From ef9eff9064d3d1ae024930d1a7792f77b4f9751e Mon Sep 17 00:00:00 2001
From: Karl Meakin <karl.meakin@arm.com>
Date: Sun, 3 May 2026 21:16:44 +0100
Subject: [PATCH 01/20] Further optimize `SliceIndex<str>` impl for
 `Range<usize>`

We can shave a further 2 `icmp`s by inlining `is_char_boundary` and rearranging
the checks.
---
 library/core/src/str/traits.rs           | 93 ++++++++++--------------
 tests/codegen-llvm/str-range-indexing.rs | 13 ++--
 2 files changed, 46 insertions(+), 60 deletions(-)

diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index 3b5cec22b69ea..21d1a5b907aa8 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -118,6 +118,35 @@ unsafe impl const SliceIndex<str> for ops::RangeFull {
     }
 }
 
+/// Check that a range is in bounds for slicing a string.
+/// If this returns true, it is safe to call `slice.get_unchecked(range)` or
+/// `slice.get_unchecked_mut(range)`.
+#[inline(always)]
+const fn check_range(slice: &str, range: crate::range::Range<usize>) -> bool {
+    let crate::range::Range { start, end } = range;
+    let bytes = slice.as_bytes();
+
+    if start > end || end > slice.len() {
+        return false;
+    }
+
+    if start == slice.len() {
+        // If `start == slice.len()`, then `end == slice.len()` must also be true.
+        return true;
+    }
+
+    // SAFETY:
+    // `start > end || end > slice.len()` is false, so `start <= end <= slice.len()` is true.
+    // `start == slice.len()` is false, so `start < slice.len()` is also true.
+    //
+    // No need to check for `end == 0`, because if `end == 0` is true then `start == slice.len()`
+    // would also be true, which is already handled above.
+    unsafe {
+        (start == 0 || bytes.as_ptr().add(start).read().is_utf8_char_boundary())
+            && (end == slice.len() || bytes.as_ptr().add(end).read().is_utf8_char_boundary())
+    }
+}
+
 /// Implements substring slicing with syntax `&self[begin .. end]` or `&mut
 /// self[begin .. end]`.
 ///
@@ -159,30 +188,11 @@ unsafe impl const SliceIndex<str> for ops::Range<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
-        if self.start <= self.end
-            && slice.is_char_boundary(self.start)
-            && slice.is_char_boundary(self.end)
-        {
-            // SAFETY: just checked that `start` and `end` are on a char boundary,
-            // and we are passing in a safe reference, so the return value will also be one.
-            // We also checked char boundaries, so this is valid UTF-8.
-            Some(unsafe { &*self.get_unchecked(slice) })
-        } else {
-            None
-        }
+        range::Range::from(self).get(slice)
     }
     #[inline]
     fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
-        if self.start <= self.end
-            && slice.is_char_boundary(self.start)
-            && slice.is_char_boundary(self.end)
-        {
-            // SAFETY: just checked that `start` and `end` are on a char boundary.
-            // We know the pointer is unique because we got it from `slice`.
-            Some(unsafe { &mut *self.get_unchecked_mut(slice) })
-        } else {
-            None
-        }
+        range::Range::from(self).get_mut(slice)
     }
     #[inline]
     #[track_caller]
@@ -235,26 +245,11 @@ unsafe impl const SliceIndex<str> for ops::Range<usize> {
     }
     #[inline]
     fn index(self, slice: &str) -> &Self::Output {
-        let (start, end) = (self.start, self.end);
-        match self.get(slice) {
-            Some(s) => s,
-            None => super::slice_error_fail(slice, start, end),
-        }
+        range::Range::from(self).index(slice)
     }
     #[inline]
     fn index_mut(self, slice: &mut str) -> &mut Self::Output {
-        // is_char_boundary checks that the index is in [0, .len()]
-        // cannot reuse `get` as above, because of NLL trouble
-        if self.start <= self.end
-            && slice.is_char_boundary(self.start)
-            && slice.is_char_boundary(self.end)
-        {
-            // SAFETY: just checked that `start` and `end` are on a char boundary,
-            // and we are passing in a safe reference, so the return value will also be one.
-            unsafe { &mut *self.get_unchecked_mut(slice) }
-        } else {
-            super::slice_error_fail(slice, self.start, self.end)
-        }
+        range::Range::from(self).index_mut(slice)
     }
 }
 
@@ -264,11 +259,8 @@ unsafe impl const SliceIndex<str> for range::Range<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
-        if self.start <= self.end
-            && slice.is_char_boundary(self.start)
-            && slice.is_char_boundary(self.end)
-        {
-            // SAFETY: just checked that `start` and `end` are on a char boundary,
+        if check_range(slice, self) {
+            // SAFETY: just checked that `self` is in bounds,
             // and we are passing in a safe reference, so the return value will also be one.
             // We also checked char boundaries, so this is valid UTF-8.
             Some(unsafe { &*self.get_unchecked(slice) })
@@ -278,11 +270,8 @@ unsafe impl const SliceIndex<str> for range::Range<usize> {
     }
     #[inline]
     fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
-        if self.start <= self.end
-            && slice.is_char_boundary(self.start)
-            && slice.is_char_boundary(self.end)
-        {
-            // SAFETY: just checked that `start` and `end` are on a char boundary.
+        if check_range(slice, self) {
+            // SAFETY: just checked that `self` is in bounds.
             // We know the pointer is unique because we got it from `slice`.
             Some(unsafe { &mut *self.get_unchecked_mut(slice) })
         } else {
@@ -348,13 +337,9 @@ unsafe impl const SliceIndex<str> for range::Range<usize> {
     }
     #[inline]
     fn index_mut(self, slice: &mut str) -> &mut Self::Output {
-        // is_char_boundary checks that the index is in [0, .len()]
         // cannot reuse `get` as above, because of NLL trouble
-        if self.start <= self.end
-            && slice.is_char_boundary(self.start)
-            && slice.is_char_boundary(self.end)
-        {
-            // SAFETY: just checked that `start` and `end` are on a char boundary,
+        if check_range(slice, self) {
+            // SAFETY: just checked that `self` is in bounds,
             // and we are passing in a safe reference, so the return value will also be one.
             unsafe { &mut *self.get_unchecked_mut(slice) }
         } else {
diff --git a/tests/codegen-llvm/str-range-indexing.rs b/tests/codegen-llvm/str-range-indexing.rs
index 5fa8e0dd17d3c..57fd886f9fc71 100644
--- a/tests/codegen-llvm/str-range-indexing.rs
+++ b/tests/codegen-llvm/str-range-indexing.rs
@@ -18,18 +18,19 @@ macro_rules! tests {
     };
 }
 
-// 9 comparisons required:
-// start <= end
-// && (start == 0 || (start >= len && start == len) || bytes[start] >= -0x40)
-// && (end   == 0 || (end   >= len && end   == len) || bytes[end]   >= -0x40)
+// 7 comparisons required:
+// start <= end && end <= len
+// && (start == len ||
+// (  (start == 0   || bytes[start] >= -0x40)
+// && (end   == len || bytes[end] >= -0x40)))
 
 // CHECK-LABEL: @get_range
-// CHECK-COUNT-9: %{{.+}} = icmp
+// CHECK-COUNT-7: %{{.+}} = icmp
 // CHECK-NOT: %{{.+}} = icmp
 // CHECK: ret
 
 // CHECK-LABEL: @index_range
-// CHECK-COUNT-9: %{{.+}} = icmp
+// CHECK-COUNT-7: %{{.+}} = icmp
 // CHECK-NOT: %{{.+}} = icmp
 // CHECK: ret
 tests!(Range<usize>, get_range, index_range);

From d2c767fc1c48ca6269750a21865c56675c29c0da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rom=C3=A1n=20C=C3=A1rdenas=20Rodr=C3=ADguez?=
 <rcardenas.rod@gmail.com>
Date: Tue, 5 May 2026 13:46:38 +0200
Subject: [PATCH 02/20] rustc: riscv: promote d, e, and f target_features to
 CfgStableToggleUnstable

---
 compiler/rustc_target/src/target_features.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index e2bf1c48b7b47..632f9c5f25700 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -610,9 +610,9 @@ static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("a", Stable, &["zaamo", "zalrsc"]),
     ("b", Stable, &["zba", "zbb", "zbs"]),
     ("c", Stable, &["zca"]),
-    ("d", Unstable(sym::riscv_target_feature), &["f"]),
-    ("e", Unstable(sym::riscv_target_feature), &[]),
-    ("f", Unstable(sym::riscv_target_feature), &["zicsr"]),
+    ("d", CfgStableToggleUnstable(sym::riscv_target_feature), &["f"]),
+    ("e", CfgStableToggleUnstable(sym::riscv_target_feature), &[]),
+    ("f", CfgStableToggleUnstable(sym::riscv_target_feature), &["zicsr"]),
     (
         "forced-atomics",
         Stability::Forbidden { reason: "unsound because it changes the ABI of atomic operations" },

From d396920b4ee9602542b9ee6282ff5a3c4c6e981f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rom=C3=A1n=20C=C3=A1rdenas=20Rodr=C3=ADguez?=
 <rcardenas.rod@gmail.com>
Date: Wed, 6 May 2026 08:13:37 +0200
Subject: [PATCH 03/20] rustc: riscv: adapt target_feature tests

---
 .../abi-incompatible-target-feature-flag-enable.riscv.stderr    | 2 +-
 .../abi-required-target-feature-flag-disable.riscv.stderr       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ui/target-feature/abi-incompatible-target-feature-flag-enable.riscv.stderr b/tests/ui/target-feature/abi-incompatible-target-feature-flag-enable.riscv.stderr
index 11ec86b1e6d85..2183513bf3b97 100644
--- a/tests/ui/target-feature/abi-incompatible-target-feature-flag-enable.riscv.stderr
+++ b/tests/ui/target-feature/abi-incompatible-target-feature-flag-enable.riscv.stderr
@@ -1,6 +1,6 @@
 warning: unstable feature specified for `-Ctarget-feature`: `d`
    |
-   = note: this feature is not stably supported; its behavior can change in the future
+   = note: this feature is allowed in cfg but unstable otherwise; its behavior can change in the future
 
 warning: target feature `d` must be disabled to ensure that the ABI of the current target can be implemented correctly
    |
diff --git a/tests/ui/target-feature/abi-required-target-feature-flag-disable.riscv.stderr b/tests/ui/target-feature/abi-required-target-feature-flag-disable.riscv.stderr
index cc225b353df13..7fa1cc299b229 100644
--- a/tests/ui/target-feature/abi-required-target-feature-flag-disable.riscv.stderr
+++ b/tests/ui/target-feature/abi-required-target-feature-flag-disable.riscv.stderr
@@ -1,6 +1,6 @@
 warning: unstable feature specified for `-Ctarget-feature`: `d`
    |
-   = note: this feature is not stably supported; its behavior can change in the future
+   = note: this feature is allowed in cfg but unstable otherwise; its behavior can change in the future
 
 warning: target feature `d` must be enabled to ensure that the ABI of the current target can be implemented correctly
    |

From 4e9a3ded2a63a567a21aa245cdd8e8a2e065d86c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rom=C3=A1n=20C=C3=A1rdenas=20Rodr=C3=ADguez?=
 <rcardenas.rod@gmail.com>
Date: Wed, 6 May 2026 11:47:21 +0200
Subject: [PATCH 04/20] rustc: riscv: add tests for cfg-only stable features

---
 ...unstable-target-feature-attribute-riscv.rs | 17 ++++++++++++++
 ...able-target-feature-attribute-riscv.stderr | 23 +++++++++++++++++++
 ...stable-target-feature-flag-enable-riscv.rs | 17 ++++++++++++++
 ...le-target-feature-flag-enable-riscv.stderr | 10 ++++++++
 4 files changed, 67 insertions(+)
 create mode 100644 tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-attribute-riscv.rs
 create mode 100644 tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-attribute-riscv.stderr
 create mode 100644 tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-flag-enable-riscv.rs
 create mode 100644 tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-flag-enable-riscv.stderr

diff --git a/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-attribute-riscv.rs b/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-attribute-riscv.rs
new file mode 100644
index 0000000000000..24d42e3df44d3
--- /dev/null
+++ b/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-attribute-riscv.rs
@@ -0,0 +1,17 @@
+//! Ensure cfg-only stable target_features trigger errors when enabled via attribute.
+//@ compile-flags: --crate-type=lib
+//@ compile-flags: --target=riscv64gc-unknown-none-elf
+//@ needs-llvm-components: riscv
+//@ add-minicore
+//@ ignore-backends: gcc
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[target_feature(enable = "v")]
+//~^ERROR: the target feature `v` is currently unstable
+#[target_feature(enable = "f")]
+//~^ERROR: the target feature `f` is allowed in cfg but unstable otherwise
+pub unsafe fn my_fun() {}
diff --git a/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-attribute-riscv.stderr b/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-attribute-riscv.stderr
new file mode 100644
index 0000000000000..7f13c11798fcf
--- /dev/null
+++ b/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-attribute-riscv.stderr
@@ -0,0 +1,23 @@
+error[E0658]: the target feature `v` is currently unstable
+  --> $DIR/cfg-stable-toggle-unstable-target-feature-attribute-riscv.rs:13:18
+   |
+LL | #[target_feature(enable = "v")]
+   |                  ^^^^^^^^^^^^
+   |
+   = note: see issue #150257 <https://github.com/rust-lang/rust/issues/150257> for more information
+   = help: add `#![feature(riscv_target_feature)]` 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 target feature `f` is allowed in cfg but unstable otherwise
+  --> $DIR/cfg-stable-toggle-unstable-target-feature-attribute-riscv.rs:15:18
+   |
+LL | #[target_feature(enable = "f")]
+   |                  ^^^^^^^^^^^^
+   |
+   = note: see issue #150257 <https://github.com/rust-lang/rust/issues/150257> for more information
+   = help: add `#![feature(riscv_target_feature)]` 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/target-feature/cfg-stable-toggle-unstable-target-feature-flag-enable-riscv.rs b/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-flag-enable-riscv.rs
new file mode 100644
index 0000000000000..ab2b75ed5190f
--- /dev/null
+++ b/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-flag-enable-riscv.rs
@@ -0,0 +1,17 @@
+//! Ensure cfg-only stable target_features trigger warnings when enabled via compile flag.
+//@ check-pass
+//@ compile-flags: --crate-type=lib
+//@ compile-flags: --target=riscv64gc-unknown-none-elf -Ctarget-feature=+v -Ctarget-feature=+f
+// FIXME(#147881): *disable* the feature again for minicore as otherwise that will fail to build.
+//@ minicore-compile-flags: -Ctarget-feature=-v -Ctarget-feature=-f
+//@ needs-llvm-components: riscv
+//@ ignore-backends: gcc
+//@ add-minicore
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+//~? WARN unstable feature specified for `-Ctarget-feature`
+//~? WARN unstable feature specified for `-Ctarget-feature`
diff --git a/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-flag-enable-riscv.stderr b/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-flag-enable-riscv.stderr
new file mode 100644
index 0000000000000..b0167221aabaa
--- /dev/null
+++ b/tests/ui/target-feature/cfg-stable-toggle-unstable-target-feature-flag-enable-riscv.stderr
@@ -0,0 +1,10 @@
+warning: unstable feature specified for `-Ctarget-feature`: `v`
+   |
+   = note: this feature is not stably supported; its behavior can change in the future
+
+warning: unstable feature specified for `-Ctarget-feature`: `f`
+   |
+   = note: this feature is allowed in cfg but unstable otherwise; its behavior can change in the future
+
+warning: 2 warnings emitted
+

From 355b5011532d35913ed3e942969974cf1bfcad60 Mon Sep 17 00:00:00 2001
From: majiayu000 <1835304752@qq.com>
Date: Wed, 3 Jun 2026 00:15:19 +0800
Subject: [PATCH 05/20] Document Repeat::last panic behavior

---
 library/core/src/iter/sources/repeat.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/library/core/src/iter/sources/repeat.rs b/library/core/src/iter/sources/repeat.rs
index f578ae86a9fce..197b5f2124235 100644
--- a/library/core/src/iter/sources/repeat.rs
+++ b/library/core/src/iter/sources/repeat.rs
@@ -101,6 +101,11 @@ impl<A: Clone> Iterator for Repeat<A> {
         Some(self.element.clone())
     }
 
+    /// Consumes the iterator and panics.
+    ///
+    /// # Panics
+    ///
+    /// This method always panics because `Repeat` is infinite.
     #[track_caller]
     fn last(self) -> Option<A> {
         panic!("iterator is infinite");

From 17ebb8f376e65c52bee1417988cea33948d66935 Mon Sep 17 00:00:00 2001
From: danieljofficial <joenah004@gmail.com>
Date: Tue, 19 May 2026 12:39:35 +0100
Subject: [PATCH 06/20] move cross crate tests out of ui/issues

---
 .../auxiliary/const-fn-evaluated-cross-crate.rs}                  | 0
 .../auxiliary/construct-extern-struct-with-destructor.rs}         | 0
 .../auxiliary/cross-crate-static-reference-and-field-access.rs}   | 0
 .../auxiliary/cross-crate-trait-inheritance-on-default-method.rs} | 0
 .../auxiliary/cross-crate-type-alias-with-nested-destructors.rs}  | 0
 .../default-trait-method-reachable-through-trait-object.rs}       | 0
 .../auxiliary/extern-crate-and-impl-inside-method-body.rs}        | 0
 .../auxiliary/extern-generic-tuple-struct-construction.rs}        | 0
 .../auxiliary/extern-repr-enum-with-discriminant-cast.rs}         | 0
 .../auxiliary/extern-trait-bound-with-array-associated-type.rs}   | 0
 .../auxiliary/fn-declared-inside-closure-body-cross-crate.rs}     | 0
 .../auxiliary/fn-local-impl-returned-as-trait-object.rs}          | 0
 .../auxiliary/generic-fn-with-supertrait-bound-cross-crate.rs}    | 0
 .../auxiliary/graceful-error-for-mistyped-assoc-const.rs}         | 0
 .../auxiliary/impl-extern-trait-with-associated-type.rs}          | 0
 .../auxiliary/imported-struct-not-confused-with-variant.rs}       | 0
 .../auxiliary/link-extern-crate-with-drop-type.rs}                | 0
 .../auxiliary/macro-generated-module-path-resolution.rs}          | 0
 .../auxiliary/method-call-on-extern-fn-return-value.rs}           | 0
 .../auxiliary/monomorphize-index-op-cross-crate.rs}               | 0
 .../auxiliary/mut-ref-write-visible-after-unwind.rs}              | 0
 .../auxiliary/nested-struct-in-polymorphic-impl-method.rs}        | 0
 .../no-duplicate-symbols-with-codegen-units-cgu-test-a.rs}        | 0
 .../no-duplicate-symbols-with-codegen-units-cgu-test-b.rs}        | 0
 .../no-duplicate-symbols-with-codegen-units-cgu-test.rs}          | 0
 .../auxiliary/optimized-closure-with-debug-info-cross-crate-1.rs} | 0
 .../auxiliary/optimized-closure-with-debug-info-cross-crate-2.rs} | 0
 .../auxiliary/stable-hash-for-trait-object-type.rs}               | 0
 .../trait-object-projection-bounds-with-interning-order.rs}       | 0
 .../auxiliary/transitive-crate-dependency-with-trait-impl-a.rs}   | 0
 .../auxiliary/transitive-crate-dependency-with-trait-impl-b.rs}   | 0
 .../type-default-applied-in-cross-crate-method-lookup.rs}         | 0
 .../const-fn-evaluated-cross-crate.rs}                            | 0
 .../construct-extern-struct-with-destructor.rs}                   | 0
 .../cross-crate-static-reference-and-field-access.rs}             | 0
 .../cross-crate-trait-inheritance-on-default-method.rs}           | 0
 .../cross-crate-type-alias-with-nested-destructors.rs}            | 0
 .../default-trait-method-reachable-through-trait-object.rs}       | 0
 .../extern-crate-and-impl-inside-method-body.rs}                  | 0
 .../extern-generic-tuple-struct-construction.rs}                  | 0
 .../extern-repr-enum-with-discriminant-cast.rs}                   | 0
 .../extern-trait-bound-with-array-associated-type.rs}             | 0
 .../fn-declared-inside-closure-body-cross-crate.rs}               | 0
 .../fn-local-impl-returned-as-trait-object.rs}                    | 0
 .../generic-fn-with-supertrait-bound-cross-crate.rs}              | 0
 .../graceful-error-for-mistyped-assoc-const.rs}                   | 0
 .../graceful-error-for-mistyped-assoc-const.stderr}               | 0
 .../impl-extern-trait-with-associated-type.rs}                    | 0
 .../imported-struct-not-confused-with-variant.rs}                 | 0
 .../link-extern-crate-with-drop-type.rs}                          | 0
 .../macro-generated-module-path-resolution.rs}                    | 0
 .../method-call-on-extern-fn-return-value.rs}                     | 0
 .../monomorphize-index-op-cross-crate.rs}                         | 0
 .../mut-ref-write-visible-after-unwind.rs}                        | 0
 .../nested-struct-in-polymorphic-impl-method.rs}                  | 0
 .../no-duplicate-symbols-with-codegen-units.rs}                   | 0
 .../optimized-closure-with-debug-info-cross-crate.rs}             | 0
 .../stable-hash-for-trait-object-type.rs}                         | 0
 .../trait-object-projection-bounds-with-interning-order.rs}       | 0
 .../transitive-crate-dependency-with-trait-impl.rs}               | 0
 .../type-default-applied-in-cross-crate-method-lookup.rs}         | 0
 .../type-default-applied-in-cross-crate-method-lookup.stderr}     | 0
 62 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/{issues/auxiliary/issue-36954.rs => cross-crate/auxiliary/const-fn-evaluated-cross-crate.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-3012-1.rs => cross-crate/auxiliary/construct-extern-struct-with-destructor.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-29265.rs => cross-crate/auxiliary/cross-crate-static-reference-and-field-access.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-3979-traits.rs => cross-crate/auxiliary/cross-crate-trait-inheritance-on-default-method.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-2526.rs => cross-crate/auxiliary/cross-crate-type-alias-with-nested-destructors.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-38226-aux.rs => cross-crate/auxiliary/default-trait-method-reachable-through-trait-object.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-41053.rs => cross-crate/auxiliary/extern-crate-and-impl-inside-method-body.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-4545.rs => cross-crate/auxiliary/extern-generic-tuple-struct-construction.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-42007-s.rs => cross-crate/auxiliary/extern-repr-enum-with-discriminant-cast.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-48984-aux.rs => cross-crate/auxiliary/extern-trait-bound-with-array-associated-type.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-2723-a.rs => cross-crate/auxiliary/fn-declared-inside-closure-body-cross-crate.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-2380.rs => cross-crate/auxiliary/fn-local-impl-returned-as-trait-object.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-4208-cc.rs => cross-crate/auxiliary/generic-fn-with-supertrait-bound-cross-crate.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-41549.rs => cross-crate/auxiliary/graceful-error-for-mistyped-assoc-const.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-20389.rs => cross-crate/auxiliary/impl-extern-trait-with-associated-type.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-19293.rs => cross-crate/auxiliary/imported-struct-not-confused-with-variant.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-2170-lib.rs => cross-crate/auxiliary/link-extern-crate-with-drop-type.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-38190.rs => cross-crate/auxiliary/macro-generated-module-path-resolution.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-51798.rs => cross-crate/auxiliary/method-call-on-extern-fn-return-value.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-2631-a.rs => cross-crate/auxiliary/monomorphize-index-op-cross-crate.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-29485.rs => cross-crate/auxiliary/mut-ref-write-visible-after-unwind.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-3136-a.rs => cross-crate/auxiliary/nested-struct-in-polymorphic-impl-method.rs} (100%)
 rename tests/ui/{issues/auxiliary/cgu_test_a.rs => cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-a.rs} (100%)
 rename tests/ui/{issues/auxiliary/cgu_test_b.rs => cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-b.rs} (100%)
 rename tests/ui/{issues/auxiliary/cgu_test.rs => cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-31702-1.rs => cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-1.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-31702-2.rs => cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-2.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-34796-aux.rs => cross-crate/auxiliary/stable-hash-for-trait-object-type.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-25467.rs => cross-crate/auxiliary/trait-object-projection-bounds-with-interning-order.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-2414-a.rs => cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-a.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-2414-b.rs => cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-b.rs} (100%)
 rename tests/ui/{issues/auxiliary/issue-30123-aux.rs => cross-crate/auxiliary/type-default-applied-in-cross-crate-method-lookup.rs} (100%)
 rename tests/ui/{issues/issue-36954.rs => cross-crate/const-fn-evaluated-cross-crate.rs} (100%)
 rename tests/ui/{issues/issue-3012-2.rs => cross-crate/construct-extern-struct-with-destructor.rs} (100%)
 rename tests/ui/{issues/issue-29265.rs => cross-crate/cross-crate-static-reference-and-field-access.rs} (100%)
 rename tests/ui/{issues/issue-3979-xcrate.rs => cross-crate/cross-crate-trait-inheritance-on-default-method.rs} (100%)
 rename tests/ui/{issues/issue-2526-a.rs => cross-crate/cross-crate-type-alias-with-nested-destructors.rs} (100%)
 rename tests/ui/{issues/issue-38226.rs => cross-crate/default-trait-method-reachable-through-trait-object.rs} (100%)
 rename tests/ui/{issues/issue-41053.rs => cross-crate/extern-crate-and-impl-inside-method-body.rs} (100%)
 rename tests/ui/{issues/issue-4545.rs => cross-crate/extern-generic-tuple-struct-construction.rs} (100%)
 rename tests/ui/{issues/issue-42007.rs => cross-crate/extern-repr-enum-with-discriminant-cast.rs} (100%)
 rename tests/ui/{issues/issue-48984.rs => cross-crate/extern-trait-bound-with-array-associated-type.rs} (100%)
 rename tests/ui/{issues/issue-2723-b.rs => cross-crate/fn-declared-inside-closure-body-cross-crate.rs} (100%)
 rename tests/ui/{issues/issue-2380-b.rs => cross-crate/fn-local-impl-returned-as-trait-object.rs} (100%)
 rename tests/ui/{issues/issue-4208.rs => cross-crate/generic-fn-with-supertrait-bound-cross-crate.rs} (100%)
 rename tests/ui/{issues/issue-41549.rs => cross-crate/graceful-error-for-mistyped-assoc-const.rs} (100%)
 rename tests/ui/{issues/issue-41549.stderr => cross-crate/graceful-error-for-mistyped-assoc-const.stderr} (100%)
 rename tests/ui/{issues/issue-20389.rs => cross-crate/impl-extern-trait-with-associated-type.rs} (100%)
 rename tests/ui/{issues/issue-19293.rs => cross-crate/imported-struct-not-confused-with-variant.rs} (100%)
 rename tests/ui/{issues/issue-2170-exe.rs => cross-crate/link-extern-crate-with-drop-type.rs} (100%)
 rename tests/ui/{issues/issue-38190.rs => cross-crate/macro-generated-module-path-resolution.rs} (100%)
 rename tests/ui/{issues/issue-51798.rs => cross-crate/method-call-on-extern-fn-return-value.rs} (100%)
 rename tests/ui/{issues/issue-2631-b.rs => cross-crate/monomorphize-index-op-cross-crate.rs} (100%)
 rename tests/ui/{issues/issue-29485.rs => cross-crate/mut-ref-write-visible-after-unwind.rs} (100%)
 rename tests/ui/{issues/issue-3136-b.rs => cross-crate/nested-struct-in-polymorphic-impl-method.rs} (100%)
 rename tests/ui/{issues/issue-32518.rs => cross-crate/no-duplicate-symbols-with-codegen-units.rs} (100%)
 rename tests/ui/{issues/issue-31702.rs => cross-crate/optimized-closure-with-debug-info-cross-crate.rs} (100%)
 rename tests/ui/{issues/issue-34796.rs => cross-crate/stable-hash-for-trait-object-type.rs} (100%)
 rename tests/ui/{issues/issue-25467.rs => cross-crate/trait-object-projection-bounds-with-interning-order.rs} (100%)
 rename tests/ui/{issues/issue-2414-c.rs => cross-crate/transitive-crate-dependency-with-trait-impl.rs} (100%)
 rename tests/ui/{issues/issue-30123.rs => cross-crate/type-default-applied-in-cross-crate-method-lookup.rs} (100%)
 rename tests/ui/{issues/issue-30123.stderr => cross-crate/type-default-applied-in-cross-crate-method-lookup.stderr} (100%)

diff --git a/tests/ui/issues/auxiliary/issue-36954.rs b/tests/ui/cross-crate/auxiliary/const-fn-evaluated-cross-crate.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-36954.rs
rename to tests/ui/cross-crate/auxiliary/const-fn-evaluated-cross-crate.rs
diff --git a/tests/ui/issues/auxiliary/issue-3012-1.rs b/tests/ui/cross-crate/auxiliary/construct-extern-struct-with-destructor.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-3012-1.rs
rename to tests/ui/cross-crate/auxiliary/construct-extern-struct-with-destructor.rs
diff --git a/tests/ui/issues/auxiliary/issue-29265.rs b/tests/ui/cross-crate/auxiliary/cross-crate-static-reference-and-field-access.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-29265.rs
rename to tests/ui/cross-crate/auxiliary/cross-crate-static-reference-and-field-access.rs
diff --git a/tests/ui/issues/auxiliary/issue-3979-traits.rs b/tests/ui/cross-crate/auxiliary/cross-crate-trait-inheritance-on-default-method.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-3979-traits.rs
rename to tests/ui/cross-crate/auxiliary/cross-crate-trait-inheritance-on-default-method.rs
diff --git a/tests/ui/issues/auxiliary/issue-2526.rs b/tests/ui/cross-crate/auxiliary/cross-crate-type-alias-with-nested-destructors.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-2526.rs
rename to tests/ui/cross-crate/auxiliary/cross-crate-type-alias-with-nested-destructors.rs
diff --git a/tests/ui/issues/auxiliary/issue-38226-aux.rs b/tests/ui/cross-crate/auxiliary/default-trait-method-reachable-through-trait-object.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-38226-aux.rs
rename to tests/ui/cross-crate/auxiliary/default-trait-method-reachable-through-trait-object.rs
diff --git a/tests/ui/issues/auxiliary/issue-41053.rs b/tests/ui/cross-crate/auxiliary/extern-crate-and-impl-inside-method-body.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-41053.rs
rename to tests/ui/cross-crate/auxiliary/extern-crate-and-impl-inside-method-body.rs
diff --git a/tests/ui/issues/auxiliary/issue-4545.rs b/tests/ui/cross-crate/auxiliary/extern-generic-tuple-struct-construction.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-4545.rs
rename to tests/ui/cross-crate/auxiliary/extern-generic-tuple-struct-construction.rs
diff --git a/tests/ui/issues/auxiliary/issue-42007-s.rs b/tests/ui/cross-crate/auxiliary/extern-repr-enum-with-discriminant-cast.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-42007-s.rs
rename to tests/ui/cross-crate/auxiliary/extern-repr-enum-with-discriminant-cast.rs
diff --git a/tests/ui/issues/auxiliary/issue-48984-aux.rs b/tests/ui/cross-crate/auxiliary/extern-trait-bound-with-array-associated-type.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-48984-aux.rs
rename to tests/ui/cross-crate/auxiliary/extern-trait-bound-with-array-associated-type.rs
diff --git a/tests/ui/issues/auxiliary/issue-2723-a.rs b/tests/ui/cross-crate/auxiliary/fn-declared-inside-closure-body-cross-crate.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-2723-a.rs
rename to tests/ui/cross-crate/auxiliary/fn-declared-inside-closure-body-cross-crate.rs
diff --git a/tests/ui/issues/auxiliary/issue-2380.rs b/tests/ui/cross-crate/auxiliary/fn-local-impl-returned-as-trait-object.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-2380.rs
rename to tests/ui/cross-crate/auxiliary/fn-local-impl-returned-as-trait-object.rs
diff --git a/tests/ui/issues/auxiliary/issue-4208-cc.rs b/tests/ui/cross-crate/auxiliary/generic-fn-with-supertrait-bound-cross-crate.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-4208-cc.rs
rename to tests/ui/cross-crate/auxiliary/generic-fn-with-supertrait-bound-cross-crate.rs
diff --git a/tests/ui/issues/auxiliary/issue-41549.rs b/tests/ui/cross-crate/auxiliary/graceful-error-for-mistyped-assoc-const.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-41549.rs
rename to tests/ui/cross-crate/auxiliary/graceful-error-for-mistyped-assoc-const.rs
diff --git a/tests/ui/issues/auxiliary/issue-20389.rs b/tests/ui/cross-crate/auxiliary/impl-extern-trait-with-associated-type.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-20389.rs
rename to tests/ui/cross-crate/auxiliary/impl-extern-trait-with-associated-type.rs
diff --git a/tests/ui/issues/auxiliary/issue-19293.rs b/tests/ui/cross-crate/auxiliary/imported-struct-not-confused-with-variant.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-19293.rs
rename to tests/ui/cross-crate/auxiliary/imported-struct-not-confused-with-variant.rs
diff --git a/tests/ui/issues/auxiliary/issue-2170-lib.rs b/tests/ui/cross-crate/auxiliary/link-extern-crate-with-drop-type.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-2170-lib.rs
rename to tests/ui/cross-crate/auxiliary/link-extern-crate-with-drop-type.rs
diff --git a/tests/ui/issues/auxiliary/issue-38190.rs b/tests/ui/cross-crate/auxiliary/macro-generated-module-path-resolution.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-38190.rs
rename to tests/ui/cross-crate/auxiliary/macro-generated-module-path-resolution.rs
diff --git a/tests/ui/issues/auxiliary/issue-51798.rs b/tests/ui/cross-crate/auxiliary/method-call-on-extern-fn-return-value.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-51798.rs
rename to tests/ui/cross-crate/auxiliary/method-call-on-extern-fn-return-value.rs
diff --git a/tests/ui/issues/auxiliary/issue-2631-a.rs b/tests/ui/cross-crate/auxiliary/monomorphize-index-op-cross-crate.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-2631-a.rs
rename to tests/ui/cross-crate/auxiliary/monomorphize-index-op-cross-crate.rs
diff --git a/tests/ui/issues/auxiliary/issue-29485.rs b/tests/ui/cross-crate/auxiliary/mut-ref-write-visible-after-unwind.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-29485.rs
rename to tests/ui/cross-crate/auxiliary/mut-ref-write-visible-after-unwind.rs
diff --git a/tests/ui/issues/auxiliary/issue-3136-a.rs b/tests/ui/cross-crate/auxiliary/nested-struct-in-polymorphic-impl-method.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-3136-a.rs
rename to tests/ui/cross-crate/auxiliary/nested-struct-in-polymorphic-impl-method.rs
diff --git a/tests/ui/issues/auxiliary/cgu_test_a.rs b/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-a.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/cgu_test_a.rs
rename to tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-a.rs
diff --git a/tests/ui/issues/auxiliary/cgu_test_b.rs b/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-b.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/cgu_test_b.rs
rename to tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-b.rs
diff --git a/tests/ui/issues/auxiliary/cgu_test.rs b/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/cgu_test.rs
rename to tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test.rs
diff --git a/tests/ui/issues/auxiliary/issue-31702-1.rs b/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-1.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-31702-1.rs
rename to tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-1.rs
diff --git a/tests/ui/issues/auxiliary/issue-31702-2.rs b/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-2.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-31702-2.rs
rename to tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-2.rs
diff --git a/tests/ui/issues/auxiliary/issue-34796-aux.rs b/tests/ui/cross-crate/auxiliary/stable-hash-for-trait-object-type.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-34796-aux.rs
rename to tests/ui/cross-crate/auxiliary/stable-hash-for-trait-object-type.rs
diff --git a/tests/ui/issues/auxiliary/issue-25467.rs b/tests/ui/cross-crate/auxiliary/trait-object-projection-bounds-with-interning-order.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-25467.rs
rename to tests/ui/cross-crate/auxiliary/trait-object-projection-bounds-with-interning-order.rs
diff --git a/tests/ui/issues/auxiliary/issue-2414-a.rs b/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-a.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-2414-a.rs
rename to tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-a.rs
diff --git a/tests/ui/issues/auxiliary/issue-2414-b.rs b/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-b.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-2414-b.rs
rename to tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-b.rs
diff --git a/tests/ui/issues/auxiliary/issue-30123-aux.rs b/tests/ui/cross-crate/auxiliary/type-default-applied-in-cross-crate-method-lookup.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-30123-aux.rs
rename to tests/ui/cross-crate/auxiliary/type-default-applied-in-cross-crate-method-lookup.rs
diff --git a/tests/ui/issues/issue-36954.rs b/tests/ui/cross-crate/const-fn-evaluated-cross-crate.rs
similarity index 100%
rename from tests/ui/issues/issue-36954.rs
rename to tests/ui/cross-crate/const-fn-evaluated-cross-crate.rs
diff --git a/tests/ui/issues/issue-3012-2.rs b/tests/ui/cross-crate/construct-extern-struct-with-destructor.rs
similarity index 100%
rename from tests/ui/issues/issue-3012-2.rs
rename to tests/ui/cross-crate/construct-extern-struct-with-destructor.rs
diff --git a/tests/ui/issues/issue-29265.rs b/tests/ui/cross-crate/cross-crate-static-reference-and-field-access.rs
similarity index 100%
rename from tests/ui/issues/issue-29265.rs
rename to tests/ui/cross-crate/cross-crate-static-reference-and-field-access.rs
diff --git a/tests/ui/issues/issue-3979-xcrate.rs b/tests/ui/cross-crate/cross-crate-trait-inheritance-on-default-method.rs
similarity index 100%
rename from tests/ui/issues/issue-3979-xcrate.rs
rename to tests/ui/cross-crate/cross-crate-trait-inheritance-on-default-method.rs
diff --git a/tests/ui/issues/issue-2526-a.rs b/tests/ui/cross-crate/cross-crate-type-alias-with-nested-destructors.rs
similarity index 100%
rename from tests/ui/issues/issue-2526-a.rs
rename to tests/ui/cross-crate/cross-crate-type-alias-with-nested-destructors.rs
diff --git a/tests/ui/issues/issue-38226.rs b/tests/ui/cross-crate/default-trait-method-reachable-through-trait-object.rs
similarity index 100%
rename from tests/ui/issues/issue-38226.rs
rename to tests/ui/cross-crate/default-trait-method-reachable-through-trait-object.rs
diff --git a/tests/ui/issues/issue-41053.rs b/tests/ui/cross-crate/extern-crate-and-impl-inside-method-body.rs
similarity index 100%
rename from tests/ui/issues/issue-41053.rs
rename to tests/ui/cross-crate/extern-crate-and-impl-inside-method-body.rs
diff --git a/tests/ui/issues/issue-4545.rs b/tests/ui/cross-crate/extern-generic-tuple-struct-construction.rs
similarity index 100%
rename from tests/ui/issues/issue-4545.rs
rename to tests/ui/cross-crate/extern-generic-tuple-struct-construction.rs
diff --git a/tests/ui/issues/issue-42007.rs b/tests/ui/cross-crate/extern-repr-enum-with-discriminant-cast.rs
similarity index 100%
rename from tests/ui/issues/issue-42007.rs
rename to tests/ui/cross-crate/extern-repr-enum-with-discriminant-cast.rs
diff --git a/tests/ui/issues/issue-48984.rs b/tests/ui/cross-crate/extern-trait-bound-with-array-associated-type.rs
similarity index 100%
rename from tests/ui/issues/issue-48984.rs
rename to tests/ui/cross-crate/extern-trait-bound-with-array-associated-type.rs
diff --git a/tests/ui/issues/issue-2723-b.rs b/tests/ui/cross-crate/fn-declared-inside-closure-body-cross-crate.rs
similarity index 100%
rename from tests/ui/issues/issue-2723-b.rs
rename to tests/ui/cross-crate/fn-declared-inside-closure-body-cross-crate.rs
diff --git a/tests/ui/issues/issue-2380-b.rs b/tests/ui/cross-crate/fn-local-impl-returned-as-trait-object.rs
similarity index 100%
rename from tests/ui/issues/issue-2380-b.rs
rename to tests/ui/cross-crate/fn-local-impl-returned-as-trait-object.rs
diff --git a/tests/ui/issues/issue-4208.rs b/tests/ui/cross-crate/generic-fn-with-supertrait-bound-cross-crate.rs
similarity index 100%
rename from tests/ui/issues/issue-4208.rs
rename to tests/ui/cross-crate/generic-fn-with-supertrait-bound-cross-crate.rs
diff --git a/tests/ui/issues/issue-41549.rs b/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.rs
similarity index 100%
rename from tests/ui/issues/issue-41549.rs
rename to tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.rs
diff --git a/tests/ui/issues/issue-41549.stderr b/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.stderr
similarity index 100%
rename from tests/ui/issues/issue-41549.stderr
rename to tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.stderr
diff --git a/tests/ui/issues/issue-20389.rs b/tests/ui/cross-crate/impl-extern-trait-with-associated-type.rs
similarity index 100%
rename from tests/ui/issues/issue-20389.rs
rename to tests/ui/cross-crate/impl-extern-trait-with-associated-type.rs
diff --git a/tests/ui/issues/issue-19293.rs b/tests/ui/cross-crate/imported-struct-not-confused-with-variant.rs
similarity index 100%
rename from tests/ui/issues/issue-19293.rs
rename to tests/ui/cross-crate/imported-struct-not-confused-with-variant.rs
diff --git a/tests/ui/issues/issue-2170-exe.rs b/tests/ui/cross-crate/link-extern-crate-with-drop-type.rs
similarity index 100%
rename from tests/ui/issues/issue-2170-exe.rs
rename to tests/ui/cross-crate/link-extern-crate-with-drop-type.rs
diff --git a/tests/ui/issues/issue-38190.rs b/tests/ui/cross-crate/macro-generated-module-path-resolution.rs
similarity index 100%
rename from tests/ui/issues/issue-38190.rs
rename to tests/ui/cross-crate/macro-generated-module-path-resolution.rs
diff --git a/tests/ui/issues/issue-51798.rs b/tests/ui/cross-crate/method-call-on-extern-fn-return-value.rs
similarity index 100%
rename from tests/ui/issues/issue-51798.rs
rename to tests/ui/cross-crate/method-call-on-extern-fn-return-value.rs
diff --git a/tests/ui/issues/issue-2631-b.rs b/tests/ui/cross-crate/monomorphize-index-op-cross-crate.rs
similarity index 100%
rename from tests/ui/issues/issue-2631-b.rs
rename to tests/ui/cross-crate/monomorphize-index-op-cross-crate.rs
diff --git a/tests/ui/issues/issue-29485.rs b/tests/ui/cross-crate/mut-ref-write-visible-after-unwind.rs
similarity index 100%
rename from tests/ui/issues/issue-29485.rs
rename to tests/ui/cross-crate/mut-ref-write-visible-after-unwind.rs
diff --git a/tests/ui/issues/issue-3136-b.rs b/tests/ui/cross-crate/nested-struct-in-polymorphic-impl-method.rs
similarity index 100%
rename from tests/ui/issues/issue-3136-b.rs
rename to tests/ui/cross-crate/nested-struct-in-polymorphic-impl-method.rs
diff --git a/tests/ui/issues/issue-32518.rs b/tests/ui/cross-crate/no-duplicate-symbols-with-codegen-units.rs
similarity index 100%
rename from tests/ui/issues/issue-32518.rs
rename to tests/ui/cross-crate/no-duplicate-symbols-with-codegen-units.rs
diff --git a/tests/ui/issues/issue-31702.rs b/tests/ui/cross-crate/optimized-closure-with-debug-info-cross-crate.rs
similarity index 100%
rename from tests/ui/issues/issue-31702.rs
rename to tests/ui/cross-crate/optimized-closure-with-debug-info-cross-crate.rs
diff --git a/tests/ui/issues/issue-34796.rs b/tests/ui/cross-crate/stable-hash-for-trait-object-type.rs
similarity index 100%
rename from tests/ui/issues/issue-34796.rs
rename to tests/ui/cross-crate/stable-hash-for-trait-object-type.rs
diff --git a/tests/ui/issues/issue-25467.rs b/tests/ui/cross-crate/trait-object-projection-bounds-with-interning-order.rs
similarity index 100%
rename from tests/ui/issues/issue-25467.rs
rename to tests/ui/cross-crate/trait-object-projection-bounds-with-interning-order.rs
diff --git a/tests/ui/issues/issue-2414-c.rs b/tests/ui/cross-crate/transitive-crate-dependency-with-trait-impl.rs
similarity index 100%
rename from tests/ui/issues/issue-2414-c.rs
rename to tests/ui/cross-crate/transitive-crate-dependency-with-trait-impl.rs
diff --git a/tests/ui/issues/issue-30123.rs b/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.rs
similarity index 100%
rename from tests/ui/issues/issue-30123.rs
rename to tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.rs
diff --git a/tests/ui/issues/issue-30123.stderr b/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.stderr
similarity index 100%
rename from tests/ui/issues/issue-30123.stderr
rename to tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.stderr

From 1e1560b5bef4b3fa74f419da6786caaa0d199bf7 Mon Sep 17 00:00:00 2001
From: danieljofficial <joenah004@gmail.com>
Date: Thu, 4 Jun 2026 13:04:43 +0100
Subject: [PATCH 07/20] add issue links and bless

---
 .../auxiliary/const-fn-evaluated-cross-crate.rs      |  1 +
 .../construct-extern-struct-with-destructor.rs       |  3 ++-
 .../cross-crate-static-reference-and-field-access.rs |  1 +
 ...ross-crate-trait-inheritance-on-default-method.rs |  3 ++-
 ...cross-crate-type-alias-with-nested-destructors.rs |  3 ++-
 ...lt-trait-method-reachable-through-trait-object.rs |  1 +
 .../extern-crate-and-impl-inside-method-body.rs      |  1 +
 .../extern-generic-tuple-struct-construction.rs      |  1 +
 .../extern-repr-enum-with-discriminant-cast.rs       |  1 +
 .../extern-trait-bound-with-array-associated-type.rs |  3 ++-
 .../fn-declared-inside-closure-body-cross-crate.rs   |  1 +
 .../fn-local-impl-returned-as-trait-object.rs        |  1 +
 .../auxiliary/for-loop-in-match-on-self.rs           |  3 +--
 .../generic-fn-with-supertrait-bound-cross-crate.rs  |  3 ++-
 .../graceful-error-for-mistyped-assoc-const.rs       |  1 +
 .../impl-extern-trait-with-associated-type.rs        |  1 +
 .../imported-struct-not-confused-with-variant.rs     |  1 +
 .../auxiliary/link-extern-crate-with-drop-type.rs    |  1 +
 .../macro-generated-module-path-resolution.rs        |  1 +
 .../method-call-on-extern-fn-return-value.rs         |  1 +
 .../auxiliary/monomorphize-index-op-cross-crate.rs   |  1 +
 .../auxiliary/mut-ref-write-visible-after-unwind.rs  |  3 ++-
 .../nested-struct-in-polymorphic-impl-method.rs      |  1 +
 ...uplicate-symbols-with-codegen-units-cgu-test-a.rs |  3 ++-
 ...uplicate-symbols-with-codegen-units-cgu-test-b.rs |  3 ++-
 ...-duplicate-symbols-with-codegen-units-cgu-test.rs |  1 +
 ...ptimized-closure-with-debug-info-cross-crate-1.rs |  1 +
 ...ptimized-closure-with-debug-info-cross-crate-2.rs |  5 +++--
 .../auxiliary/stable-hash-for-trait-object-type.rs   |  1 +
 ...-object-projection-bounds-with-interning-order.rs |  1 +
 .../transitive-crate-dependency-with-trait-impl-a.rs |  1 +
 .../transitive-crate-dependency-with-trait-impl-b.rs |  1 +
 ...e-default-applied-in-cross-crate-method-lookup.rs |  1 +
 .../ui/cross-crate/const-fn-evaluated-cross-crate.rs |  8 ++++++--
 .../construct-extern-struct-with-destructor.rs       |  6 ++++--
 .../cross-crate-static-reference-and-field-access.rs |  8 ++++++--
 ...ross-crate-trait-inheritance-on-default-method.rs |  6 ++++--
 ...cross-crate-type-alias-with-nested-destructors.rs |  7 ++++---
 ...lt-trait-method-reachable-through-trait-object.rs |  4 ++--
 .../extern-crate-and-impl-inside-method-body.rs      |  9 +++++++--
 .../extern-generic-tuple-struct-construction.rs      |  6 +++---
 .../extern-repr-enum-with-discriminant-cast.rs       | 10 +++++++---
 .../extern-trait-bound-with-array-associated-type.rs | 10 ++++++++--
 .../fn-declared-inside-closure-body-cross-crate.rs   |  8 +++++---
 .../fn-local-impl-returned-as-trait-object.rs        |  7 +++++--
 .../generic-fn-with-supertrait-bound-cross-crate.rs  |  6 +++---
 .../graceful-error-for-mistyped-assoc-const.rs       |  9 +++++----
 .../graceful-error-for-mistyped-assoc-const.stderr   |  2 +-
 .../impl-extern-trait-with-associated-type.rs        | 10 ++++++----
 .../imported-struct-not-confused-with-variant.rs     |  9 ++++++---
 .../cross-crate/link-extern-crate-with-drop-type.rs  |  7 +++++--
 .../macro-generated-module-path-resolution.rs        | 12 ++++++++----
 .../method-call-on-extern-fn-return-value.rs         |  8 ++++++--
 .../cross-crate/monomorphize-index-op-cross-crate.rs |  4 +++-
 .../mut-ref-write-visible-after-unwind.rs            |  8 +++++---
 .../nested-struct-in-polymorphic-impl-method.rs      |  5 +++--
 .../no-duplicate-symbols-with-codegen-units.rs       | 11 ++++++-----
 .../optimized-closure-with-debug-info-cross-crate.rs |  9 +++++----
 .../cross-crate/stable-hash-for-trait-object-type.rs |  5 +++--
 ...-object-projection-bounds-with-interning-order.rs |  6 ++++--
 .../transitive-crate-dependency-with-trait-impl.rs   |  5 +++--
 ...e-default-applied-in-cross-crate-method-lookup.rs |  7 ++++---
 ...fault-applied-in-cross-crate-method-lookup.stderr | 12 ++++++------
 .../duplicate-rlib-crate-name-precedence-1.rs        |  3 +--
 .../duplicate-rlib-crate-name-precedence-2.rs        |  3 +--
 65 files changed, 188 insertions(+), 97 deletions(-)

diff --git a/tests/ui/cross-crate/auxiliary/const-fn-evaluated-cross-crate.rs b/tests/ui/cross-crate/auxiliary/const-fn-evaluated-cross-crate.rs
index bc444a3817b88..9f0900809b18b 100644
--- a/tests/ui/cross-crate/auxiliary/const-fn-evaluated-cross-crate.rs
+++ b/tests/ui/cross-crate/auxiliary/const-fn-evaluated-cross-crate.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/36954
 #![crate_type = "lib"]
 
 const fn foo(i: i32) -> i32 {
diff --git a/tests/ui/cross-crate/auxiliary/construct-extern-struct-with-destructor.rs b/tests/ui/cross-crate/auxiliary/construct-extern-struct-with-destructor.rs
index 509af2a8d7df3..e01835cce563a 100644
--- a/tests/ui/cross-crate/auxiliary/construct-extern-struct-with-destructor.rs
+++ b/tests/ui/cross-crate/auxiliary/construct-extern-struct-with-destructor.rs
@@ -1,4 +1,5 @@
-#![crate_name="socketlib"]
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/3012
+#![crate_name="construct_extern_struct_with_destructor"]
 #![crate_type = "lib"]
 
 pub mod socket {
diff --git a/tests/ui/cross-crate/auxiliary/cross-crate-static-reference-and-field-access.rs b/tests/ui/cross-crate/auxiliary/cross-crate-static-reference-and-field-access.rs
index 6d26002a2e707..5c50ee0d59ce6 100644
--- a/tests/ui/cross-crate/auxiliary/cross-crate-static-reference-and-field-access.rs
+++ b/tests/ui/cross-crate/auxiliary/cross-crate-static-reference-and-field-access.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/29265
 #![crate_type = "lib"]
 
 pub struct SomeType {
diff --git a/tests/ui/cross-crate/auxiliary/cross-crate-trait-inheritance-on-default-method.rs b/tests/ui/cross-crate/auxiliary/cross-crate-trait-inheritance-on-default-method.rs
index 5d03a0e9e9931..17796ae23d4e2 100644
--- a/tests/ui/cross-crate/auxiliary/cross-crate-trait-inheritance-on-default-method.rs
+++ b/tests/ui/cross-crate/auxiliary/cross-crate-trait-inheritance-on-default-method.rs
@@ -1,4 +1,5 @@
-#![crate_name="issue_3979_traits"]
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/3979
+#![crate_name="cross_crate_trait_inheritance_on_default_method"]
 
 #![crate_type = "lib"]
 
diff --git a/tests/ui/cross-crate/auxiliary/cross-crate-type-alias-with-nested-destructors.rs b/tests/ui/cross-crate/auxiliary/cross-crate-type-alias-with-nested-destructors.rs
index 3b27f658cdae5..879f215b24f4e 100644
--- a/tests/ui/cross-crate/auxiliary/cross-crate-type-alias-with-nested-destructors.rs
+++ b/tests/ui/cross-crate/auxiliary/cross-crate-type-alias-with-nested-destructors.rs
@@ -1,4 +1,5 @@
-#![crate_name="issue_2526"]
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/2526
+#![crate_name="cross_crate_type_alias_with_nested_destructors"]
 #![crate_type = "lib"]
 
 use std::marker;
diff --git a/tests/ui/cross-crate/auxiliary/default-trait-method-reachable-through-trait-object.rs b/tests/ui/cross-crate/auxiliary/default-trait-method-reachable-through-trait-object.rs
index a8e964e016fd1..b14a140de18f5 100644
--- a/tests/ui/cross-crate/auxiliary/default-trait-method-reachable-through-trait-object.rs
+++ b/tests/ui/cross-crate/auxiliary/default-trait-method-reachable-through-trait-object.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/38226
 #![crate_type="rlib"]
 
 #[inline(never)]
diff --git a/tests/ui/cross-crate/auxiliary/extern-crate-and-impl-inside-method-body.rs b/tests/ui/cross-crate/auxiliary/extern-crate-and-impl-inside-method-body.rs
index ae73c3e780fb3..cd011fc294c44 100644
--- a/tests/ui/cross-crate/auxiliary/extern-crate-and-impl-inside-method-body.rs
+++ b/tests/ui/cross-crate/auxiliary/extern-crate-and-impl-inside-method-body.rs
@@ -1 +1,2 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/41053
 pub struct Test;
diff --git a/tests/ui/cross-crate/auxiliary/extern-generic-tuple-struct-construction.rs b/tests/ui/cross-crate/auxiliary/extern-generic-tuple-struct-construction.rs
index 2f60947507541..1a27ca252a30e 100644
--- a/tests/ui/cross-crate/auxiliary/extern-generic-tuple-struct-construction.rs
+++ b/tests/ui/cross-crate/auxiliary/extern-generic-tuple-struct-construction.rs
@@ -1,2 +1,3 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/4545
 pub struct S<T>(Option<T>);
 pub fn mk<T>() -> S<T> { S(None) }
diff --git a/tests/ui/cross-crate/auxiliary/extern-repr-enum-with-discriminant-cast.rs b/tests/ui/cross-crate/auxiliary/extern-repr-enum-with-discriminant-cast.rs
index 95119a589c99d..85819006c78ae 100644
--- a/tests/ui/cross-crate/auxiliary/extern-repr-enum-with-discriminant-cast.rs
+++ b/tests/ui/cross-crate/auxiliary/extern-repr-enum-with-discriminant-cast.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/42007
 #[repr(u8)]
 pub enum E {
     B = 1 as u8,
diff --git a/tests/ui/cross-crate/auxiliary/extern-trait-bound-with-array-associated-type.rs b/tests/ui/cross-crate/auxiliary/extern-trait-bound-with-array-associated-type.rs
index 7cc888cd4cb29..d383b9ff64b80 100644
--- a/tests/ui/cross-crate/auxiliary/extern-trait-bound-with-array-associated-type.rs
+++ b/tests/ui/cross-crate/auxiliary/extern-trait-bound-with-array-associated-type.rs
@@ -1,5 +1,6 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/48984
 #![crate_type = "lib"]
-#![crate_name = "issue48984aux"]
+#![crate_name = "extern_trait_bound_with_array_associated_type"]
 
 pub trait Foo { type Item; }
 
diff --git a/tests/ui/cross-crate/auxiliary/fn-declared-inside-closure-body-cross-crate.rs b/tests/ui/cross-crate/auxiliary/fn-declared-inside-closure-body-cross-crate.rs
index 661b46d829dfe..6346ebfb54dd4 100644
--- a/tests/ui/cross-crate/auxiliary/fn-declared-inside-closure-body-cross-crate.rs
+++ b/tests/ui/cross-crate/auxiliary/fn-declared-inside-closure-body-cross-crate.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/2723
 pub unsafe fn f(xs: Vec<isize> ) {
     xs.iter().map(|_x| { unsafe fn q() { panic!(); } }).collect::<Vec<()>>();
 }
diff --git a/tests/ui/cross-crate/auxiliary/fn-local-impl-returned-as-trait-object.rs b/tests/ui/cross-crate/auxiliary/fn-local-impl-returned-as-trait-object.rs
index 9ec829b417f81..420792577cf04 100644
--- a/tests/ui/cross-crate/auxiliary/fn-local-impl-returned-as-trait-object.rs
+++ b/tests/ui/cross-crate/auxiliary/fn-local-impl-returned-as-trait-object.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/2380
 #![crate_name="a"]
 #![crate_type = "lib"]
 
diff --git a/tests/ui/cross-crate/auxiliary/for-loop-in-match-on-self.rs b/tests/ui/cross-crate/auxiliary/for-loop-in-match-on-self.rs
index 307f23c10e284..db1f5edb4507e 100644
--- a/tests/ui/cross-crate/auxiliary/for-loop-in-match-on-self.rs
+++ b/tests/ui/cross-crate/auxiliary/for-loop-in-match-on-self.rs
@@ -1,5 +1,4 @@
-//! Auxiliary crate for <https://github.com/rust-lang/rust/issues/16643>.
-
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/16643
 #![crate_type = "lib"]
 
 pub struct TreeBuilder<H> { pub h: H }
diff --git a/tests/ui/cross-crate/auxiliary/generic-fn-with-supertrait-bound-cross-crate.rs b/tests/ui/cross-crate/auxiliary/generic-fn-with-supertrait-bound-cross-crate.rs
index 7b4c8b01a9e2f..ad0fe922d6f2f 100644
--- a/tests/ui/cross-crate/auxiliary/generic-fn-with-supertrait-bound-cross-crate.rs
+++ b/tests/ui/cross-crate/auxiliary/generic-fn-with-supertrait-bound-cross-crate.rs
@@ -1,4 +1,5 @@
-#![crate_name="numeric"]
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/4208
+#![crate_name="generic_fn_with_supertrait_bound_cross_crate"]
 #![crate_type = "lib"]
 
 pub trait Trig<T> {
diff --git a/tests/ui/cross-crate/auxiliary/graceful-error-for-mistyped-assoc-const.rs b/tests/ui/cross-crate/auxiliary/graceful-error-for-mistyped-assoc-const.rs
index b7bd375250f0b..84ac2b5ae9de3 100644
--- a/tests/ui/cross-crate/auxiliary/graceful-error-for-mistyped-assoc-const.rs
+++ b/tests/ui/cross-crate/auxiliary/graceful-error-for-mistyped-assoc-const.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/41549
 pub trait Trait {
     const CONST: u32;
 }
diff --git a/tests/ui/cross-crate/auxiliary/impl-extern-trait-with-associated-type.rs b/tests/ui/cross-crate/auxiliary/impl-extern-trait-with-associated-type.rs
index ae6d44eeb7703..5d935380e0649 100644
--- a/tests/ui/cross-crate/auxiliary/impl-extern-trait-with-associated-type.rs
+++ b/tests/ui/cross-crate/auxiliary/impl-extern-trait-with-associated-type.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/20389
 pub trait T {
     type C;
     fn dummy(&self) { }
diff --git a/tests/ui/cross-crate/auxiliary/imported-struct-not-confused-with-variant.rs b/tests/ui/cross-crate/auxiliary/imported-struct-not-confused-with-variant.rs
index 31359e86559dd..4f70e98f22af9 100644
--- a/tests/ui/cross-crate/auxiliary/imported-struct-not-confused-with-variant.rs
+++ b/tests/ui/cross-crate/auxiliary/imported-struct-not-confused-with-variant.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/19293
 pub struct Foo (pub isize);
 pub enum MyEnum {
     Foo(Foo),
diff --git a/tests/ui/cross-crate/auxiliary/link-extern-crate-with-drop-type.rs b/tests/ui/cross-crate/auxiliary/link-extern-crate-with-drop-type.rs
index a99385a834dfb..e498dd0758cef 100644
--- a/tests/ui/cross-crate/auxiliary/link-extern-crate-with-drop-type.rs
+++ b/tests/ui/cross-crate/auxiliary/link-extern-crate-with-drop-type.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/20389
 fn foo(_x: i32) {
 }
 
diff --git a/tests/ui/cross-crate/auxiliary/macro-generated-module-path-resolution.rs b/tests/ui/cross-crate/auxiliary/macro-generated-module-path-resolution.rs
index 373e646ba2c39..f808fa793e475 100644
--- a/tests/ui/cross-crate/auxiliary/macro-generated-module-path-resolution.rs
+++ b/tests/ui/cross-crate/auxiliary/macro-generated-module-path-resolution.rs
@@ -1,2 +1,3 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/38190
 #[macro_export]
 macro_rules! m { ([$i:item]) => {} }
diff --git a/tests/ui/cross-crate/auxiliary/method-call-on-extern-fn-return-value.rs b/tests/ui/cross-crate/auxiliary/method-call-on-extern-fn-return-value.rs
index fef5213db9f7a..02f85ee90ee6b 100644
--- a/tests/ui/cross-crate/auxiliary/method-call-on-extern-fn-return-value.rs
+++ b/tests/ui/cross-crate/auxiliary/method-call-on-extern-fn-return-value.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/51798
 #![crate_type = "lib"]
 
 pub fn vec() -> Vec<u8> { vec![] }
diff --git a/tests/ui/cross-crate/auxiliary/monomorphize-index-op-cross-crate.rs b/tests/ui/cross-crate/auxiliary/monomorphize-index-op-cross-crate.rs
index 1e8211bfaa783..6ab538044fa5c 100644
--- a/tests/ui/cross-crate/auxiliary/monomorphize-index-op-cross-crate.rs
+++ b/tests/ui/cross-crate/auxiliary/monomorphize-index-op-cross-crate.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/2631
 #![crate_name="req"]
 #![crate_type = "lib"]
 
diff --git a/tests/ui/cross-crate/auxiliary/mut-ref-write-visible-after-unwind.rs b/tests/ui/cross-crate/auxiliary/mut-ref-write-visible-after-unwind.rs
index 1e8891c51206f..2545f4f0c48cc 100644
--- a/tests/ui/cross-crate/auxiliary/mut-ref-write-visible-after-unwind.rs
+++ b/tests/ui/cross-crate/auxiliary/mut-ref-write-visible-after-unwind.rs
@@ -1,4 +1,5 @@
-#![crate_name="a"]
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/29265
+#![crate_name="mut_ref_write_visible_after_unwind"]
 #![crate_type = "lib"]
 
 pub struct X(pub u8);
diff --git a/tests/ui/cross-crate/auxiliary/nested-struct-in-polymorphic-impl-method.rs b/tests/ui/cross-crate/auxiliary/nested-struct-in-polymorphic-impl-method.rs
index 22bb1c8f97709..24f7601b67125 100644
--- a/tests/ui/cross-crate/auxiliary/nested-struct-in-polymorphic-impl-method.rs
+++ b/tests/ui/cross-crate/auxiliary/nested-struct-in-polymorphic-impl-method.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/3136
 #![crate_type = "lib"]
 
 trait x {
diff --git a/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-a.rs b/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-a.rs
index 7998f1870b8fe..22618804fe629 100644
--- a/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-a.rs
+++ b/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-a.rs
@@ -1,7 +1,8 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/32518
 //@ no-prefer-dynamic
 //@ compile-flags: -Ccodegen-units=2 --crate-type=lib
 
-extern crate cgu_test;
+extern crate no_duplicate_symbols_with_codegen_units_cgu_test as cgu_test;
 
 pub mod a {
     pub fn a() {
diff --git a/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-b.rs b/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-b.rs
index 7998f1870b8fe..22618804fe629 100644
--- a/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-b.rs
+++ b/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test-b.rs
@@ -1,7 +1,8 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/32518
 //@ no-prefer-dynamic
 //@ compile-flags: -Ccodegen-units=2 --crate-type=lib
 
-extern crate cgu_test;
+extern crate no_duplicate_symbols_with_codegen_units_cgu_test as cgu_test;
 
 pub mod a {
     pub fn a() {
diff --git a/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test.rs b/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test.rs
index 1103fcb1f0b28..73dd32b34ba8b 100644
--- a/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test.rs
+++ b/tests/ui/cross-crate/auxiliary/no-duplicate-symbols-with-codegen-units-cgu-test.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/32518
 //@ no-prefer-dynamic
 //@ compile-flags: --crate-type=lib
 
diff --git a/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-1.rs b/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-1.rs
index a48d0dc2c6447..b14ce0b0dc190 100644
--- a/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-1.rs
+++ b/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-1.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/31702
 #[derive(Copy)]
 pub struct U256(pub [u64; 4]);
 
diff --git a/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-2.rs b/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-2.rs
index 16300b0f5d530..05da5e21824cd 100644
--- a/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-2.rs
+++ b/tests/ui/cross-crate/auxiliary/optimized-closure-with-debug-info-cross-crate-2.rs
@@ -1,9 +1,10 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/31702
 //@ compile-flags: -g
 
-extern crate issue_31702_1;
+extern crate optimized_closure_with_debug_info_cross_crate_1;
 
 use std::collections::HashMap;
-use issue_31702_1::U256;
+use optimized_closure_with_debug_info_cross_crate_1::U256;
 
 pub struct Ethash {
     engine_params: fn() -> Option<&'static Vec<u8>>,
diff --git a/tests/ui/cross-crate/auxiliary/stable-hash-for-trait-object-type.rs b/tests/ui/cross-crate/auxiliary/stable-hash-for-trait-object-type.rs
index 0e91bb4bcdc1f..a3c278db38a60 100644
--- a/tests/ui/cross-crate/auxiliary/stable-hash-for-trait-object-type.rs
+++ b/tests/ui/cross-crate/auxiliary/stable-hash-for-trait-object-type.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate for regression test of https://github.com/rust-lang/rust/issues/34796
 #![crate_type = "lib"]
 pub trait Future {
     type Item;
diff --git a/tests/ui/cross-crate/auxiliary/trait-object-projection-bounds-with-interning-order.rs b/tests/ui/cross-crate/auxiliary/trait-object-projection-bounds-with-interning-order.rs
index 16c2869dc75cc..eb58bb5d29d06 100644
--- a/tests/ui/cross-crate/auxiliary/trait-object-projection-bounds-with-interning-order.rs
+++ b/tests/ui/cross-crate/auxiliary/trait-object-projection-bounds-with-interning-order.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/25467
 #![crate_type="lib"]
 
 pub trait Trait {
diff --git a/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-a.rs b/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-a.rs
index b90ab32ddc4ad..58d79571f8d97 100644
--- a/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-a.rs
+++ b/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-a.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/2414
 #![crate_name="a"]
 #![crate_type = "lib"]
 
diff --git a/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-b.rs b/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-b.rs
index fc018349d80f1..eddb36bc4d0fa 100644
--- a/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-b.rs
+++ b/tests/ui/cross-crate/auxiliary/transitive-crate-dependency-with-trait-impl-b.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/2414
 #![crate_name="b"]
 #![crate_type = "lib"]
 
diff --git a/tests/ui/cross-crate/auxiliary/type-default-applied-in-cross-crate-method-lookup.rs b/tests/ui/cross-crate/auxiliary/type-default-applied-in-cross-crate-method-lookup.rs
index 07c743eb2aa34..68b9f6843ddbd 100644
--- a/tests/ui/cross-crate/auxiliary/type-default-applied-in-cross-crate-method-lookup.rs
+++ b/tests/ui/cross-crate/auxiliary/type-default-applied-in-cross-crate-method-lookup.rs
@@ -1,3 +1,4 @@
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/30123
 use std::marker::PhantomData;
 
 pub struct Directed;
diff --git a/tests/ui/cross-crate/const-fn-evaluated-cross-crate.rs b/tests/ui/cross-crate/const-fn-evaluated-cross-crate.rs
index 411e99b603da4..cf0843f01ce8a 100644
--- a/tests/ui/cross-crate/const-fn-evaluated-cross-crate.rs
+++ b/tests/ui/cross-crate/const-fn-evaluated-cross-crate.rs
@@ -1,7 +1,11 @@
 //@ run-pass
-//@ aux-build:issue-36954.rs
+//@ aux-build:const-fn-evaluated-cross-crate.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/36954
+//! Cross crate const fn evaluation failed because the compiler's
+//! internal argument lookup table used crate local ids that didn't
+//! exist when evaluating a const fn from another crate.
 
-extern crate issue_36954 as lib;
+extern crate const_fn_evaluated_cross_crate as lib;
 
 fn main() {
     let _ = lib::FOO;
diff --git a/tests/ui/cross-crate/construct-extern-struct-with-destructor.rs b/tests/ui/cross-crate/construct-extern-struct-with-destructor.rs
index fd090d5e7b50e..d916305bbc764 100644
--- a/tests/ui/cross-crate/construct-extern-struct-with-destructor.rs
+++ b/tests/ui/cross-crate/construct-extern-struct-with-destructor.rs
@@ -1,8 +1,10 @@
 //@ run-pass
-//@ aux-build:issue-3012-1.rs
+//@ aux-build:construct-extern-struct-with-destructor.rs
 
+//! Regression test for https://github.com/rust-lang/rust/issues/3012
+//! Guarantees that you can construct cross crate structs.
 
-extern crate socketlib;
+extern crate construct_extern_struct_with_destructor as socketlib;
 
 use socketlib::socket;
 
diff --git a/tests/ui/cross-crate/cross-crate-static-reference-and-field-access.rs b/tests/ui/cross-crate/cross-crate-static-reference-and-field-access.rs
index a3da9be3a3b65..25e52c153ba0e 100644
--- a/tests/ui/cross-crate/cross-crate-static-reference-and-field-access.rs
+++ b/tests/ui/cross-crate/cross-crate-static-reference-and-field-access.rs
@@ -1,7 +1,11 @@
-//@ aux-build:issue-29265.rs
+//@ aux-build:cross-crate-static-reference-and-field-access.rs
 //@ check-pass
 
-extern crate issue_29265 as lib;
+//! Regression test for https://github.com/rust-lang/rust/issues/29265
+//! Exposed an bug where referencing a static variable from another crate
+//! was causing an error.
+
+extern crate cross_crate_static_reference_and_field_access as lib;
 
 static _UNUSED: &'static lib::SomeType = &lib::SOME_VALUE;
 
diff --git a/tests/ui/cross-crate/cross-crate-trait-inheritance-on-default-method.rs b/tests/ui/cross-crate/cross-crate-trait-inheritance-on-default-method.rs
index 7660405929bfb..3ff481d2c17e9 100644
--- a/tests/ui/cross-crate/cross-crate-trait-inheritance-on-default-method.rs
+++ b/tests/ui/cross-crate/cross-crate-trait-inheritance-on-default-method.rs
@@ -1,8 +1,10 @@
 //@ run-pass
 #![allow(dead_code)]
-//@ aux-build:issue-3979-traits.rs
+//@ aux-build:cross-crate-trait-inheritance-on-default-method.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/3979
+//! Exposed a bug where external traits on a default method were failing to typecheck.
 
-extern crate issue_3979_traits;
+extern crate cross_crate_trait_inheritance_on_default_method as  issue_3979_traits;
 use issue_3979_traits::{Positioned, Movable};
 
 struct Point { x: isize, y: isize }
diff --git a/tests/ui/cross-crate/cross-crate-type-alias-with-nested-destructors.rs b/tests/ui/cross-crate/cross-crate-type-alias-with-nested-destructors.rs
index 379146d02b3de..c12dc04f5ab4a 100644
--- a/tests/ui/cross-crate/cross-crate-type-alias-with-nested-destructors.rs
+++ b/tests/ui/cross-crate/cross-crate-type-alias-with-nested-destructors.rs
@@ -1,10 +1,11 @@
 //@ run-pass
-//@ aux-build:issue-2526.rs
+//@ aux-build:cross-crate-type-alias-with-nested-destructors.rs
 
+//! Regression test for https://github.com/rust-lang/rust/issues/2526
 
 #![allow(unused_imports)]
 
-extern crate issue_2526;
-use issue_2526::*;
+extern crate cross_crate_type_alias_with_nested_destructors;
+use cross_crate_type_alias_with_nested_destructors::*;
 
 pub fn main() {}
diff --git a/tests/ui/cross-crate/default-trait-method-reachable-through-trait-object.rs b/tests/ui/cross-crate/default-trait-method-reachable-through-trait-object.rs
index d8bd9d64a7c60..a7683252757e8 100644
--- a/tests/ui/cross-crate/default-trait-method-reachable-through-trait-object.rs
+++ b/tests/ui/cross-crate/default-trait-method-reachable-through-trait-object.rs
@@ -2,13 +2,13 @@
 // This test makes sure that we don't run into a linker error because of the
 // middle::reachable pass missing trait methods with default impls.
 
-//@ aux-build:issue-38226-aux.rs
+//@ aux-build:default-trait-method-reachable-through-trait-object.rs
 
 // Need -Cno-prepopulate-passes to really disable inlining, otherwise the faulty
 // code gets optimized out:
 //@ compile-flags: -Cno-prepopulate-passes -Cpasses=name-anon-globals
 
-extern crate issue_38226_aux;
+extern crate default_trait_method_reachable_through_trait_object as issue_38226_aux;
 
 fn main() {
     issue_38226_aux::foo::<()>();
diff --git a/tests/ui/cross-crate/extern-crate-and-impl-inside-method-body.rs b/tests/ui/cross-crate/extern-crate-and-impl-inside-method-body.rs
index 42b0b008ce9b5..15ce563d575d9 100644
--- a/tests/ui/cross-crate/extern-crate-and-impl-inside-method-body.rs
+++ b/tests/ui/cross-crate/extern-crate-and-impl-inside-method-body.rs
@@ -1,5 +1,10 @@
 //@ run-pass
-//@ aux-build:issue-41053.rs
+//@ aux-build:extern-crate-and-impl-inside-method-body.rs
+
+//! Regression test for https://github.com/rust-lang/rust/issues/41053
+//! An extern crate declaration and trait impl referencing that crate
+//! inside an impl method body triggered a borrow conflict in the
+//! compiler's visible_parent_map.
 
 #![allow(non_local_definitions)]
 
@@ -10,7 +15,7 @@ pub struct Foo;
 impl Iterator for Foo {
     type Item = Box<dyn Trait>;
     fn next(&mut self) -> Option<Box<dyn Trait>> {
-        extern crate issue_41053;
+        extern crate extern_crate_and_impl_inside_method_body as issue_41053;
         impl crate::Trait for issue_41053::Test {
             fn foo(&self) {}
         }
diff --git a/tests/ui/cross-crate/extern-generic-tuple-struct-construction.rs b/tests/ui/cross-crate/extern-generic-tuple-struct-construction.rs
index dfb89136cbd22..98d1fec370da9 100644
--- a/tests/ui/cross-crate/extern-generic-tuple-struct-construction.rs
+++ b/tests/ui/cross-crate/extern-generic-tuple-struct-construction.rs
@@ -1,6 +1,6 @@
 //@ run-pass
-//@ aux-build:issue-4545.rs
+//@ aux-build:extern-generic-tuple-struct-construction.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/4545
 
-
-extern crate issue_4545 as somelib;
+extern crate extern_generic_tuple_struct_construction as somelib;
 pub fn main() { somelib::mk::<isize>(); }
diff --git a/tests/ui/cross-crate/extern-repr-enum-with-discriminant-cast.rs b/tests/ui/cross-crate/extern-repr-enum-with-discriminant-cast.rs
index b8ea7e871a736..96f345d002d86 100644
--- a/tests/ui/cross-crate/extern-repr-enum-with-discriminant-cast.rs
+++ b/tests/ui/cross-crate/extern-repr-enum-with-discriminant-cast.rs
@@ -1,8 +1,12 @@
 //@ run-pass
 #![allow(dead_code)]
-//@ aux-build:issue-42007-s.rs
-
-extern crate issue_42007_s;
+//@ aux-build:extern-repr-enum-with-discriminant-cast.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/42007
+//! This test exposes a bug that happens because the Session LintStore is emptied when linting
+//! The LintStore is emptied because the checker wants ownership as it wants to
+//! mutate the pass objects and lint levels.
+//! The fix was not taking ownership of the entire store just the lint levels and pass objects.
+extern crate extern_repr_enum_with_discriminant_cast as issue_42007_s;
 
 enum I {
     E(issue_42007_s::E),
diff --git a/tests/ui/cross-crate/extern-trait-bound-with-array-associated-type.rs b/tests/ui/cross-crate/extern-trait-bound-with-array-associated-type.rs
index 0440789a480aa..a0b5d0e876963 100644
--- a/tests/ui/cross-crate/extern-trait-bound-with-array-associated-type.rs
+++ b/tests/ui/cross-crate/extern-trait-bound-with-array-associated-type.rs
@@ -1,7 +1,13 @@
 //@ run-pass
 #![allow(dead_code)]
-//@ aux-build:issue-48984-aux.rs
-extern crate issue48984aux;
+//@ aux-build:extern-trait-bound-with-array-associated-type.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/48984
+//! This test exposes an error that occurs when a base trait has at
+//! least one associated type, and the extending trait specifies the
+//! associated type as an array of some kind. In order to trigger the
+//! error, the extending trait must be defined in an external crate, and
+//! used to constrain a generic type parameter.
+extern crate extern_trait_bound_with_array_associated_type as issue48984aux;
 use issue48984aux::Bar;
 
 fn do_thing<T: Bar>() { }
diff --git a/tests/ui/cross-crate/fn-declared-inside-closure-body-cross-crate.rs b/tests/ui/cross-crate/fn-declared-inside-closure-body-cross-crate.rs
index 731e521f26f89..9d47358777c53 100644
--- a/tests/ui/cross-crate/fn-declared-inside-closure-body-cross-crate.rs
+++ b/tests/ui/cross-crate/fn-declared-inside-closure-body-cross-crate.rs
@@ -1,8 +1,10 @@
 //@ run-pass
-//@ aux-build:issue-2723-a.rs
+//@ aux-build:fn-declared-inside-closure-body-cross-crate.rs
 
-extern crate issue_2723_a;
-use issue_2723_a::f;
+//! Regression test for https://github.com/rust-lang/rust/issues/2723
+
+extern crate fn_declared_inside_closure_body_cross_crate;
+use fn_declared_inside_closure_body_cross_crate::f;
 
 pub fn main() {
     unsafe {
diff --git a/tests/ui/cross-crate/fn-local-impl-returned-as-trait-object.rs b/tests/ui/cross-crate/fn-local-impl-returned-as-trait-object.rs
index 503698f88c620..0fc404784e22b 100644
--- a/tests/ui/cross-crate/fn-local-impl-returned-as-trait-object.rs
+++ b/tests/ui/cross-crate/fn-local-impl-returned-as-trait-object.rs
@@ -1,6 +1,9 @@
 //@ run-pass
-//@ aux-build:issue-2380.rs
-
+//@ aux-build:fn-local-impl-returned-as-trait-object.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/2380
+//! This test exposes a bug where a function that defines a trait impl inside its body
+//!  and returns it as a trait object failed  because the reachability pass skipped nested
+//! items in function bodies.
 
 extern crate a;
 
diff --git a/tests/ui/cross-crate/generic-fn-with-supertrait-bound-cross-crate.rs b/tests/ui/cross-crate/generic-fn-with-supertrait-bound-cross-crate.rs
index 84938bea022d1..bce55b2140068 100644
--- a/tests/ui/cross-crate/generic-fn-with-supertrait-bound-cross-crate.rs
+++ b/tests/ui/cross-crate/generic-fn-with-supertrait-bound-cross-crate.rs
@@ -1,9 +1,9 @@
 //@ run-pass
 #![allow(dead_code)]
-//@ aux-build:issue-4208-cc.rs
+//@ aux-build:generic-fn-with-supertrait-bound-cross-crate.rs
 
-
-extern crate numeric;
+//! Regression test for https://github.com/rust-lang/rust/issues/4208
+extern crate generic_fn_with_supertrait_bound_cross_crate as numeric;
 use numeric::{sin, Angle};
 
 fn foo<T, A:Angle<T>>(theta: A) -> T { sin(&theta) }
diff --git a/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.rs b/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.rs
index 8f57515415c6e..238fb6bf0e738 100644
--- a/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.rs
+++ b/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.rs
@@ -1,7 +1,8 @@
-//@ aux-build:issue-41549.rs
-
-
-extern crate issue_41549;
+//@ aux-build:graceful-error-for-mistyped-assoc-const.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/41549
+//! Mismatched types on exernal associated constants used to ice,
+//! this test confirms that it errors correctly.
+extern crate graceful_error_for_mistyped_assoc_const as issue_41549;
 
 struct S;
 
diff --git a/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.stderr b/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.stderr
index 55be59684b55d..18b06462de7b6 100644
--- a/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.stderr
+++ b/tests/ui/cross-crate/graceful-error-for-mistyped-assoc-const.stderr
@@ -1,5 +1,5 @@
 error[E0326]: implemented const `CONST` has an incompatible type for trait
-  --> $DIR/issue-41549.rs:9:18
+  --> $DIR/graceful-error-for-mistyped-assoc-const.rs:10:18
    |
 LL |     const CONST: () = ();
    |                  ^^ expected `u32`, found `()`
diff --git a/tests/ui/cross-crate/impl-extern-trait-with-associated-type.rs b/tests/ui/cross-crate/impl-extern-trait-with-associated-type.rs
index e201663afc522..c6905e9002b29 100644
--- a/tests/ui/cross-crate/impl-extern-trait-with-associated-type.rs
+++ b/tests/ui/cross-crate/impl-extern-trait-with-associated-type.rs
@@ -1,13 +1,15 @@
 //@ run-pass
 #![allow(dead_code)]
-//@ aux-build:issue-20389.rs
+//@ aux-build:impl-extern-trait-with-associated-type.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/20389
+//! This test confirms that code implementing a trait with an associated type from an external crate
+//! runs.
 
-
-extern crate issue_20389;
+extern crate impl_extern_trait_with_associated_type;
 
 struct Foo;
 
-impl issue_20389::T for Foo {
+impl impl_extern_trait_with_associated_type::T for Foo {
     type C = ();
 }
 
diff --git a/tests/ui/cross-crate/imported-struct-not-confused-with-variant.rs b/tests/ui/cross-crate/imported-struct-not-confused-with-variant.rs
index 42effe303d036..458fc32be0cea 100644
--- a/tests/ui/cross-crate/imported-struct-not-confused-with-variant.rs
+++ b/tests/ui/cross-crate/imported-struct-not-confused-with-variant.rs
@@ -1,8 +1,11 @@
 //@ run-pass
-//@ aux-build:issue-19293.rs
+//@ aux-build:imported-struct-not-confused-with-variant.rs
 
-extern crate issue_19293;
-use issue_19293::{Foo, MyEnum};
+//! Regression test for https://github.com/rust-lang/rust/issues/19293
+//! This test ensures that cross crate variants are properly namespaced under their enum or struct.
+
+extern crate imported_struct_not_confused_with_variant;
+use imported_struct_not_confused_with_variant::{Foo, MyEnum};
 
 fn main() {
     MyEnum::Foo(Foo(5));
diff --git a/tests/ui/cross-crate/link-extern-crate-with-drop-type.rs b/tests/ui/cross-crate/link-extern-crate-with-drop-type.rs
index b66843d48cad6..623a644dcbf9f 100644
--- a/tests/ui/cross-crate/link-extern-crate-with-drop-type.rs
+++ b/tests/ui/cross-crate/link-extern-crate-with-drop-type.rs
@@ -1,7 +1,10 @@
 //@ run-pass
-//@ aux-build:issue-2170-lib.rs
+//@ aux-build:link-extern-crate-with-drop-type.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/2170
+//! This test just verifies that linking against an external crate works without
+//! a metadata failure. Apparently, having a Drop that calls another function is the trigger.
 
-extern crate issue_2170_lib;
+extern crate link_extern_crate_with_drop_type;
 
 pub fn main() {
    // let _ = issue_2170_lib::rsrc(2);
diff --git a/tests/ui/cross-crate/macro-generated-module-path-resolution.rs b/tests/ui/cross-crate/macro-generated-module-path-resolution.rs
index 539d7f2ed3be4..f785c24a83623 100644
--- a/tests/ui/cross-crate/macro-generated-module-path-resolution.rs
+++ b/tests/ui/cross-crate/macro-generated-module-path-resolution.rs
@@ -1,13 +1,17 @@
 //@ run-pass
-//@ aux-build:issue-38190.rs
+//@ aux-build:macro-generated-module-path-resolution.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/38190
+//! Non inline modules parsed as macro item fragments used the wrong
+//! directory for file resolution, because the fragment parser didn't
+//! inherit the correct directory from the macro invocation context.
 
 #[macro_use]
-extern crate issue_38190;
+extern crate macro_generated_module_path_resolution as aux;
 
 mod auxiliary {
     m!([
-        #[path = "issue-38190.rs"]
-        mod issue_38190;
+        #[path = "macro-generated-module-path-resolution"]
+        mod aux;
     ]);
 }
 
diff --git a/tests/ui/cross-crate/method-call-on-extern-fn-return-value.rs b/tests/ui/cross-crate/method-call-on-extern-fn-return-value.rs
index f4d59f39952eb..26a24aeb8ca99 100644
--- a/tests/ui/cross-crate/method-call-on-extern-fn-return-value.rs
+++ b/tests/ui/cross-crate/method-call-on-extern-fn-return-value.rs
@@ -1,8 +1,12 @@
 //@ edition:2018
-//@ aux-build:issue-51798.rs
+//@ aux-build:method-call-on-extern-fn-return-value.rs
 //@ check-pass
+//! Regression test for https://github.com/rust-lang/rust/issues/51798
+//! Calling a method on a value returned from an external crate function
+//! caused the privacy checker to panic when looking up the method's
+//! type dependent definition. Requires 2018 edition.
 
-extern crate issue_51798;
+extern crate method_call_on_extern_fn_return_value as issue_51798;
 
 mod server {
     fn f() {
diff --git a/tests/ui/cross-crate/monomorphize-index-op-cross-crate.rs b/tests/ui/cross-crate/monomorphize-index-op-cross-crate.rs
index fb2ecd74a6595..b915bbebf785b 100644
--- a/tests/ui/cross-crate/monomorphize-index-op-cross-crate.rs
+++ b/tests/ui/cross-crate/monomorphize-index-op-cross-crate.rs
@@ -1,6 +1,8 @@
 //@ run-pass
 
-//@ aux-build:issue-2631-a.rs
+//@ aux-build:monomorphize-index-op-cross-crate.rs
+
+//! Regression test for https://github.com/rust-lang/rust/issues/2631
 
 extern crate req;
 
diff --git a/tests/ui/cross-crate/mut-ref-write-visible-after-unwind.rs b/tests/ui/cross-crate/mut-ref-write-visible-after-unwind.rs
index 843a684a85b5e..2e3073286f0f6 100644
--- a/tests/ui/cross-crate/mut-ref-write-visible-after-unwind.rs
+++ b/tests/ui/cross-crate/mut-ref-write-visible-after-unwind.rs
@@ -1,14 +1,16 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/29485
+//! Exposed an LLVM bug that caused rustc to panic.
 //@ run-pass
-//@ aux-build:issue-29485.rs
+//@ aux-build:mut-ref-write-visible-after-unwind.rs
 //@ needs-unwind
 //@ needs-threads
 //@ ignore-backends: gcc
 
-extern crate a;
+extern crate mut_ref_write_visible_after_unwind as lib;
 
 fn main() {
     let _ = std::thread::spawn(move || {
-        a::f(&mut a::X(0), g);
+        lib::f(&mut lib::X(0), g);
     }).join();
 }
 
diff --git a/tests/ui/cross-crate/nested-struct-in-polymorphic-impl-method.rs b/tests/ui/cross-crate/nested-struct-in-polymorphic-impl-method.rs
index bd6ea732643f1..12d09cdc84440 100644
--- a/tests/ui/cross-crate/nested-struct-in-polymorphic-impl-method.rs
+++ b/tests/ui/cross-crate/nested-struct-in-polymorphic-impl-method.rs
@@ -1,7 +1,8 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/3136
 //@ run-pass
-//@ aux-build:issue-3136-a.rs
+//@ aux-build:nested-struct-in-polymorphic-impl-method.rs
 
 
-extern crate issue_3136_a;
+extern crate nested_struct_in_polymorphic_impl_method;
 
 pub fn main() {}
diff --git a/tests/ui/cross-crate/no-duplicate-symbols-with-codegen-units.rs b/tests/ui/cross-crate/no-duplicate-symbols-with-codegen-units.rs
index 45a882850c009..f54c89a9162c3 100644
--- a/tests/ui/cross-crate/no-duplicate-symbols-with-codegen-units.rs
+++ b/tests/ui/cross-crate/no-duplicate-symbols-with-codegen-units.rs
@@ -1,11 +1,12 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/32518
 //@ run-pass
 //@ no-prefer-dynamic
-//@ aux-build:cgu_test.rs
-//@ aux-build:cgu_test_a.rs
-//@ aux-build:cgu_test_b.rs
+//@ aux-build:no-duplicate-symbols-with-codegen-units-cgu-test.rs
+//@ aux-build:no-duplicate-symbols-with-codegen-units-cgu-test-a.rs
+//@ aux-build:no-duplicate-symbols-with-codegen-units-cgu-test-b.rs
 
-extern crate cgu_test_a;
-extern crate cgu_test_b;
+extern crate no_duplicate_symbols_with_codegen_units_cgu_test_a as cgu_test_a;
+extern crate no_duplicate_symbols_with_codegen_units_cgu_test_b as cgu_test_b;
 
 fn main() {
     cgu_test_a::a::a();
diff --git a/tests/ui/cross-crate/optimized-closure-with-debug-info-cross-crate.rs b/tests/ui/cross-crate/optimized-closure-with-debug-info-cross-crate.rs
index 1cf01f7f04ecc..f0b34bdd86f0a 100644
--- a/tests/ui/cross-crate/optimized-closure-with-debug-info-cross-crate.rs
+++ b/tests/ui/cross-crate/optimized-closure-with-debug-info-cross-crate.rs
@@ -1,10 +1,11 @@
 //@ run-pass
-//@ aux-build:issue-31702-1.rs
-//@ aux-build:issue-31702-2.rs
+//@ aux-build:optimized-closure-with-debug-info-cross-crate-1.rs
+//@ aux-build:optimized-closure-with-debug-info-cross-crate-2.rs
 
+//! Regression test for https://github.com/rust-lang/rust/issues/31702
 // this test is actually entirely in the linked library crates
 
-extern crate issue_31702_1;
-extern crate issue_31702_2;
+extern crate optimized_closure_with_debug_info_cross_crate_1;
+extern crate optimized_closure_with_debug_info_cross_crate_2;
 
 fn main() {}
diff --git a/tests/ui/cross-crate/stable-hash-for-trait-object-type.rs b/tests/ui/cross-crate/stable-hash-for-trait-object-type.rs
index 1a417b3483068..725469e4e4f91 100644
--- a/tests/ui/cross-crate/stable-hash-for-trait-object-type.rs
+++ b/tests/ui/cross-crate/stable-hash-for-trait-object-type.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 #![allow(dead_code)]
+// Regression test for https://github.com/rust-lang/rust/issues/34796
 // This test case exposes conditions where the encoding of a trait object type
 // with projection predicates would differ between this crate and the upstream
 // crate, because the predicates were encoded in different order within each
@@ -8,8 +9,8 @@
 // the symbol name.
 // The fix was to make the order in which predicates get encoded stable.
 
-//@ aux-build:issue-34796-aux.rs
-extern crate issue_34796_aux;
+//@ aux-build:stable-hash-for-trait-object-type.rs
+extern crate stable_hash_for_trait_object_type as issue_34796_aux;
 
 fn mk<T>() -> T { loop {} }
 
diff --git a/tests/ui/cross-crate/trait-object-projection-bounds-with-interning-order.rs b/tests/ui/cross-crate/trait-object-projection-bounds-with-interning-order.rs
index 1ba5a0ef697a1..44aff69126c2a 100644
--- a/tests/ui/cross-crate/trait-object-projection-bounds-with-interning-order.rs
+++ b/tests/ui/cross-crate/trait-object-projection-bounds-with-interning-order.rs
@@ -1,11 +1,13 @@
 //@ run-pass
 #![allow(unused_variables)]
-//@ aux-build:issue-25467.rs
+//@ aux-build:trait-object-projection-bounds-with-interning-order.rs
+
+//! Regression test for https://github.com/rust-lang/rust/issues/25467
 
 pub type Issue25467BarT = ();
 pub type Issue25467FooT = ();
 
-extern crate issue_25467 as aux;
+extern crate trait_object_projection_bounds_with_interning_order as aux;
 
 fn main() {
     let o: aux::Object = None;
diff --git a/tests/ui/cross-crate/transitive-crate-dependency-with-trait-impl.rs b/tests/ui/cross-crate/transitive-crate-dependency-with-trait-impl.rs
index ac75c5c51051c..8d3b15cfd86bb 100644
--- a/tests/ui/cross-crate/transitive-crate-dependency-with-trait-impl.rs
+++ b/tests/ui/cross-crate/transitive-crate-dependency-with-trait-impl.rs
@@ -1,7 +1,8 @@
 //@ run-pass
-//@ aux-build:issue-2414-a.rs
-//@ aux-build:issue-2414-b.rs
+//@ aux-build:transitive-crate-dependency-with-trait-impl-a.rs
+//@ aux-build:transitive-crate-dependency-with-trait-impl-b.rs
 
+//! Regression test for https://github.com/rust-lang/rust/issues/2414
 
 extern crate b;
 
diff --git a/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.rs b/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.rs
index 88fab44741f2e..b0b6f05610d50 100644
--- a/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.rs
+++ b/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.rs
@@ -1,7 +1,8 @@
-//@ aux-build:issue-30123-aux.rs
+//! Regression test for https://github.com/rust-lang/rust/issues/30123
+//@ aux-build:type-default-applied-in-cross-crate-method-lookup.rs
 
-extern crate issue_30123_aux;
-use issue_30123_aux::*;
+extern crate type_default_applied_in_cross_crate_method_lookup;
+use type_default_applied_in_cross_crate_method_lookup::*;
 
 fn main() {
     let ug = Graph::<i32, i32>::new_undirected();
diff --git a/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.stderr b/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.stderr
index 1e2747407d1da..c5c5f206fe071 100644
--- a/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.stderr
+++ b/tests/ui/cross-crate/type-default-applied-in-cross-crate-method-lookup.stderr
@@ -1,15 +1,15 @@
-error[E0599]: no associated function or constant named `new_undirected` found for struct `issue_30123_aux::Graph<i32, i32>` in the current scope
-  --> $DIR/issue-30123.rs:7:33
+error[E0599]: no associated function or constant named `new_undirected` found for struct `type_default_applied_in_cross_crate_method_lookup::Graph<i32, i32>` in the current scope
+  --> $DIR/type-default-applied-in-cross-crate-method-lookup.rs:8:33
    |
 LL |     let ug = Graph::<i32, i32>::new_undirected();
-   |                                 ^^^^^^^^^^^^^^ associated function or constant not found in `issue_30123_aux::Graph<i32, i32>`
+   |                                 ^^^^^^^^^^^^^^ associated function or constant not found in `type_default_applied_in_cross_crate_method_lookup::Graph<i32, i32>`
    |
-note: if you're trying to build a new `issue_30123_aux::Graph<i32, i32>`, consider using `issue_30123_aux::Graph::<N, E>::new` which returns `issue_30123_aux::Graph<_, _>`
-  --> $DIR/auxiliary/issue-30123-aux.rs:14:5
+note: if you're trying to build a new `type_default_applied_in_cross_crate_method_lookup::Graph<i32, i32>`, consider using `type_default_applied_in_cross_crate_method_lookup::Graph::<N, E>::new` which returns `type_default_applied_in_cross_crate_method_lookup::Graph<_, _>`
+  --> $DIR/auxiliary/type-default-applied-in-cross-crate-method-lookup.rs:15:5
    |
 LL |     pub fn new() -> Self {
    |     ^^^^^^^^^^^^^^^^^^^^
-   = note: the associated function or constant was found for `issue_30123_aux::Graph<N, E, Undirected>`
+   = note: the associated function or constant was found for `type_default_applied_in_cross_crate_method_lookup::Graph<N, E, Undirected>`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/linking/auxiliary/duplicate-rlib-crate-name-precedence-1.rs b/tests/ui/linking/auxiliary/duplicate-rlib-crate-name-precedence-1.rs
index 7b2bfbba12e6e..bac086ba0c054 100644
--- a/tests/ui/linking/auxiliary/duplicate-rlib-crate-name-precedence-1.rs
+++ b/tests/ui/linking/auxiliary/duplicate-rlib-crate-name-precedence-1.rs
@@ -1,5 +1,4 @@
-//! Auxiliary crate for <https://github.com/rust-lang/rust/issues/18913>.
-
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/18913
 //@ no-prefer-dynamic
 
 #![crate_type = "rlib"]
diff --git a/tests/ui/linking/auxiliary/duplicate-rlib-crate-name-precedence-2.rs b/tests/ui/linking/auxiliary/duplicate-rlib-crate-name-precedence-2.rs
index fc0d3d6ea4283..05dba52c6625e 100644
--- a/tests/ui/linking/auxiliary/duplicate-rlib-crate-name-precedence-2.rs
+++ b/tests/ui/linking/auxiliary/duplicate-rlib-crate-name-precedence-2.rs
@@ -1,5 +1,4 @@
-//! Auxiliary crate for <https://github.com/rust-lang/rust/issues/18913>.
-
+//! Auxiliary crate testing this issue https://github.com/rust-lang/rust/issues/18913
 //@ no-prefer-dynamic
 
 #![crate_type = "rlib"]

From f1d8aedadf012810e28285cb5671095badcf589d Mon Sep 17 00:00:00 2001
From: Walnut <39544927+Walnut356@users.noreply.github.com>
Date: Tue, 2 Jun 2026 02:41:15 -0500
Subject: [PATCH 08/20] add infallible primitive type lookups to template arg
 resolver

---
 src/etc/lldb_lookup.py    |  2 ++
 src/etc/lldb_providers.py | 45 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/src/etc/lldb_lookup.py b/src/etc/lldb_lookup.py
index cc3e8411306d9..77c508f3ebb77 100644
--- a/src/etc/lldb_lookup.py
+++ b/src/etc/lldb_lookup.py
@@ -114,6 +114,8 @@ def __lldb_init_module(debugger: lldb.SBDebugger, _dict: LLDBOpaque):
         FEATURE_FLAGS |= LLDBFeature.StaticFields
     if getattr(lldb, "eFormatterMatchCallback", None) is not None:
         FEATURE_FLAGS |= LLDBFeature.TypeRecognizers
+    if getattr(lldb, "eBasicTypeFloat128", None) is not None:
+        FEATURE_FLAGS |= LLDBFeature.Float128
 
     register_providers_compatibility()
 
diff --git a/src/etc/lldb_providers.py b/src/etc/lldb_providers.py
index 81841dcc4cbb1..f6c2ab8f2b8c7 100644
--- a/src/etc/lldb_providers.py
+++ b/src/etc/lldb_providers.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 import sys
-from typing import Generator, List, TYPE_CHECKING, Optional
+from typing import Generator, Dict, List, TYPE_CHECKING, Optional
 from enum import Flag, auto
 
 from lldb import (
@@ -9,6 +9,15 @@
     eBasicTypeLong,
     eBasicTypeUnsignedLong,
     eBasicTypeUnsignedChar,
+    eBasicTypeUnsignedShort,
+    eBasicTypeUnsignedLongLong,
+    eBasicTypeSignedChar,
+    eBasicTypeShort,
+    eBasicTypeLongLong,
+    eBasicTypeFloat,
+    eBasicTypeDouble,
+    eBasicTypeHalf,
+    eBasicTypeChar32,
     eFormatChar,
     eTypeIsInteger,
 )
@@ -67,6 +76,9 @@ class LLDBFeature(Flag):
     """Added in LLDB 18. Adds functions to `SBType` the inspection of a struct's static fields."""
     TypeRecognizers = auto()
     """Added in LLDB 19. Callback-based type matching for synthetic/summary providers."""
+    Float128 = auto()
+    """Added in LLDB 22.1. Adds builtin support for Float 128's, including an `eBasicTypeFloat128`,
+    a formatter, and handlers in `TypeSystemClang`"""
 
 
 FEATURE_FLAGS: LLDBFeature = LLDBFeature(0)
@@ -198,6 +210,21 @@ def get_template_args(type_name: str) -> Generator[str, None, None]:
 
 MSVC_PTR_PREFIX: List[str] = ["ref$<", "ref_mut$<", "ptr_const$<", "ptr_mut$<"]
 
+PRIMITIVE_TYPES: Dict[str, int] = {
+    "u8": eBasicTypeUnsignedChar,
+    "u16": eBasicTypeUnsignedShort,
+    "u32": eBasicTypeUnsignedLong,
+    "u64": eBasicTypeUnsignedLongLong,
+    "i8": eBasicTypeSignedChar,
+    "i16": eBasicTypeShort,
+    "i32": eBasicTypeLong,
+    "i64": eBasicTypeLongLong,
+    "f16": eBasicTypeHalf,
+    "f32": eBasicTypeFloat,
+    "f64": eBasicTypeDouble,
+    "char": eBasicTypeChar32,
+}
+
 
 def resolve_msvc_template_arg(arg_name: str, target: SBTarget) -> SBType:
     """
@@ -214,6 +241,22 @@ def resolve_msvc_template_arg(arg_name: str, target: SBTarget) -> SBType:
     current version of LLDB, so instead the types are generated via `base_type.GetPointerType()` and
     `base_type.GetArrayType()`, which bypass the PDB file and ask clang directly for the type node.
     """
+
+    # As of LLDB 22, finding primitives based on `FindFirstType` with their rust name no longer
+    # works. Instead, we can look them up by their `eBasicType` equivalent. For usize and isize,
+    # we convert them to their bit-sized counterpart before the lookup
+    if arg_name == "isize" or arg_name == "usize":
+        equivalent = f"{arg_name[0]}{target.GetAddressByteSize() * 8}"
+        return target.GetBasicType(PRIMITIVE_TYPES[equivalent])
+
+    if (basic_type := PRIMITIVE_TYPES.get(arg_name)) is not None:
+        return target.GetBasicType(basic_type)
+
+    if arg_name == "f128" and LLDBFeature.Float128 in FEATURE_FLAGS:
+        from lldb import eBasicTypeFloat128
+
+        return target.GetBasicType(eBasicTypeFloat128)
+
     result = target.FindFirstType(arg_name)
 
     if result.IsValid():

From c6945a5b4b314ccc513635099713776d0df6e2d0 Mon Sep 17 00:00:00 2001
From: Walnut <39544927+Walnut356@users.noreply.github.com>
Date: Sat, 6 Jun 2026 02:56:30 -0500
Subject: [PATCH 09/20] fix `breakpoint_callback` path

---
 src/etc/lldb_batchmode/runner.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/etc/lldb_batchmode/runner.py b/src/etc/lldb_batchmode/runner.py
index e9b106390f6f9..cdc5458606858 100644
--- a/src/etc/lldb_batchmode/runner.py
+++ b/src/etc/lldb_batchmode/runner.py
@@ -98,7 +98,7 @@ def execute_command(command_interpreter, command):
                     "registering breakpoint callback, id = " + str(breakpoint_id)
                 )
                 callback_command = f"breakpoint command add -s python {str(breakpoint_id)} -o \
-                    'import lldb_batchmode; lldb_batchmode.breakpoint_callback'"
+'import lldb_batchmode; lldb_batchmode.runner.breakpoint_callback'"
 
                 command_interpreter.HandleCommand(callback_command, res)
                 if res.Succeeded():

From c4d84db5f184088791011f216811d9e9fec32f0e Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Fri, 8 Aug 2025 17:47:25 +0200
Subject: [PATCH 10/20] Resolver: Batched import resolution.

Import resolution now happens in 2 phases:
1. We resolve all undetermined and collect their resolutions
2. Write all resolutions to the Resolver state.

Repeat this untill we reach a fix point.

+ Bless tests
---
 compiler/rustc_resolve/src/imports.rs         | 313 +++++++++++-------
 compiler/rustc_resolve/src/lib.rs             |  35 +-
 .../crates/hir-ty/src/mir/lower/as_place.rs   |   2 +-
 tests/ui/imports/ambiguous-14.rs              |   1 -
 tests/ui/imports/ambiguous-14.stderr          |  36 +-
 tests/ui/imports/ambiguous-9.rs               |   9 +-
 tests/ui/imports/ambiguous-9.stderr           |  52 +--
 tests/ui/imports/duplicate.rs                 |   1 -
 tests/ui/imports/duplicate.stderr             |  71 ++--
 tests/ui/imports/import-loop-2.rs             |   4 +-
 tests/ui/imports/import-loop-2.stderr         |   8 +-
 tests/ui/imports/import4.rs                   |   4 +-
 tests/ui/imports/import4.stderr               |   8 +-
 .../ui/imports/same-res-ambigious.fail.stderr |   2 +-
 .../ui/imports/same-res-ambigious.pass.stderr |  20 ++
 tests/ui/imports/same-res-ambigious.rs        |   3 +-
 tests/ui/privacy/privacy1.stderr              |  24 +-
 17 files changed, 303 insertions(+), 290 deletions(-)
 create mode 100644 tests/ui/imports/same-res-ambigious.pass.stderr

diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 46cc163ca8ed2..bed025438c331 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -57,6 +57,16 @@ pub(crate) enum PendingDecl<'ra> {
     Pending,
 }
 
+enum ImportResolutionKind<'ra> {
+    Single(PerNS<PendingDecl<'ra>>),
+    Glob(Vec<(Decl<'ra>, BindingKey, Span /* orig_ident_span */)>),
+}
+
+struct ImportResolution<'ra> {
+    kind: ImportResolutionKind<'ra>,
+    imported_module: ModuleOrUniformRoot<'ra>,
+}
+
 impl<'ra> PendingDecl<'ra> {
     pub(crate) fn decl(self) -> Option<Decl<'ra>> {
         match self {
@@ -442,7 +452,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             && (vis == import.vis
                 || max_vis.get().is_none_or(|max_vis| vis.greater_than(max_vis, self.tcx)))
         {
-            max_vis.set_unchecked(Some(vis))
+            // `set` can't fail because this can only happen during "write_import_resolutions"
+            max_vis.set(Some(vis), self)
         }
 
         self.arenas.alloc_decl(DeclData {
@@ -559,7 +570,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 && glob_decl.ambiguity.get().is_none()
             {
                 // Do not lose glob ambiguities when re-fetching the glob.
-                glob_decl.ambiguity.set_unchecked(Some((old_ambig, true)));
+                glob_decl.ambiguity.set(Some((old_ambig, true)), self);
             }
             glob_decl
         } else if glob_decl.res() != old_glob_decl.res() {
@@ -567,7 +578,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 || self.is_rustybuzz_0_4_0(old_glob_decl, glob_decl)
                 || self.is_pdf_0_9_0(old_glob_decl, glob_decl)
                 || self.is_net2_0_2_39(old_glob_decl, glob_decl);
-            old_glob_decl.ambiguity.set_unchecked(Some((glob_decl, warning)));
+            old_glob_decl.ambiguity.set(Some((glob_decl, warning)), self);
             old_glob_decl
         } else if let old_vis = old_glob_decl.vis()
             && let vis = glob_decl.vis()
@@ -576,17 +587,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             // We are glob-importing the same item but with a different visibility.
             // All visibilities here are ordered because all of them are ancestors of `module`.
             if vis.greater_than(old_vis, self.tcx) {
-                old_glob_decl.ambiguity_vis_max.set_unchecked(Some(glob_decl));
+                old_glob_decl.ambiguity_vis_max.set(Some(glob_decl), self);
             } else if let old_min_vis = old_glob_decl.min_vis()
                 && old_min_vis != vis
                 && old_min_vis.greater_than(vis, self.tcx)
             {
-                old_glob_decl.ambiguity_vis_min.set_unchecked(Some(glob_decl));
+                old_glob_decl.ambiguity_vis_min.set(Some(glob_decl), self);
             }
             old_glob_decl
         } else if glob_decl.is_ambiguity_recursive() && !old_glob_decl.is_ambiguity_recursive() {
             // Overwriting a non-ambiguous glob import with an ambiguous glob import.
-            old_glob_decl.ambiguity.set_unchecked(Some((glob_decl, true)));
+            old_glob_decl.ambiguity.set(Some((glob_decl, true)), self);
             old_glob_decl
         } else {
             old_glob_decl
@@ -613,7 +624,7 @@ 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_unchecked(|d| d + 1);
+            module.underscore_disambiguator.update(self, |d| d + 1);
             module.underscore_disambiguator.get()
         });
         self.update_local_resolution(module, key, orig_ident_span, |this, resolution| {
@@ -650,7 +661,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let (binding, t) = {
             let resolution = &mut *self
                 .resolution_or_default(module.to_module(), key, orig_ident_span)
-                .borrow_mut_unchecked();
+                .borrow_mut(self);
             let old_decl = resolution.determined_decl();
             let old_vis = old_decl.map(|d| d.vis());
 
@@ -665,7 +676,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
         };
 
-        let Ok(glob_importers) = module.glob_importers.try_borrow_mut_unchecked() else {
+        let Ok(glob_importers) = module.glob_importers.try_borrow_mut(self) else {
             return t;
         };
 
@@ -727,11 +738,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     // Import resolution
     //
-    // This is a fixed-point algorithm. We resolve imports until our efforts
-    // are stymied by an unresolved import; then we bail out of the current
-    // module and continue. We terminate successfully once no more imports
-    // remain or unsuccessfully when no forward progress in resolving imports
-    // is made.
+    // This is a batched fixed-point algorithm. Each import is resolved in
+    // isolation, with any resolutions collected for later.
+    // After a full pass over the current set of `indeterminate_imports`,
+    // the collected resolutions are committed together. The process
+    // repeats until either no imports remain or no further progress can
+    // be made.
 
     /// Resolves all imports for the crate. This method performs the fixed-
     /// point iteration.
@@ -741,16 +753,125 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         while indeterminate_count < prev_indeterminate_count {
             prev_indeterminate_count = indeterminate_count;
             indeterminate_count = 0;
+            let mut resolutions = Vec::new();
             self.assert_speculative = true;
             for import in mem::take(&mut self.indeterminate_imports) {
-                let import_indeterminate_count = self.cm().resolve_import(import);
+                let (resolution, import_indeterminate_count) = self.cm().resolve_import(import);
                 indeterminate_count += import_indeterminate_count;
                 match import_indeterminate_count {
                     0 => self.determined_imports.push(import),
                     _ => self.indeterminate_imports.push(import),
                 }
+                if let Some(resolution) = resolution {
+                    resolutions.push((import, resolution));
+                }
             }
             self.assert_speculative = false;
+            self.write_import_resolutions(resolutions);
+        }
+    }
+
+    fn write_import_resolutions(
+        &mut self,
+        import_resolutions: Vec<(Import<'ra>, ImportResolution<'ra>)>,
+    ) {
+        for (import, resolution) in &import_resolutions {
+            let ImportResolution { imported_module, .. } = resolution;
+            import.imported_module.set(Some(*imported_module), self);
+
+            if import.is_glob()
+                && let ModuleOrUniformRoot::Module(module) = imported_module
+                && import.parent_scope.module != *module
+                && module.is_local()
+            {
+                module.glob_importers.borrow_mut(self).push(*import);
+            }
+        }
+
+        for (import, resolution) in import_resolutions {
+            let ImportResolution { imported_module, kind: resolution_kind } = resolution;
+
+            match (&import.kind, resolution_kind) {
+                (
+                    ImportKind::Single { target, decls, .. },
+                    ImportResolutionKind::Single(import_decls),
+                ) => {
+                    self.per_ns(|this, ns| {
+                        match import_decls[ns] {
+                            PendingDecl::Ready(Some(import_decl)) => {
+                                if import_decl.is_assoc_item()
+                                    && !this.tcx.features().import_trait_associated_functions()
+                                {
+                                    feature_err(
+                                        this.tcx.sess,
+                                        sym::import_trait_associated_functions,
+                                        import.span,
+                                        "`use` associated items of traits is unstable",
+                                    )
+                                    .emit();
+                                }
+                                this.plant_decl_into_local_module(
+                                    IdentKey::new(*target),
+                                    target.span,
+                                    ns,
+                                    import_decl,
+                                );
+                                decls[ns].set(PendingDecl::Ready(Some(import_decl)), this);
+                            }
+                            PendingDecl::Ready(None) => {
+                                // Don't remove underscores from `single_imports`, they were never added.
+                                if target.name != kw::Underscore {
+                                    let key = BindingKey::new(IdentKey::new(*target), ns);
+                                    this.update_local_resolution(
+                                        import.parent_scope.module.expect_local(),
+                                        key,
+                                        target.span,
+                                        |_, resolution| {
+                                            resolution.single_imports.swap_remove(&import);
+                                        },
+                                    );
+                                }
+                                decls[ns].set(PendingDecl::Ready(None), this);
+                            }
+                            PendingDecl::Pending => {}
+                        }
+                    });
+                }
+                (ImportKind::Glob { id, .. }, ImportResolutionKind::Glob(imported_decls)) => {
+                    let ModuleOrUniformRoot::Module(module) = imported_module else {
+                        self.dcx().emit_err(CannotGlobImportAllCrates { span: import.span });
+                        continue;
+                    };
+
+                    if module.is_trait() && !self.tcx.features().import_trait_associated_functions()
+                    {
+                        feature_err(
+                            self.tcx.sess,
+                            sym::import_trait_associated_functions,
+                            import.span,
+                            "`use` associated items of traits is unstable",
+                        )
+                        .emit();
+                    }
+
+                    for (binding, key, orig_ident_span) in imported_decls {
+                        let import_decl = self.new_import_decl(binding, import);
+                        let _ = self
+                            .try_plant_decl_into_local_module(
+                                key.ident,
+                                orig_ident_span,
+                                key.ns,
+                                import_decl,
+                            )
+                            .expect("planting a glob cannot fail");
+                    }
+
+                    self.record_partial_res(*id, PartialRes::new(module.res().unwrap()));
+                }
+
+                // Something weird happened, which shouldn't have happened.
+                _ => unreachable!("mismatched import and resolution kind"),
+            }
         }
     }
 
@@ -1085,12 +1206,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     /// - `0` means its resolution is determined.
     /// - Other values mean that indeterminate exists under certain namespaces.
     ///
-    /// Meanwhile, if resolve successful, the resolved bindings are written
-    /// into the module.
-    fn resolve_import<'r>(mut self: CmResolver<'r, 'ra, 'tcx>, import: Import<'ra>) -> usize {
+    /// Meanwhile, if resolution is successful, its result is returned.
+    fn resolve_import<'r>(
+        mut self: CmResolver<'r, 'ra, 'tcx>,
+        import: Import<'ra>,
+    ) -> (Option<ImportResolution<'ra>>, usize) {
         debug!(
-            "(resolving import for module) resolving import `{}::...` in `{}`",
+            "(resolving import for module) resolving import `{}::{}` in `{}`",
             Segment::names_to_string(&import.module_path),
+            import_kind_to_string(&import.kind),
             module_to_string(import.parent_scope.module).unwrap_or_else(|| "???".to_string()),
         );
         let module = if let Some(module) = import.imported_module.get() {
@@ -1105,21 +1229,24 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             match path_res {
                 PathResult::Module(module) => module,
-                PathResult::Indeterminate => return 3,
-                PathResult::NonModule(..) | PathResult::Failed { .. } => return 0,
+                PathResult::Indeterminate => return (None, 3),
+                PathResult::NonModule(..) | PathResult::Failed { .. } => return (None, 0),
             }
         };
 
-        import.imported_module.set_unchecked(Some(module));
-        let (source, target, bindings) = match import.kind {
-            ImportKind::Single { source, target, ref decls, .. } => (source, target, decls),
+        let (source, bindings) = match import.kind {
+            ImportKind::Single { source, ref decls, .. } => (source, decls),
             ImportKind::Glob { .. } => {
-                self.get_mut_unchecked().resolve_glob_import(import);
-                return 0;
+                let import_resolution = ImportResolution {
+                    imported_module: module,
+                    kind: self.resolve_glob_import(import, module),
+                };
+                return (Some(import_resolution), 0);
             }
             _ => unreachable!(),
         };
 
+        let mut import_decls = PerNS::default();
         let mut indeterminate_count = 0;
         self.per_ns_cm(|mut this, ns| {
             if bindings[ns].get() != PendingDecl::Pending {
@@ -1132,54 +1259,26 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 &import.parent_scope,
                 Some(import),
             );
-            let parent = import.parent_scope.module;
-            let binding = match binding_result {
+            let pending_decl = match binding_result {
                 Ok(binding) => {
-                    if binding.is_assoc_item()
-                        && !this.tcx.features().import_trait_associated_functions()
-                    {
-                        feature_err(
-                            this.tcx.sess,
-                            sym::import_trait_associated_functions,
-                            import.span,
-                            "`use` associated items of traits is unstable",
-                        )
-                        .emit();
-                    }
                     // We need the `target`, `source` can be extracted.
                     let import_decl = this.new_import_decl(binding, import);
-                    this.get_mut_unchecked().plant_decl_into_local_module(
-                        IdentKey::new(target),
-                        target.span,
-                        ns,
-                        import_decl,
-                    );
                     PendingDecl::Ready(Some(import_decl))
                 }
-                Err(Determinacy::Determined) => {
-                    // Don't remove underscores from `single_imports`, they were never added.
-                    if target.name != kw::Underscore {
-                        let key = BindingKey::new(IdentKey::new(target), ns);
-                        this.get_mut_unchecked().update_local_resolution(
-                            parent.expect_local(),
-                            key,
-                            target.span,
-                            |_, resolution| {
-                                resolution.single_imports.swap_remove(&import);
-                            },
-                        );
-                    }
-                    PendingDecl::Ready(None)
-                }
+                Err(Determinacy::Determined) => PendingDecl::Ready(None),
                 Err(Determinacy::Undetermined) => {
                     indeterminate_count += 1;
                     PendingDecl::Pending
                 }
             };
-            bindings[ns].set_unchecked(binding);
+            import_decls[ns] = pending_decl;
         });
+        let import_resolution = ImportResolution {
+            imported_module: module,
+            kind: ImportResolutionKind::Single(import_decls),
+        };
 
-        indeterminate_count
+        (Some(import_resolution), indeterminate_count)
     }
 
     /// Performs final import resolution, consistency checks and error reporting.
@@ -1799,68 +1898,40 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         false
     }
 
-    fn resolve_glob_import(&mut self, import: Import<'ra>) {
-        // This function is only called for glob imports.
-        let ImportKind::Glob { id, .. } = import.kind else { unreachable!() };
+    fn resolve_glob_import(
+        &self,
+        import: Import<'ra>,
+        imported_module: ModuleOrUniformRoot<'ra>,
+    ) -> ImportResolutionKind<'ra> {
+        let import_bindings = match imported_module {
+            ModuleOrUniformRoot::Module(module) if module != import.parent_scope.module => self
+                .resolutions(module)
+                .borrow()
+                .iter()
+                .filter_map(|(key, resolution)| {
+                    let res = resolution.borrow();
+                    let decl = res.determined_decl()?;
+                    let mut key = *key;
+                    let scope = match key.ident.ctxt.update_unchecked(|ctxt| {
+                        ctxt.reverse_glob_adjust(module.expansion, import.span)
+                    }) {
+                        Some(Some(def)) => self.expn_def_scope(def),
+                        Some(None) => import.parent_scope.module,
+                        None => return None,
+                    };
+                    self.is_accessible_from(decl.vis(), scope).then_some((
+                        decl,
+                        key,
+                        res.orig_ident_span,
+                    ))
+                })
+                .collect::<Vec<_>>(),
 
-        let ModuleOrUniformRoot::Module(module) = import.imported_module.get().unwrap() else {
-            self.dcx().emit_err(CannotGlobImportAllCrates { span: import.span });
-            return;
+            // Errors are reported in `write_imports_resolutions`
+            _ => vec![],
         };
 
-        if module.is_trait() && !self.tcx.features().import_trait_associated_functions() {
-            feature_err(
-                self.tcx.sess,
-                sym::import_trait_associated_functions,
-                import.span,
-                "`use` associated items of traits is unstable",
-            )
-            .emit();
-        }
-
-        if module == import.parent_scope.module {
-            return;
-        }
-
-        // Add to module's glob_importers
-        if module.is_local() {
-            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.
-        let bindings = self
-            .resolutions(module)
-            .borrow()
-            .iter()
-            .filter_map(|(key, resolution)| {
-                let resolution = resolution.borrow();
-                resolution.determined_decl().map(|decl| (*key, decl, resolution.orig_ident_span))
-            })
-            .collect::<Vec<_>>();
-        for (mut key, binding, orig_ident_span) in bindings {
-            let scope =
-                match key.ident.ctxt.update_unchecked(|ctxt| {
-                    ctxt.reverse_glob_adjust(module.expansion, import.span)
-                }) {
-                    Some(Some(def)) => self.expn_def_scope(def),
-                    Some(None) => import.parent_scope.module,
-                    None => continue,
-                };
-            if self.is_accessible_from(binding.vis(), scope) {
-                let import_decl = self.new_import_decl(binding, import);
-                self.try_plant_decl_into_local_module(
-                    key.ident,
-                    orig_ident_span,
-                    key.ns,
-                    import_decl,
-                )
-                .expect("planting a glob cannot fail");
-            }
-        }
-
-        // Record the destination of this import
-        self.record_partial_res(id, PartialRes::new(module.res().unwrap()));
+        ImportResolutionKind::Glob(import_bindings)
     }
 
     // Miscellaneous post-processing, including recording re-exports,
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 9af55565d30b7..090722c496fd8 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -2868,16 +2868,10 @@ mod ref_mut {
         #[track_caller]
         pub(crate) fn get_mut(&mut self) -> &mut T {
             match self.mutable {
-                false => panic!("Can't mutably borrow speculative resolver"),
+                false => panic!("can't mutably borrow speculative resolver"),
                 true => self.p,
             }
         }
-
-        /// Returns a mutable reference to the inner value without checking if
-        /// it's in a mutable state.
-        pub(crate) fn get_mut_unchecked(&mut self) -> &mut T {
-            self.p
-        }
     }
 
     /// A wrapper around a [`Cell`] that only allows mutation based on a condition in the resolver.
@@ -2901,12 +2895,12 @@ mod ref_mut {
             self.0.get()
         }
 
-        pub(crate) fn update_unchecked(&self, f: impl FnOnce(T) -> T)
+        pub(crate) fn update<'ra, 'tcx>(&self, r: &Resolver<'ra, 'tcx>, f: impl FnOnce(T) -> T)
         where
             T: Copy,
         {
             let old = self.get();
-            self.set_unchecked(f(old));
+            self.set(f(old), r);
         }
     }
 
@@ -2915,7 +2909,10 @@ mod ref_mut {
             CmCell(Cell::new(value))
         }
 
-        pub(crate) fn set_unchecked(&self, val: T) {
+        pub(crate) fn set<'ra, 'tcx>(&self, val: T, r: &Resolver<'ra, 'tcx>) {
+            if r.assert_speculative {
+                panic!("not allowed to mutate a `CmCell` during speculative resolution")
+            }
             self.0.set(val);
         }
 
@@ -2941,16 +2938,26 @@ mod ref_mut {
         #[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");
+                panic!("not allowed to mutably borrow a `CmRefCell` during speculative resolution");
             }
-            self.borrow_mut_unchecked()
+            self.0.borrow_mut()
         }
 
-        #[track_caller]
         pub(crate) fn try_borrow_mut_unchecked(&self) -> Result<RefMut<'_, T>, BorrowMutError> {
             self.0.try_borrow_mut()
         }
 
+        #[track_caller]
+        pub(crate) fn try_borrow_mut<'ra, 'tcx>(
+            &self,
+            r: &Resolver<'ra, 'tcx>,
+        ) -> Result<RefMut<'_, T>, BorrowMutError> {
+            if r.assert_speculative {
+                panic!("not allowed to mutably borrow a `CmRefCell` during speculative resolution");
+            }
+            self.0.try_borrow_mut()
+        }
+
         #[track_caller]
         pub(crate) fn borrow(&self) -> Ref<'_, T> {
             self.0.borrow()
@@ -2960,7 +2967,7 @@ mod ref_mut {
     impl<T: Default> CmRefCell<T> {
         pub(crate) fn take<'ra, 'tcx>(&self, r: &Resolver<'ra, 'tcx>) -> T {
             if r.assert_speculative {
-                panic!("Not allowed to mutate a CmRefCell during speculative resolution");
+                panic!("not allowed to mutate a CmRefCell during speculative resolution");
             }
             self.0.take()
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/as_place.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/as_place.rs
index 2ed7aedecffef..453866e93b965 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/as_place.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/as_place.rs
@@ -1,7 +1,7 @@
 //! MIR lowering for places
 
 use hir_def::FunctionId;
-use rustc_type_ir::inherent::{Region as _, Ty as _};
+use rustc_type_ir::inherent::Region as _;
 
 use super::*;
 use crate::{
diff --git a/tests/ui/imports/ambiguous-14.rs b/tests/ui/imports/ambiguous-14.rs
index ba2d7dc4e0166..b7203a2cb6fb4 100644
--- a/tests/ui/imports/ambiguous-14.rs
+++ b/tests/ui/imports/ambiguous-14.rs
@@ -22,5 +22,4 @@ mod g {
 fn main() {
     g::foo();
     //~^ ERROR `foo` is ambiguous
-    //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
diff --git a/tests/ui/imports/ambiguous-14.stderr b/tests/ui/imports/ambiguous-14.stderr
index 2ca10d2d6a848..327dd075945a4 100644
--- a/tests/ui/imports/ambiguous-14.stderr
+++ b/tests/ui/imports/ambiguous-14.stderr
@@ -1,4 +1,4 @@
-error: `foo` is ambiguous
+error[E0659]: `foo` is ambiguous
   --> $DIR/ambiguous-14.rs:23:8
    |
 LL |     g::foo();
@@ -6,44 +6,18 @@ LL |     g::foo();
    |
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `foo` could refer to the function imported here
-  --> $DIR/ambiguous-14.rs:18:13
+  --> $DIR/ambiguous-14.rs:13:13
    |
 LL |     pub use a::*;
    |             ^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 note: `foo` could also refer to the function imported here
-  --> $DIR/ambiguous-14.rs:19:13
+  --> $DIR/ambiguous-14.rs:14:13
    |
-LL |     pub use f::*;
+LL |     pub use b::*;
    |             ^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
-   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
-   = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
 
 error: aborting due to 1 previous error
 
-Future incompatibility report: Future breakage diagnostic:
-error: `foo` is ambiguous
-  --> $DIR/ambiguous-14.rs:23:8
-   |
-LL |     g::foo();
-   |        ^^^ ambiguous name
-   |
-   = note: ambiguous because of multiple glob imports of a name in the same module
-note: `foo` could refer to the function imported here
-  --> $DIR/ambiguous-14.rs:18:13
-   |
-LL |     pub use a::*;
-   |             ^^^^
-   = help: consider adding an explicit import of `foo` to disambiguate
-note: `foo` could also refer to the function imported here
-  --> $DIR/ambiguous-14.rs:19:13
-   |
-LL |     pub use f::*;
-   |             ^^^^
-   = help: consider adding an explicit import of `foo` to disambiguate
-   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
-   = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
-
+For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/ambiguous-9.rs b/tests/ui/imports/ambiguous-9.rs
index 58796031bf18f..0e60a2929c024 100644
--- a/tests/ui/imports/ambiguous-9.rs
+++ b/tests/ui/imports/ambiguous-9.rs
@@ -4,16 +4,16 @@ pub mod dsl {
     mod range {
         pub fn date_range() {}
     }
-    pub use self::range::*; //~ WARNING ambiguous glob re-exports
+    pub use self::range::*;
     use super::prelude::*;
 }
 
 pub mod prelude {
     mod t {
-      pub fn date_range() {}
+        pub fn date_range() {}
     }
-    pub use self::t::*; //~ WARNING ambiguous glob re-exports
-    pub use super::dsl::*;
+    pub use self::t::*;
+    pub use super::dsl::*; //~ WARNING ambiguous glob re-exports
 }
 
 use dsl::*;
@@ -22,5 +22,4 @@ use prelude::*;
 fn main() {
     date_range();
     //~^ ERROR `date_range` is ambiguous
-    //~| ERROR `date_range` is ambiguous
 }
diff --git a/tests/ui/imports/ambiguous-9.stderr b/tests/ui/imports/ambiguous-9.stderr
index b6e4c30a8d410..0ffbeb7c89509 100644
--- a/tests/ui/imports/ambiguous-9.stderr
+++ b/tests/ui/imports/ambiguous-9.stderr
@@ -6,56 +6,28 @@ LL |     date_range();
    |
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `date_range` could refer to the function imported here
-  --> $DIR/ambiguous-9.rs:19:5
+  --> $DIR/ambiguous-9.rs:16:13
    |
-LL | use dsl::*;
-   |     ^^^^^^
-   = help: consider adding an explicit import of `date_range` to disambiguate
-note: `date_range` could also refer to the function imported here
-  --> $DIR/ambiguous-9.rs:20:5
-   |
-LL | use prelude::*;
-   |     ^^^^^^^^^^
-   = help: consider adding an explicit import of `date_range` to disambiguate
-
-error[E0659]: `date_range` is ambiguous
-  --> $DIR/ambiguous-9.rs:23:5
-   |
-LL |     date_range();
-   |     ^^^^^^^^^^ ambiguous name
-   |
-   = note: ambiguous because of multiple glob imports of a name in the same module
-note: `date_range` could refer to the function imported here
-  --> $DIR/ambiguous-9.rs:7:13
-   |
-LL |     pub use self::range::*;
-   |             ^^^^^^^^^^^^^^
+LL |     pub use super::dsl::*;
+   |             ^^^^^^^^^^^^^
    = help: consider adding an explicit import of `date_range` to disambiguate
 note: `date_range` could also refer to the function imported here
-  --> $DIR/ambiguous-9.rs:8:9
+  --> $DIR/ambiguous-9.rs:15:13
    |
-LL |     use super::prelude::*;
-   |         ^^^^^^^^^^^^^^^^^
+LL |     pub use self::t::*;
+   |             ^^^^^^^^^^
    = help: consider adding an explicit import of `date_range` to disambiguate
 
 warning: ambiguous glob re-exports
-  --> $DIR/ambiguous-9.rs:7:13
-   |
-LL |     pub use self::range::*;
-   |             ^^^^^^^^^^^^^^ the name `date_range` in the value namespace is first re-exported here
-LL |     use super::prelude::*;
-   |         ----------------- but the name `date_range` in the value namespace is also re-exported here
-   |
-   = note: `#[warn(ambiguous_glob_reexports)]` on by default
-
-warning: ambiguous glob re-exports
-  --> $DIR/ambiguous-9.rs:15:13
+  --> $DIR/ambiguous-9.rs:16:13
    |
 LL |     pub use self::t::*;
-   |             ^^^^^^^^^^ the name `date_range` in the value namespace is first re-exported here
+   |             ---------- but the name `date_range` in the value namespace is also re-exported here
 LL |     pub use super::dsl::*;
-   |             ------------- but the name `date_range` in the value namespace is also re-exported here
+   |             ^^^^^^^^^^^^^ the name `date_range` in the value namespace is first re-exported here
+   |
+   = note: `#[warn(ambiguous_glob_reexports)]` on by default
 
-error: aborting due to 2 previous errors; 2 warnings emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/duplicate.rs b/tests/ui/imports/duplicate.rs
index 0a652889ca8ad..be089dbf5a4af 100644
--- a/tests/ui/imports/duplicate.rs
+++ b/tests/ui/imports/duplicate.rs
@@ -35,7 +35,6 @@ fn main() {
     f::foo(); //~ ERROR `foo` is ambiguous
     g::foo();
     //~^ ERROR `foo` is ambiguous
-    //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
 
 mod ambiguous_module_errors {
diff --git a/tests/ui/imports/duplicate.stderr b/tests/ui/imports/duplicate.stderr
index f02d35b1d28ce..7bff44109e40b 100644
--- a/tests/ui/imports/duplicate.stderr
+++ b/tests/ui/imports/duplicate.stderr
@@ -9,20 +9,20 @@ LL |     use crate::a::foo;
    = note: `foo` must be defined only once in the value namespace of this module
 
 error[E0659]: `foo` is ambiguous
-  --> $DIR/duplicate.rs:48:15
+  --> $DIR/duplicate.rs:47:15
    |
 LL |     use self::foo::bar;
    |               ^^^ ambiguous name
    |
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `foo` could refer to the module imported here
-  --> $DIR/duplicate.rs:45:9
+  --> $DIR/duplicate.rs:44:9
    |
 LL |     use self::m1::*;
    |         ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 note: `foo` could also refer to the module imported here
-  --> $DIR/duplicate.rs:46:9
+  --> $DIR/duplicate.rs:45:9
    |
 LL |     use self::m2::*;
    |         ^^^^^^^^^^^
@@ -49,26 +49,6 @@ LL |     pub use crate::b::*;
    = help: consider adding an explicit import of `foo` to disambiguate
 
 error[E0659]: `foo` is ambiguous
-  --> $DIR/duplicate.rs:51:9
-   |
-LL |         foo::bar();
-   |         ^^^ ambiguous name
-   |
-   = note: ambiguous because of multiple glob imports of a name in the same module
-note: `foo` could refer to the module imported here
-  --> $DIR/duplicate.rs:45:9
-   |
-LL |     use self::m1::*;
-   |         ^^^^^^^^^^^
-   = help: consider adding an explicit import of `foo` to disambiguate
-note: `foo` could also refer to the module imported here
-  --> $DIR/duplicate.rs:46:9
-   |
-LL |     use self::m2::*;
-   |         ^^^^^^^^^^^
-   = help: consider adding an explicit import of `foo` to disambiguate
-
-error: `foo` is ambiguous
   --> $DIR/duplicate.rs:36:8
    |
 LL |     g::foo();
@@ -76,46 +56,39 @@ LL |     g::foo();
    |
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `foo` could refer to the function imported here
-  --> $DIR/duplicate.rs:29:13
+  --> $DIR/duplicate.rs:24:13
    |
 LL |     pub use crate::a::*;
    |             ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 note: `foo` could also refer to the function imported here
-  --> $DIR/duplicate.rs:30:13
+  --> $DIR/duplicate.rs:25:13
    |
-LL |     pub use crate::f::*;
+LL |     pub use crate::b::*;
    |             ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
-   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
-   = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
-
-error: aborting due to 5 previous errors
 
-Some errors have detailed explanations: E0252, E0659.
-For more information about an error, try `rustc --explain E0252`.
-Future incompatibility report: Future breakage diagnostic:
-error: `foo` is ambiguous
-  --> $DIR/duplicate.rs:36:8
+error[E0659]: `foo` is ambiguous
+  --> $DIR/duplicate.rs:50:9
    |
-LL |     g::foo();
-   |        ^^^ ambiguous name
+LL |         foo::bar();
+   |         ^^^ ambiguous name
    |
    = note: ambiguous because of multiple glob imports of a name in the same module
-note: `foo` could refer to the function imported here
-  --> $DIR/duplicate.rs:29:13
+note: `foo` could refer to the module imported here
+  --> $DIR/duplicate.rs:44:9
    |
-LL |     pub use crate::a::*;
-   |             ^^^^^^^^^^^
+LL |     use self::m1::*;
+   |         ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
-note: `foo` could also refer to the function imported here
-  --> $DIR/duplicate.rs:30:13
+note: `foo` could also refer to the module imported here
+  --> $DIR/duplicate.rs:45:9
    |
-LL |     pub use crate::f::*;
-   |             ^^^^^^^^^^^
+LL |     use self::m2::*;
+   |         ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
-   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
-   = note: `#[deny(ambiguous_glob_imports)]` (part of `#[deny(future_incompatible)]`) on by default
 
+error: aborting due to 5 previous errors
+
+Some errors have detailed explanations: E0252, E0659.
+For more information about an error, try `rustc --explain E0252`.
diff --git a/tests/ui/imports/import-loop-2.rs b/tests/ui/imports/import-loop-2.rs
index 42f9a07fff389..af5c6509d38b6 100644
--- a/tests/ui/imports/import-loop-2.rs
+++ b/tests/ui/imports/import-loop-2.rs
@@ -1,9 +1,9 @@
 mod a {
-    pub use crate::b::x;
+    pub use crate::b::x; //~ ERROR unresolved import `crate::b::x`
 }
 
 mod b {
-    pub use crate::a::x; //~ ERROR unresolved import `crate::a::x`
+    pub use crate::a::x;
 
     fn main() { let y = x; }
 }
diff --git a/tests/ui/imports/import-loop-2.stderr b/tests/ui/imports/import-loop-2.stderr
index 2ef40c4e21829..dfa7cf35eaac2 100644
--- a/tests/ui/imports/import-loop-2.stderr
+++ b/tests/ui/imports/import-loop-2.stderr
@@ -1,8 +1,8 @@
-error[E0432]: unresolved import `crate::a::x`
-  --> $DIR/import-loop-2.rs:6:13
+error[E0432]: unresolved import `crate::b::x`
+  --> $DIR/import-loop-2.rs:2:13
    |
-LL |     pub use crate::a::x;
-   |             ^^^^^^^^^^^ no `x` in `a`
+LL |     pub use crate::b::x;
+   |             ^^^^^^^^^^^ no `x` in `b`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/import4.rs b/tests/ui/imports/import4.rs
index f670cc06201c0..76a9887534c34 100644
--- a/tests/ui/imports/import4.rs
+++ b/tests/ui/imports/import4.rs
@@ -1,4 +1,4 @@
-mod a { pub use crate::b::foo; }
-mod b { pub use crate::a::foo; } //~ ERROR unresolved import `crate::a::foo`
+mod a { pub use crate::b::foo; } //~ ERROR unresolved import `crate::b::foo`
+mod b { pub use crate::a::foo; }
 
 fn main() { println!("loop"); }
diff --git a/tests/ui/imports/import4.stderr b/tests/ui/imports/import4.stderr
index 4faa5f0520a9d..07fdc6a3d0ced 100644
--- a/tests/ui/imports/import4.stderr
+++ b/tests/ui/imports/import4.stderr
@@ -1,8 +1,8 @@
-error[E0432]: unresolved import `crate::a::foo`
-  --> $DIR/import4.rs:2:17
+error[E0432]: unresolved import `crate::b::foo`
+  --> $DIR/import4.rs:1:17
    |
-LL | mod b { pub use crate::a::foo; }
-   |                 ^^^^^^^^^^^^^ no `foo` in `a`
+LL | mod a { pub use crate::b::foo; }
+   |                 ^^^^^^^^^^^^^ no `foo` in `b`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/same-res-ambigious.fail.stderr b/tests/ui/imports/same-res-ambigious.fail.stderr
index dfd7c5a5f94e0..aeeff5f2e2ad8 100644
--- a/tests/ui/imports/same-res-ambigious.fail.stderr
+++ b/tests/ui/imports/same-res-ambigious.fail.stderr
@@ -1,5 +1,5 @@
 error[E0603]: derive macro `Embed` is private
-  --> $DIR/same-res-ambigious.rs:8:28
+  --> $DIR/same-res-ambigious.rs:7:28
    |
 LL | #[derive(ambigious_extern::Embed)]
    |                            ^^^^^ private derive macro
diff --git a/tests/ui/imports/same-res-ambigious.pass.stderr b/tests/ui/imports/same-res-ambigious.pass.stderr
new file mode 100644
index 0000000000000..a1d75a4387f66
--- /dev/null
+++ b/tests/ui/imports/same-res-ambigious.pass.stderr
@@ -0,0 +1,20 @@
+error[E0603]: derive macro `Embed` is private
+  --> $DIR/same-res-ambigious.rs:7:28
+   |
+LL | #[derive(ambigious_extern::Embed)]
+   |                            ^^^^^ private derive macro
+   |
+note: the derive macro `Embed` is defined here
+  --> $DIR/auxiliary/same-res-ambigious-extern.rs:11: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
index b5c13a15b7c9c..52a40450b942f 100644
--- a/tests/ui/imports/same-res-ambigious.rs
+++ b/tests/ui/imports/same-res-ambigious.rs
@@ -1,11 +1,10 @@
 //@ 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
+#[derive(ambigious_extern::Embed)] //~ ERROR: derive macro `Embed` is private
 struct Foo{}
 
 fn main(){}
diff --git a/tests/ui/privacy/privacy1.stderr b/tests/ui/privacy/privacy1.stderr
index 5d1e003c703b4..22cc16b12af79 100644
--- a/tests/ui/privacy/privacy1.stderr
+++ b/tests/ui/privacy/privacy1.stderr
@@ -34,18 +34,6 @@ note: the module `baz` is defined here
 LL |     mod baz {
    |     ^^^^^^^
 
-error[E0603]: module `baz` is private
-  --> $DIR/privacy1.rs:148:18
-   |
-LL |         use bar::baz;
-   |                  ^^^ private module
-   |
-note: the module `baz` is defined here
-  --> $DIR/privacy1.rs:57:5
-   |
-LL |     mod baz {
-   |     ^^^^^^^
-
 error[E0603]: module `i` is private
   --> $DIR/privacy1.rs:172:20
    |
@@ -60,6 +48,18 @@ note: the module `i` is defined here
 LL |         mod i {
    |         ^^^^^
 
+error[E0603]: module `baz` is private
+  --> $DIR/privacy1.rs:148:18
+   |
+LL |         use bar::baz;
+   |                  ^^^ private module
+   |
+note: the module `baz` is defined here
+  --> $DIR/privacy1.rs:57:5
+   |
+LL |     mod baz {
+   |     ^^^^^^^
+
 error[E0603]: module `baz` is private
   --> $DIR/privacy1.rs:111:21
    |

From b09dbec01db64a823f3d1b96cc8a8b1f89dd0a83 Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Tue, 24 Feb 2026 18:02:09 +0100
Subject: [PATCH 11/20] hack for RustEmbed with updated test

---
 compiler/rustc_resolve/src/imports.rs         | 48 ++++++++++++++++---
 compiler/rustc_span/src/symbol.rs             |  2 +
 .../ui/imports/same-res-ambigious.fail.stderr | 20 --------
 .../ui/imports/same-res-ambigious.pass.stderr | 20 --------
 tests/ui/imports/same-res-ambigious.rs        |  3 +-
 5 files changed, 46 insertions(+), 47 deletions(-)
 delete mode 100644 tests/ui/imports/same-res-ambigious.fail.stderr
 delete mode 100644 tests/ui/imports/same-res-ambigious.pass.stderr

diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index bed025438c331..9e0f5c24d1101 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -1934,6 +1934,38 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ImportResolutionKind::Glob(import_bindings)
     }
 
+    // Hack for the `rust_embed` regression observed in the crater run of #145108.
+    fn rust_embed_hack(&self, module: LocalModule<'ra>, decl: Decl<'ra>) -> bool {
+        // We are looking for this pattern:
+        // ```rust
+        // #[macro_use]
+        // extern crate rust_embed_impl;
+        // pub use rust_embed_impl::*;
+        //
+        // pub use RustEmbed as Embed;
+        // ```
+        if let DeclKind::Import { source_decl, import } = decl.kind
+            // Check that `decl` is the re-export: "pub use RustEmbed as Embed;"
+            && let ImportKind::Single { source, .. } = import.kind
+            && source.name == sym::RustEmbed
+            // make sure that the import points to the #[macro_use] import
+            && let DeclKind::Import { import, .. } = source_decl.kind
+            && matches!(import.kind, ImportKind::MacroUse { .. })
+            && self.macro_use_prelude.contains_key(&source.name) // and that the name actually exists in the macro_use_prelude
+            // Then check that `RustEmbed` exists in the modules Macro namespace.
+            && let Some(y_decl) = self
+                .resolution(module.to_module(), BindingKey::new(IdentKey::new(source), MacroNS))
+                .and_then(|res| res.best_decl())
+            // which comes from "pub use rust_embed_impl::*"
+            && y_decl.is_glob_import()
+            && y_decl.vis().is_public()
+        {
+            return true;
+        }
+
+        false
+    }
+
     // Miscellaneous post-processing, including recording re-exports,
     // reporting conflicts, and reporting unresolved imports.
     fn finalize_resolutions_in(
@@ -1950,13 +1982,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut children = Vec::new();
         let mut ambig_children = Vec::new();
 
-        module.to_module().for_each_child(self, |_this, ident, orig_ident_span, _, binding| {
-            let res = binding.res().expect_non_local();
+        module.to_module().for_each_child(self, |this, ident, orig_ident_span, _, decl| {
+            let res = decl.res().expect_non_local();
             if res != def::Res::Err {
+                let vis = if this.rust_embed_hack(module, decl) {
+                    Visibility::Public
+                } else {
+                    decl.vis()
+                };
                 let ident = ident.orig(orig_ident_span);
-                let child =
-                    |reexport_chain| ModChild { ident, res, vis: binding.vis(), reexport_chain };
-                if let Some((ambig_binding1, ambig_binding2)) = binding.descent_to_ambiguity() {
+                let child = |reexport_chain| ModChild { ident, res, vis, reexport_chain };
+                if let Some((ambig_binding1, ambig_binding2)) = decl.descent_to_ambiguity() {
                     let main = child(ambig_binding1.reexport_chain());
                     let second = ModChild {
                         ident,
@@ -1966,7 +2002,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     };
                     ambig_children.push(AmbigModChild { main, second })
                 } else {
-                    children.push(child(binding.reexport_chain()));
+                    children.push(child(decl.reexport_chain()));
                 }
             }
         });
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index fb433aef68cf8..86eea0bf303c6 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -294,6 +294,8 @@ symbols! {
         ResumeTy,
         Reverse,
         Rust,
+        // Temporary name for the rust_embed hack introduced in #145108
+        RustEmbed,
         RustaceansAreAwesome,
         RwLock,
         RwLockReadGuard,
diff --git a/tests/ui/imports/same-res-ambigious.fail.stderr b/tests/ui/imports/same-res-ambigious.fail.stderr
deleted file mode 100644
index aeeff5f2e2ad8..0000000000000
--- a/tests/ui/imports/same-res-ambigious.fail.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0603]: derive macro `Embed` is private
-  --> $DIR/same-res-ambigious.rs:7: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.pass.stderr b/tests/ui/imports/same-res-ambigious.pass.stderr
deleted file mode 100644
index a1d75a4387f66..0000000000000
--- a/tests/ui/imports/same-res-ambigious.pass.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0603]: derive macro `Embed` is private
-  --> $DIR/same-res-ambigious.rs:7:28
-   |
-LL | #[derive(ambigious_extern::Embed)]
-   |                            ^^^^^ private derive macro
-   |
-note: the derive macro `Embed` is defined here
-  --> $DIR/auxiliary/same-res-ambigious-extern.rs:11: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
index 52a40450b942f..0bfd10f18ada8 100644
--- a/tests/ui/imports/same-res-ambigious.rs
+++ b/tests/ui/imports/same-res-ambigious.rs
@@ -1,10 +1,11 @@
+//@ check-pass
 //@ edition: 2018
 //@ revisions: fail 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)] //~ ERROR: derive macro `Embed` is private
+#[derive(ambigious_extern::Embed)]
 struct Foo{}
 
 fn main(){}

From fe7c7a11a7b450504e9674518fcf6ddb0e581a2f Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Fri, 5 Jun 2026 16:58:54 +0200
Subject: [PATCH 12/20] Add extra line in generator script for `core_arch` that
 unambiguously imports the correct traits for `aarch64`. + run the generator
 to apply change.

---
 library/stdarch/crates/core_arch/src/aarch64/sve/generated.rs | 1 +
 library/stdarch/crates/stdarch-gen-arm/src/main.rs            | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/stdarch/crates/core_arch/src/aarch64/sve/generated.rs b/library/stdarch/crates/core_arch/src/aarch64/sve/generated.rs
index 6c6a2476a43fd..e1157f3440cfb 100644
--- a/library/stdarch/crates/core_arch/src/aarch64/sve/generated.rs
+++ b/library/stdarch/crates/core_arch/src/aarch64/sve/generated.rs
@@ -12,6 +12,7 @@ use stdarch_test::assert_instr;
 
 use super::*;
 use crate::core_arch::arch::aarch64::*;
+use super::{AsSigned, AsUnsigned};
 
 #[doc = "Absolute difference"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/svabd[_f32]_m)"]
diff --git a/library/stdarch/crates/stdarch-gen-arm/src/main.rs b/library/stdarch/crates/stdarch-gen-arm/src/main.rs
index b7e2aa416fb59..717a1707aafe3 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/main.rs
+++ b/library/stdarch/crates/stdarch-gen-arm/src/main.rs
@@ -166,7 +166,7 @@ use super::*;{uses_neon}
 
 "#,
         uses_neon = if generated_input.ctx.uses_neon_types {
-            "\nuse crate::core_arch::arch::aarch64::*;"
+            "\nuse crate::core_arch::arch::aarch64::*;\nuse super::{AsSigned, AsUnsigned};"
         } else {
             ""
         },

From d21aa1c6f408299d5f7634be413c0a901c63a680 Mon Sep 17 00:00:00 2001
From: zedddie <zedddie@protonmail.com>
Date: Sat, 6 Jun 2026 20:30:55 +0200
Subject: [PATCH 13/20] move batch

---
 .../issue-19037.rs => derives/clone-copy/clone-ref-to-dst.rs}     | 0
 .../dyn-incompat-const-slice.rs}                                  | 0
 .../dyn-incompat-const-slice.stderr}                              | 0
 .../manual-fn-impl-lifetime-elision.rs}                           | 0
 .../trait-bounds/hrtb-closure-lifetime-infer.rs}                  | 0
 .../trait-bounds/hrtb-unused-lifetime.rs}                         | 0
 tests/ui/{issues/issue-19367.rs => match/match-field-reassign.rs} | 0
 .../issue-19086.rs => pattern/struct-variant-as-tuple-variant.rs} | 0
 .../struct-variant-as-tuple-variant.stderr}                       | 0
 .../issue-19811-escape-unicode.rs => str/char-escape-unicode.rs}  | 0
 .../error-reporting/incompatible-method-multiline.rs}             | 0
 .../error-reporting/incompatible-method-multiline.stderr}         | 0
 .../object/inherent-method-on-dyn-with-rc-coercion.rs}            | 0
 13 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/{issues/issue-19037.rs => derives/clone-copy/clone-ref-to-dst.rs} (100%)
 rename tests/ui/{issues/issue-19380.rs => dyn-compatibility/dyn-incompat-const-slice.rs} (100%)
 rename tests/ui/{issues/issue-19380.stderr => dyn-compatibility/dyn-incompat-const-slice.stderr} (100%)
 rename tests/ui/{issues/issue-19982.rs => fn_traits/manual-fn-impl-lifetime-elision.rs} (100%)
 rename tests/ui/{issues/issue-19135.rs => higher-ranked/trait-bounds/hrtb-closure-lifetime-infer.rs} (100%)
 rename tests/ui/{issues/issue-19098.rs => higher-ranked/trait-bounds/hrtb-unused-lifetime.rs} (100%)
 rename tests/ui/{issues/issue-19367.rs => match/match-field-reassign.rs} (100%)
 rename tests/ui/{issues/issue-19086.rs => pattern/struct-variant-as-tuple-variant.rs} (100%)
 rename tests/ui/{issues/issue-19086.stderr => pattern/struct-variant-as-tuple-variant.stderr} (100%)
 rename tests/ui/{issues/issue-19811-escape-unicode.rs => str/char-escape-unicode.rs} (100%)
 rename tests/ui/{issues/issue-21332.rs => traits/error-reporting/incompatible-method-multiline.rs} (100%)
 rename tests/ui/{issues/issue-21332.stderr => traits/error-reporting/incompatible-method-multiline.stderr} (100%)
 rename tests/ui/{issues/issue-19404.rs => traits/object/inherent-method-on-dyn-with-rc-coercion.rs} (100%)

diff --git a/tests/ui/issues/issue-19037.rs b/tests/ui/derives/clone-copy/clone-ref-to-dst.rs
similarity index 100%
rename from tests/ui/issues/issue-19037.rs
rename to tests/ui/derives/clone-copy/clone-ref-to-dst.rs
diff --git a/tests/ui/issues/issue-19380.rs b/tests/ui/dyn-compatibility/dyn-incompat-const-slice.rs
similarity index 100%
rename from tests/ui/issues/issue-19380.rs
rename to tests/ui/dyn-compatibility/dyn-incompat-const-slice.rs
diff --git a/tests/ui/issues/issue-19380.stderr b/tests/ui/dyn-compatibility/dyn-incompat-const-slice.stderr
similarity index 100%
rename from tests/ui/issues/issue-19380.stderr
rename to tests/ui/dyn-compatibility/dyn-incompat-const-slice.stderr
diff --git a/tests/ui/issues/issue-19982.rs b/tests/ui/fn_traits/manual-fn-impl-lifetime-elision.rs
similarity index 100%
rename from tests/ui/issues/issue-19982.rs
rename to tests/ui/fn_traits/manual-fn-impl-lifetime-elision.rs
diff --git a/tests/ui/issues/issue-19135.rs b/tests/ui/higher-ranked/trait-bounds/hrtb-closure-lifetime-infer.rs
similarity index 100%
rename from tests/ui/issues/issue-19135.rs
rename to tests/ui/higher-ranked/trait-bounds/hrtb-closure-lifetime-infer.rs
diff --git a/tests/ui/issues/issue-19098.rs b/tests/ui/higher-ranked/trait-bounds/hrtb-unused-lifetime.rs
similarity index 100%
rename from tests/ui/issues/issue-19098.rs
rename to tests/ui/higher-ranked/trait-bounds/hrtb-unused-lifetime.rs
diff --git a/tests/ui/issues/issue-19367.rs b/tests/ui/match/match-field-reassign.rs
similarity index 100%
rename from tests/ui/issues/issue-19367.rs
rename to tests/ui/match/match-field-reassign.rs
diff --git a/tests/ui/issues/issue-19086.rs b/tests/ui/pattern/struct-variant-as-tuple-variant.rs
similarity index 100%
rename from tests/ui/issues/issue-19086.rs
rename to tests/ui/pattern/struct-variant-as-tuple-variant.rs
diff --git a/tests/ui/issues/issue-19086.stderr b/tests/ui/pattern/struct-variant-as-tuple-variant.stderr
similarity index 100%
rename from tests/ui/issues/issue-19086.stderr
rename to tests/ui/pattern/struct-variant-as-tuple-variant.stderr
diff --git a/tests/ui/issues/issue-19811-escape-unicode.rs b/tests/ui/str/char-escape-unicode.rs
similarity index 100%
rename from tests/ui/issues/issue-19811-escape-unicode.rs
rename to tests/ui/str/char-escape-unicode.rs
diff --git a/tests/ui/issues/issue-21332.rs b/tests/ui/traits/error-reporting/incompatible-method-multiline.rs
similarity index 100%
rename from tests/ui/issues/issue-21332.rs
rename to tests/ui/traits/error-reporting/incompatible-method-multiline.rs
diff --git a/tests/ui/issues/issue-21332.stderr b/tests/ui/traits/error-reporting/incompatible-method-multiline.stderr
similarity index 100%
rename from tests/ui/issues/issue-21332.stderr
rename to tests/ui/traits/error-reporting/incompatible-method-multiline.stderr
diff --git a/tests/ui/issues/issue-19404.rs b/tests/ui/traits/object/inherent-method-on-dyn-with-rc-coercion.rs
similarity index 100%
rename from tests/ui/issues/issue-19404.rs
rename to tests/ui/traits/object/inherent-method-on-dyn-with-rc-coercion.rs

From eff5e8dd0650ff8de33d7aa22909c5f71a25c3e0 Mon Sep 17 00:00:00 2001
From: zedddie <zedddie@protonmail.com>
Date: Sat, 6 Jun 2026 20:31:09 +0200
Subject: [PATCH 14/20] bless batch

---
 tests/ui/derives/clone-copy/clone-ref-to-dst.rs           | 2 ++
 tests/ui/dyn-compatibility/dyn-incompat-const-slice.rs    | 2 ++
 .../ui/dyn-compatibility/dyn-incompat-const-slice.stderr  | 8 ++++----
 tests/ui/fn_traits/manual-fn-impl-lifetime-elision.rs     | 2 ++
 .../trait-bounds/hrtb-closure-lifetime-infer.rs           | 2 ++
 .../ui/higher-ranked/trait-bounds/hrtb-unused-lifetime.rs | 3 +++
 tests/ui/match/match-field-reassign.rs                    | 8 +++++---
 tests/ui/pattern/struct-variant-as-tuple-variant.rs       | 2 ++
 tests/ui/pattern/struct-variant-as-tuple-variant.stderr   | 2 +-
 tests/ui/str/char-escape-unicode.rs                       | 1 +
 .../error-reporting/incompatible-method-multiline.rs      | 3 +++
 .../error-reporting/incompatible-method-multiline.stderr  | 2 +-
 .../object/inherent-method-on-dyn-with-rc-coercion.rs     | 2 ++
 13 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/tests/ui/derives/clone-copy/clone-ref-to-dst.rs b/tests/ui/derives/clone-copy/clone-ref-to-dst.rs
index 7f88a89a65702..3eb8bba709329 100644
--- a/tests/ui/derives/clone-copy/clone-ref-to-dst.rs
+++ b/tests/ui/derives/clone-copy/clone-ref-to-dst.rs
@@ -1,3 +1,5 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/19037>.
+
 //@ check-pass
 #![allow(dead_code)]
 
diff --git a/tests/ui/dyn-compatibility/dyn-incompat-const-slice.rs b/tests/ui/dyn-compatibility/dyn-incompat-const-slice.rs
index fce737cba18d2..d4cb2817d663b 100644
--- a/tests/ui/dyn-compatibility/dyn-incompat-const-slice.rs
+++ b/tests/ui/dyn-compatibility/dyn-incompat-const-slice.rs
@@ -1,3 +1,5 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/19380>.
+
 trait Qiz {
   fn qiz();
 }
diff --git a/tests/ui/dyn-compatibility/dyn-incompat-const-slice.stderr b/tests/ui/dyn-compatibility/dyn-incompat-const-slice.stderr
index 4c41d41ae3792..46ed6a48a77fa 100644
--- a/tests/ui/dyn-compatibility/dyn-incompat-const-slice.stderr
+++ b/tests/ui/dyn-compatibility/dyn-incompat-const-slice.stderr
@@ -1,12 +1,12 @@
 error[E0038]: the trait `Qiz` is not dyn compatible
-  --> $DIR/issue-19380.rs:11:29
+  --> $DIR/dyn-incompat-const-slice.rs:13:29
    |
 LL |   foos: &'static [&'static (dyn Qiz + 'static)]
    |                             ^^^^^^^^^^^^^^^^^ `Qiz` 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-19380.rs:2:6
+  --> $DIR/dyn-incompat-const-slice.rs:4:6
    |
 LL | trait Qiz {
    |       --- this trait is not dyn compatible...
@@ -23,14 +23,14 @@ LL |   fn qiz() where Self: Sized;
    |            +++++++++++++++++
 
 error[E0038]: the trait `Qiz` is not dyn compatible
-  --> $DIR/issue-19380.rs:16:31
+  --> $DIR/dyn-incompat-const-slice.rs:18:31
    |
 LL | const BAR : Bar = Bar { foos: &[&FOO]};
    |                               ^^^^^^^ `Qiz` 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-19380.rs:2:6
+  --> $DIR/dyn-incompat-const-slice.rs:4:6
    |
 LL | trait Qiz {
    |       --- this trait is not dyn compatible...
diff --git a/tests/ui/fn_traits/manual-fn-impl-lifetime-elision.rs b/tests/ui/fn_traits/manual-fn-impl-lifetime-elision.rs
index 4bace6d734ff1..550f917e72891 100644
--- a/tests/ui/fn_traits/manual-fn-impl-lifetime-elision.rs
+++ b/tests/ui/fn_traits/manual-fn-impl-lifetime-elision.rs
@@ -1,3 +1,5 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/19982>.
+
 //@ check-pass
 
 #![feature(fn_traits, unboxed_closures)]
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-closure-lifetime-infer.rs b/tests/ui/higher-ranked/trait-bounds/hrtb-closure-lifetime-infer.rs
index 42288511ab588..d4d81a31d4197 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-closure-lifetime-infer.rs
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-closure-lifetime-infer.rs
@@ -1,3 +1,5 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/19135>.
+
 //@ run-pass
 use std::marker::PhantomData;
 
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-unused-lifetime.rs b/tests/ui/higher-ranked/trait-bounds/hrtb-unused-lifetime.rs
index 97e8ca17de1ec..576d59d401881 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-unused-lifetime.rs
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-unused-lifetime.rs
@@ -1,3 +1,6 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/19098>.
+//! Tests that we don't ICE from unused lifetime in HRTB.
+
 //@ check-pass
 pub trait Handler {
     fn handle(&self, _: &mut String);
diff --git a/tests/ui/match/match-field-reassign.rs b/tests/ui/match/match-field-reassign.rs
index 1cd6c483375ab..c7135ac92fbfd 100644
--- a/tests/ui/match/match-field-reassign.rs
+++ b/tests/ui/match/match-field-reassign.rs
@@ -1,3 +1,8 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/19367>.
+//!
+//! Make sure we don't reuse the same alloca when matching
+//! on field of struct or tuple which we reassign in the match body.
+
 //@ run-pass
 
 #![allow(unused_assignments)]
@@ -6,9 +11,6 @@ struct S {
     o: Option<String>
 }
 
-// Make sure we don't reuse the same alloca when matching
-// on field of struct or tuple which we reassign in the match body.
-
 fn main() {
     let mut a = (0, Some("right".to_string()));
     let b = match a.1 {
diff --git a/tests/ui/pattern/struct-variant-as-tuple-variant.rs b/tests/ui/pattern/struct-variant-as-tuple-variant.rs
index 42148c5f5a18d..944371ae9e952 100644
--- a/tests/ui/pattern/struct-variant-as-tuple-variant.rs
+++ b/tests/ui/pattern/struct-variant-as-tuple-variant.rs
@@ -1,3 +1,5 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/19086>.
+
 use Foo::FooB;
 
 enum Foo {
diff --git a/tests/ui/pattern/struct-variant-as-tuple-variant.stderr b/tests/ui/pattern/struct-variant-as-tuple-variant.stderr
index 03b9249bb1e3d..1cd063e453100 100644
--- a/tests/ui/pattern/struct-variant-as-tuple-variant.stderr
+++ b/tests/ui/pattern/struct-variant-as-tuple-variant.stderr
@@ -1,5 +1,5 @@
 error[E0532]: expected tuple struct or tuple variant, found variant `FooB`
-  --> $DIR/issue-19086.rs:10:9
+  --> $DIR/struct-variant-as-tuple-variant.rs:12:9
    |
 LL |     FooB { x: i32, y: i32 }
    |     ----------------------- `FooB` defined here
diff --git a/tests/ui/str/char-escape-unicode.rs b/tests/ui/str/char-escape-unicode.rs
index 7be77b88494b2..11975e15c1d38 100644
--- a/tests/ui/str/char-escape-unicode.rs
+++ b/tests/ui/str/char-escape-unicode.rs
@@ -1,3 +1,4 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/19811>.
 //@ run-pass
 
 fn main() {
diff --git a/tests/ui/traits/error-reporting/incompatible-method-multiline.rs b/tests/ui/traits/error-reporting/incompatible-method-multiline.rs
index ad764f84aa81a..950ee9d9e0b1c 100644
--- a/tests/ui/traits/error-reporting/incompatible-method-multiline.rs
+++ b/tests/ui/traits/error-reporting/incompatible-method-multiline.rs
@@ -1,3 +1,6 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/21332>.
+//! Ensure multi-line error formatting for "method has incompatible type for trait" diagnostics.
+
 struct S;
 
 impl Iterator for S {
diff --git a/tests/ui/traits/error-reporting/incompatible-method-multiline.stderr b/tests/ui/traits/error-reporting/incompatible-method-multiline.stderr
index 237b3acc9b4df..4f797dedfa846 100644
--- a/tests/ui/traits/error-reporting/incompatible-method-multiline.stderr
+++ b/tests/ui/traits/error-reporting/incompatible-method-multiline.stderr
@@ -1,5 +1,5 @@
 error[E0053]: method `next` has an incompatible type for trait
-  --> $DIR/issue-21332.rs:5:27
+  --> $DIR/incompatible-method-multiline.rs:8:27
    |
 LL |     fn next(&mut self) -> Result<i32, i32> { Ok(7) }
    |                           ^^^^^^^^^^^^^^^^ expected `Option<i32>`, found `Result<i32, i32>`
diff --git a/tests/ui/traits/object/inherent-method-on-dyn-with-rc-coercion.rs b/tests/ui/traits/object/inherent-method-on-dyn-with-rc-coercion.rs
index ff9bb1f2e037e..fc8715e8d513a 100644
--- a/tests/ui/traits/object/inherent-method-on-dyn-with-rc-coercion.rs
+++ b/tests/ui/traits/object/inherent-method-on-dyn-with-rc-coercion.rs
@@ -1,3 +1,5 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/19404>
+
 //@ build-pass
 #![allow(dead_code)]
 #![allow(unused_variables)]

From 8cac9a30a9de5d09bafc48dadbc9f4a2dd4ed7e1 Mon Sep 17 00:00:00 2001
From: Aria Givens <aria@ariagivens.com>
Date: Sat, 6 Jun 2026 17:06:50 -0400
Subject: [PATCH 15/20] Suggest using comma to separate valid attribute list
 items

---
 compiler/rustc_attr_parsing/src/parser.rs     | 33 +++++++++++++++----
 .../src/session_diagnostics.rs                | 13 ++++++++
 .../expected-comma-found-token.rs             |  4 +--
 .../expected-comma-found-token.stderr         |  8 ++---
 4 files changed, 44 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
index 4d714fccc3f61..799b5ccbe4e40 100644
--- a/compiler/rustc_attr_parsing/src/parser.rs
+++ b/compiler/rustc_attr_parsing/src/parser.rs
@@ -30,8 +30,8 @@ use thin_vec::ThinVec;
 
 use crate::ShouldEmit;
 use crate::session_diagnostics::{
-    InvalidMetaItem, InvalidMetaItemQuoteIdentSugg, InvalidMetaItemRemoveNegSugg, MetaBadDelim,
-    MetaBadDelimSugg, SuffixedLiteralInAttribute,
+    ExpectedComma, InvalidMetaItem, InvalidMetaItemQuoteIdentSugg, InvalidMetaItemRemoveNegSugg,
+    MetaBadDelim, MetaBadDelimSugg, SuffixedLiteralInAttribute,
 };
 
 #[derive(Clone, Debug)]
@@ -704,6 +704,29 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
         self.parser.dcx().create_err(err)
     }
 
+    fn should_continue_parsing_meta_items(&mut self) -> Result<bool, Diag<'sess>> {
+        if self.parser.eat(exp!(Comma)) {
+            return Ok(true);
+        } else if self.parser.token == token::Eof {
+            return Ok(false);
+        }
+
+        let mut snapshot = self.parser.create_snapshot_for_diagnostic();
+        if matches!(self.should_emit, ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed }) {
+            let span = self.parser.prev_token.span.shrink_to_hi();
+            self.should_emit = ShouldEmit::Nothing;
+            match self.parse_meta_item_inner() {
+                Ok(_) => {
+                    return Err(self.parser.dcx().create_err(ExpectedComma { span }));
+                }
+                Err(e) => {
+                    e.cancel();
+                }
+            }
+        }
+        snapshot.unexpected_any()
+    }
+
     fn parse(
         tokens: TokenStream,
         psess: &'sess ParseSess,
@@ -724,15 +747,11 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
         while this.parser.token != token::Eof {
             sub_parsers.push(this.parse_meta_item_inner()?);
 
-            if !this.parser.eat(exp!(Comma)) {
+            if !this.should_continue_parsing_meta_items()? {
                 break;
             }
         }
 
-        if parser.token != token::Eof {
-            parser.unexpected()?;
-        }
-
         Ok(MetaItemListParser { sub_parsers, span })
     }
 }
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index b4afdfd7ce409..6dc629583cebe 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -1032,3 +1032,16 @@ pub(crate) struct SanitizeInvalidStatic {
     pub span: Span,
     pub field: &'static str,
 }
+
+#[derive(Diagnostic)]
+#[diag("attribute items not separated with `,`")]
+pub(crate) struct ExpectedComma {
+    #[primary_span]
+    #[suggestion(
+        "try adding `,` here",
+        code = ",",
+        applicability = "maybe-incorrect",
+        style = "short"
+    )]
+    pub span: Span,
+}
diff --git a/tests/ui/on-unimplemented/expected-comma-found-token.rs b/tests/ui/on-unimplemented/expected-comma-found-token.rs
index d60ab3341fd6d..09c293f7eba78 100644
--- a/tests/ui/on-unimplemented/expected-comma-found-token.rs
+++ b/tests/ui/on-unimplemented/expected-comma-found-token.rs
@@ -4,7 +4,7 @@
 #![feature(rustc_attrs)]
 
 #[rustc_on_unimplemented(
-    message="the message"
-    label="the label" //~ ERROR expected `,`, found `label`
+    message="the message" //~ ERROR attribute items not separated with `,`
+    label="the label"
 )]
 trait T {}
diff --git a/tests/ui/on-unimplemented/expected-comma-found-token.stderr b/tests/ui/on-unimplemented/expected-comma-found-token.stderr
index 2717100a1dc64..cdc80a4d9267c 100644
--- a/tests/ui/on-unimplemented/expected-comma-found-token.stderr
+++ b/tests/ui/on-unimplemented/expected-comma-found-token.stderr
@@ -1,10 +1,8 @@
-error: expected `,`, found `label`
-  --> $DIR/expected-comma-found-token.rs:8:5
+error: attribute items not separated with `,`
+  --> $DIR/expected-comma-found-token.rs:7:26
    |
 LL |     message="the message"
-   |                          - expected `,`
-LL |     label="the label"
-   |     ^^^^^ unexpected token
+   |                          ^ help: try adding `,` here
 
 error: aborting due to 1 previous error
 

From a23630fe793bd1629ebe2e424be952ce1782a86e Mon Sep 17 00:00:00 2001
From: majiayu000 <1835304752@qq.com>
Date: Sun, 7 Jun 2026 12:43:47 +0800
Subject: [PATCH 16/20] Document Repeat::count panic behavior

---
 library/core/src/iter/sources/repeat.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/library/core/src/iter/sources/repeat.rs b/library/core/src/iter/sources/repeat.rs
index 197b5f2124235..bdad4adccabac 100644
--- a/library/core/src/iter/sources/repeat.rs
+++ b/library/core/src/iter/sources/repeat.rs
@@ -111,6 +111,11 @@ impl<A: Clone> Iterator for Repeat<A> {
         panic!("iterator is infinite");
     }
 
+    /// Consumes the iterator and panics.
+    ///
+    /// # Panics
+    ///
+    /// This method always panics because `Repeat` is infinite.
     #[track_caller]
     fn count(self) -> usize {
         panic!("iterator is infinite");

From 4e26424d8b00c98fa55034963689df91222e0af5 Mon Sep 17 00:00:00 2001
From: "Mark Z. Ding" <invalidpathexception@gmail.com>
Date: Sun, 7 Jun 2026 01:06:01 -0400
Subject: [PATCH 17/20] chore: Update annotate-snippets to 0.12.16

---
 Cargo.lock                       | 6 +++---
 compiler/rustc_errors/Cargo.toml | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a3f7b3a4367db..7aeb863159ddb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -64,9 +64,9 @@ dependencies = [
 
 [[package]]
 name = "annotate-snippets"
-version = "0.12.15"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92570a3f9c98e7e84df84b71d0965ac99b1871fcd75a3773a3bd1bad13f64cf7"
+checksum = "f211a51805bc641f3ad5b7664c77d2547af685cc33b4cd8d31964027a46f13f1"
 dependencies = [
  "anstyle",
  "memchr",
@@ -3958,7 +3958,7 @@ dependencies = [
 name = "rustc_errors"
 version = "0.0.0"
 dependencies = [
- "annotate-snippets 0.12.15",
+ "annotate-snippets 0.12.16",
  "anstream",
  "anstyle",
  "derive_setters",
diff --git a/compiler/rustc_errors/Cargo.toml b/compiler/rustc_errors/Cargo.toml
index 386467c3e1edb..b0eed7ae2aad9 100644
--- a/compiler/rustc_errors/Cargo.toml
+++ b/compiler/rustc_errors/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-annotate-snippets = { version = "0.12.15", features = ["simd"] }
+annotate-snippets = { version = "0.12.16", features = ["simd"] }
 anstream = "0.6.20"
 anstyle = "1.0.13"
 derive_setters = "0.1.6"

From 0053d7602a87baf5437c013ab61ddc02c411faa6 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Sat, 6 Jun 2026 20:40:09 +0300
Subject: [PATCH 18/20] Cleanup and optimize `render_impls`

- take ownership of the `Vec<&Impl>` instead of copying into another alloc
- reuse `ImplString` to do natural sort ordering
- lazy formatting
---
 src/librustdoc/html/render/mod.rs             | 113 ++++++++----------
 src/librustdoc/html/render/print_item.rs      |  23 ++--
 .../macro/const-rendering-macros-33302.rs     |  20 ++--
 3 files changed, 77 insertions(+), 79 deletions(-)

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index fd6d389542b99..4de2a46007877 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -40,6 +40,7 @@ mod type_layout;
 mod write_shared;
 
 use std::borrow::Cow;
+use std::cmp::Ordering;
 use std::collections::VecDeque;
 use std::fmt::{self, Display as _, Write};
 use std::iter::Peekable;
@@ -79,7 +80,7 @@ use crate::html::format::{
 use crate::html::markdown::{
     HeadingOffset, IdMap, Markdown, MarkdownItemInfo, MarkdownSummaryLine, short_markdown_summary,
 };
-use crate::html::render::print_item::compare_names;
+use crate::html::render::print_item::ImplString;
 use crate::html::render::search_index::get_function_type_for_search;
 use crate::html::static_files::SCRAPE_EXAMPLES_HELP_MD;
 use crate::html::{highlight, sources};
@@ -954,46 +955,50 @@ fn impl_trait_key(cx: &Context<'_>, i: &Impl) -> Option<String> {
 
 // Render the list of items inside one of the sections "Trait Implementations",
 // "Auto Trait Implementations," "Blanket Trait Implementations" (on struct/enum pages).
-fn render_impls(
-    cx: &Context<'_>,
-    mut w: impl Write,
-    impls: &[&Impl],
-    containing_item: &clean::Item,
+fn render_impls<'a, 'cx>(
+    cx: &'a Context<'cx>,
+    mut impls: Vec<&'a Impl>,
+    containing_item: &'a clean::Item,
     toggle_open_by_default: bool,
-) -> fmt::Result {
+) -> impl fmt::Display + use<'a, 'cx> {
+    impls.sort_by_cached_key(|imp| {
+        let prefix = match imp.inner_impl().polarity {
+            ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => Ordering::Greater,
+            ty::ImplPolarity::Negative => Ordering::Less,
+        };
+        (prefix, ImplString::new_path(imp, cx))
+    });
     // Render each impl alongside its `impl_trait_key`, which is used as the primary sorting key
     // to match the impl order in the sidebar.
-    let mut keyed_rendered_impls = impls
-        .iter()
-        .map(|i| {
-            let did = i.trait_did().unwrap();
-            let provided_trait_methods = i.inner_impl().provided_trait_methods(cx.tcx());
-            let assoc_link = AssocItemLink::GotoSource(did.into(), &provided_trait_methods);
-            let imp = render_impl(
-                cx,
-                i,
-                containing_item,
-                assoc_link,
-                RenderMode::Normal,
-                None,
-                &[],
-                ImplRenderingParameters {
-                    show_def_docs: true,
-                    show_default_items: true,
-                    show_non_assoc_items: true,
-                    toggle_open_by_default,
-                },
-            );
-            (impl_trait_key(cx, i).unwrap(), imp.to_string())
-        })
-        .collect::<Vec<_>>();
 
-    // Sort and then remove the `impl_trait_key`s, which are no longer needed after sorting.
-    keyed_rendered_impls
-        .sort_by(|(k1, h1), (k2, h2)| compare_names(k1, k2).then_with(|| h1.cmp(h2)));
-    let joined: String = keyed_rendered_impls.into_iter().map(|a| a.1).collect();
-
-    w.write_str(&joined)
+    fmt::from_fn(move |f| {
+        impls
+            .iter()
+            .map(|i| {
+                fmt::from_fn(|f| {
+                    let did = i.trait_did().unwrap();
+                    let provided_trait_methods = i.inner_impl().provided_trait_methods(cx.tcx());
+                    let assoc_link = AssocItemLink::GotoSource(did.into(), &provided_trait_methods);
+                    render_impl(
+                        cx,
+                        i,
+                        containing_item,
+                        assoc_link,
+                        RenderMode::Normal,
+                        None,
+                        &[],
+                        ImplRenderingParameters {
+                            show_def_docs: true,
+                            show_default_items: true,
+                            show_non_assoc_items: true,
+                            toggle_open_by_default,
+                        },
+                    )
+                    .fmt(f)
+                })
+            })
+            .joined("", f)
+    })
 }
 
 /// Build a (possibly empty) `href` attribute (a key-value pair) for the given associated item.
@@ -1415,16 +1420,12 @@ fn render_all_impls(
     mut w: impl Write,
     cx: &Context<'_>,
     containing_item: &clean::Item,
-    concrete_impls: &[&Impl],
-    auto_trait_impls: &[&Impl],
-    blanket_impls: &[&Impl],
+    concrete_impls: Vec<&Impl>,
+    auto_trait_impls: Vec<&Impl>,
+    blanket_impls: Vec<&Impl>,
 ) -> fmt::Result {
-    let impls = {
-        let mut buf = String::new();
-        render_impls(cx, &mut buf, concrete_impls, containing_item, true)?;
-        buf
-    };
-    if !impls.is_empty() {
+    if !concrete_impls.is_empty() {
+        let impls = render_impls(cx, concrete_impls, containing_item, true);
         write!(
             w,
             "{}<div id=\"trait-implementations-list\">{impls}</div>",
@@ -1433,25 +1434,24 @@ fn render_all_impls(
     }
 
     if !auto_trait_impls.is_empty() {
+        let impls = render_impls(cx, auto_trait_impls, containing_item, false);
         // FIXME: Change the ID to `auto-trait-implementations-list`!
         write!(
             w,
-            "{}<div id=\"synthetic-implementations-list\">",
+            "{}<div id=\"synthetic-implementations-list\">{impls}</div>",
             write_impl_section_heading("Auto Trait Implementations", "synthetic-implementations",)
         )?;
-        render_impls(cx, &mut w, auto_trait_impls, containing_item, false)?;
-        w.write_str("</div>")?;
     }
 
     if !blanket_impls.is_empty() {
+        let impls = render_impls(cx, blanket_impls, containing_item, false);
         write!(
             w,
-            "{}<div id=\"blanket-implementations-list\">",
+            "{}<div id=\"blanket-implementations-list\">{impls}</div>",
             write_impl_section_heading("Blanket Implementations", "blanket-implementations")
         )?;
-        render_impls(cx, &mut w, blanket_impls, containing_item, false)?;
-        w.write_str("</div>")?;
     }
+
     Ok(())
 }
 
@@ -1588,14 +1588,7 @@ fn render_assoc_items_inner(
         let (blanket_impls, concrete_impls): (Vec<&Impl>, _) =
             trait_impls.into_iter().partition(|t| t.inner_impl().kind.is_blanket());
 
-        render_all_impls(
-            w,
-            cx,
-            containing_item,
-            &concrete_impls,
-            &auto_trait_impls,
-            &blanket_impls,
-        )?;
+        render_all_impls(w, cx, containing_item, concrete_impls, auto_trait_impls, blanket_impls)?;
     }
     Ok(())
 }
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index 8385e691ed385..7469b08b4b424 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -32,8 +32,8 @@ use crate::formats::item_type::ItemType;
 use crate::html::escape::{Escape, EscapeBodyTextWithWbr};
 use crate::html::format::{
     Ending, PrintWithSpace, full_print_fn_decl, print_abi_with_space, print_constness_with_space,
-    print_generic_bound, print_generics, print_impl, print_import, print_type, print_where_clause,
-    visibility_print_with_space,
+    print_generic_bound, print_generics, print_impl, print_import, print_path, print_type,
+    print_where_clause, visibility_print_with_space,
 };
 use crate::html::markdown::{HeadingOffset, MarkdownSummaryLine};
 use crate::html::render::sidebar::filters;
@@ -1016,9 +1016,9 @@ fn item_trait(cx: &Context<'_>, it: &clean::Item, t: &clean::Trait) -> impl fmt:
             let (mut synthetic, mut concrete): (Vec<&&Impl>, Vec<&&Impl>) =
                 local.iter().partition(|i| i.inner_impl().kind.is_auto());
 
-            synthetic.sort_by_cached_key(|i| ImplString::new(i, cx));
-            concrete.sort_by_cached_key(|i| ImplString::new(i, cx));
-            foreign.sort_by_cached_key(|i| ImplString::new(i, cx));
+            synthetic.sort_by_cached_key(|i| ImplString::new_impl(i, cx));
+            concrete.sort_by_cached_key(|i| ImplString::new_impl(i, cx));
+            foreign.sort_by_cached_key(|i| ImplString::new_impl(i, cx));
 
             if !foreign.is_empty() {
                 write!(
@@ -1969,7 +1969,7 @@ fn item_primitive(cx: &Context<'_>, it: &clean::Item) -> impl fmt::Display {
             let (concrete, synthetic, blanket_impl) =
                 get_filtered_impls_for_reference(&cx.shared, it);
 
-            render_all_impls(w, cx, it, &concrete, &synthetic, &blanket_impl)
+            render_all_impls(w, cx, it, concrete, synthetic, blanket_impl)
         }
     })
 }
@@ -2346,16 +2346,21 @@ where
 }
 
 #[derive(PartialEq, Eq)]
-struct ImplString {
+pub(super) struct ImplString {
     // Plain text (not HTML text) because this is only used for sorting purposes, and the plain
     // text is much shorter and thus faster to compare.
     cmp_text: String,
 }
 
 impl ImplString {
-    fn new(i: &Impl, cx: &Context<'_>) -> ImplString {
+    fn new_impl(i: &Impl, cx: &Context<'_>) -> Self {
         let impl_ = i.inner_impl();
-        ImplString { cmp_text: format!("{:#}", print_impl(impl_, false, cx)) }
+        Self { cmp_text: format!("{:#}", print_impl(impl_, false, cx)) }
+    }
+
+    pub(super) fn new_path(i: &Impl, cx: &Context<'_>) -> Option<Self> {
+        let path = i.inner_impl().trait_.as_ref()?;
+        Some(Self { cmp_text: format!("{:#}", print_path(path, cx)) })
     }
 }
 
diff --git a/tests/rustdoc-html/macro/const-rendering-macros-33302.rs b/tests/rustdoc-html/macro/const-rendering-macros-33302.rs
index 9fd45df08be34..26b7d3d008481 100644
--- a/tests/rustdoc-html/macro/const-rendering-macros-33302.rs
+++ b/tests/rustdoc-html/macro/const-rendering-macros-33302.rs
@@ -1,5 +1,5 @@
 // https://github.com/rust-lang/rust/issues/33302
-#![crate_name="issue_33302"]
+#![crate_name = "issue_33302"]
 
 // Ensure constant and array length values are not taken from source
 // code, which wreaks havoc with macros.
@@ -25,11 +25,12 @@ macro_rules! make {
         }
 
         //@ has issue_33302/struct.S.html \
-        //        '//*[@class="impl"]' 'impl T<[i32; 16]> for S'
-        //@ has - '//*[@id="associatedconstant.C"]' 'const C: [i32; 16]'
+        //        '//*[@class="impl"]' 'impl T<(i32, i32)> for S'
+        //@ has - '//*[@id="associatedconstant.C"]' 'const C: (i32, i32)'
         //@ has - '//*[@id="associatedconstant.D"]' 'const D: i32'
-        impl T<[i32; ($n * $n)]> for S {
-            const C: [i32; ($n * $n)] = [0; ($n * $n)];
+        impl T<(i32, i32)> for S {
+            const C: (i32, i32) = ($n, $n);
+            const D: i32 = ($n / $n);
         }
 
         //@ has issue_33302/struct.S.html \
@@ -41,12 +42,11 @@ macro_rules! make {
         }
 
         //@ has issue_33302/struct.S.html \
-        //        '//*[@class="impl"]' 'impl T<(i32, i32)> for S'
-        //@ has - '//*[@id="associatedconstant.C-2"]' 'const C: (i32, i32)'
+        //        '//*[@class="impl"]' 'impl T<[i32; 16]> for S'
+        //@ has - '//*[@id="associatedconstant.C-2"]' 'const C: [i32; 16]'
         //@ has - '//*[@id="associatedconstant.D-2"]' 'const D: i32'
-        impl T<(i32, i32)> for S {
-            const C: (i32, i32) = ($n, $n);
-            const D: i32 = ($n / $n);
+        impl T<[i32; ($n * $n)]> for S {
+            const C: [i32; ($n * $n)] = [0; ($n * $n)];
         }
     };
 }

From 5ec82ecf0162010f90d257ce23af2762a41abc8c Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 3 Jun 2026 15:01:07 +0000
Subject: [PATCH 19/20] Use WorkProductMap instead of FxIndexMap

This is an UnordMap internally. Iteration order for the work product map
should not matter aside from the place it is serialized where sorting by
WorkProductId is sufficient.
---
 compiler/rustc_codegen_cranelift/src/lib.rs       |  6 +++---
 compiler/rustc_codegen_gcc/src/lib.rs             |  5 ++---
 compiler/rustc_codegen_llvm/src/lib.rs            |  5 ++---
 compiler/rustc_codegen_ssa/src/back/write.rs      | 13 ++++---------
 compiler/rustc_codegen_ssa/src/traits/backend.rs  |  5 ++---
 compiler/rustc_incremental/src/persist/save.rs    | 15 ++++++---------
 compiler/rustc_interface/src/queries.rs           |  5 ++---
 compiler/rustc_interface/src/util.rs              |  7 +++----
 .../codegen-backend/auxiliary/the_backend.rs      | 15 ++++-----------
 9 files changed, 28 insertions(+), 48 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs
index 38cb986034859..af783f31a2136 100644
--- a/compiler/rustc_codegen_cranelift/src/lib.rs
+++ b/compiler/rustc_codegen_cranelift/src/lib.rs
@@ -40,7 +40,7 @@ use cranelift_codegen::settings::{self, Configurable};
 use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_codegen_ssa::{CompiledModules, CrateInfo, TargetConfig, back};
 use rustc_log::tracing::info;
-use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
+use rustc_middle::dep_graph::WorkProductMap;
 use rustc_session::Session;
 use rustc_session::config::OutputFilenames;
 use rustc_span::{Symbol, sym};
@@ -88,7 +88,7 @@ mod prelude {
     };
     pub(crate) use cranelift_module::{self, DataDescription, FuncId, Linkage, Module};
     pub(crate) use rustc_abi::{BackendRepr, FIRST_VARIANT, FieldIdx, Scalar, Size, VariantIdx};
-    pub(crate) use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
+    pub(crate) use rustc_data_structures::fx::FxHashMap;
     pub(crate) use rustc_hir::def_id::{DefId, LOCAL_CRATE};
     pub(crate) use rustc_index::Idx;
     pub(crate) use rustc_middle::mir::{self, *};
@@ -235,7 +235,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
         sess: &Session,
         _outputs: &OutputFilenames,
         crate_info: &CrateInfo,
-    ) -> (CompiledModules, FxIndexMap<WorkProductId, WorkProduct>) {
+    ) -> (CompiledModules, WorkProductMap) {
         ongoing_codegen
             .downcast::<rustc_codegen_ssa::back::write::OngoingCodegen<driver::aot::AotDriver>>()
             .unwrap()
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 9669f40166287..850b67c7b25af 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -89,11 +89,10 @@ use rustc_codegen_ssa::base::codegen_crate;
 use rustc_codegen_ssa::target_features::cfg_target_feature;
 use rustc_codegen_ssa::traits::{CodegenBackend, ExtraBackendMethods, WriteBackendMethods};
 use rustc_codegen_ssa::{CompiledModule, CompiledModules, CrateInfo, ModuleCodegen, TargetConfig};
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::sync::IntoDynSyncSend;
 use rustc_errors::{DiagCtxt, DiagCtxtHandle};
-use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
+use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::util::Providers;
 use rustc_session::Session;
@@ -301,7 +300,7 @@ impl CodegenBackend for GccCodegenBackend {
         sess: &Session,
         _outputs: &OutputFilenames,
         crate_info: &CrateInfo,
-    ) -> (CompiledModules, FxIndexMap<WorkProductId, WorkProduct>) {
+    ) -> (CompiledModules, WorkProductMap) {
         ongoing_codegen
             .downcast::<rustc_codegen_ssa::back::write::OngoingCodegen<GccCodegenBackend>>()
             .expect("Expected GccCodegenBackend's OngoingCodegen, found Box<Any>")
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 7c05ecbab6d1c..c0593bb467796 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -32,11 +32,10 @@ use rustc_codegen_ssa::back::write::{
 };
 use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::{CompiledModule, CompiledModules, CrateInfo, ModuleCodegen, TargetConfig};
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_errors::{DiagCtxt, DiagCtxtHandle};
 use rustc_metadata::EncodedMetadata;
-use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
+use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::util::Providers;
 use rustc_session::Session;
@@ -358,7 +357,7 @@ impl CodegenBackend for LlvmCodegenBackend {
         sess: &Session,
         outputs: &OutputFilenames,
         crate_info: &CrateInfo,
-    ) -> (CompiledModules, FxIndexMap<WorkProductId, WorkProduct>) {
+    ) -> (CompiledModules, WorkProductMap) {
         let (compiled_modules, work_products) = ongoing_codegen
             .downcast::<rustc_codegen_ssa::back::write::OngoingCodegen<LlvmCodegenBackend>>()
             .expect("Expected LlvmCodegenBackend's OngoingCodegen, found Box<Any>")
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 1b7817cb17bfe..2262db392f54e 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -6,7 +6,6 @@ use std::sync::mpsc::{Receiver, Sender, channel};
 use std::{assert_matches, fs, io, mem, str, thread};
 
 use rustc_abi::Size;
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::jobserver::{self, Acquired};
 use rustc_data_structures::profiling::{SelfProfilerRef, VerboseTimingGuard};
 use rustc_errors::emitter::Emitter;
@@ -22,7 +21,7 @@ use rustc_incremental::{
 use rustc_macros::{Decodable, Encodable};
 use rustc_metadata::fs::copy_to_stdout;
 use rustc_middle::bug;
-use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
+use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::config::{
@@ -460,8 +459,8 @@ pub(crate) fn start_async_codegen<B: WriteBackendMethods>(
 fn copy_all_cgu_workproducts_to_incr_comp_cache_dir(
     sess: &Session,
     compiled_modules: &CompiledModules,
-) -> FxIndexMap<WorkProductId, WorkProduct> {
-    let mut work_products = FxIndexMap::default();
+) -> WorkProductMap {
+    let mut work_products = WorkProductMap::default();
 
     if sess.opts.incremental.is_none() || sess.opts.unstable_opts.disable_incr_comp_backend_caching
     {
@@ -2099,11 +2098,7 @@ pub struct OngoingCodegen<B: WriteBackendMethods> {
 }
 
 impl<B: WriteBackendMethods> OngoingCodegen<B> {
-    pub fn join(
-        self,
-        sess: &Session,
-        crate_info: &CrateInfo,
-    ) -> (CompiledModules, FxIndexMap<WorkProductId, WorkProduct>) {
+    pub fn join(self, sess: &Session, crate_info: &CrateInfo) -> (CompiledModules, WorkProductMap) {
         self.shared_emitter_main.check(sess, true);
 
         let maybe_lto_modules = sess.time("join_worker_thread", || match self.coordinator.join() {
diff --git a/compiler/rustc_codegen_ssa/src/traits/backend.rs b/compiler/rustc_codegen_ssa/src/traits/backend.rs
index 6bee9f7cadee7..6014f1af4bfc3 100644
--- a/compiler/rustc_codegen_ssa/src/traits/backend.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/backend.rs
@@ -2,11 +2,10 @@ use std::any::Any;
 use std::hash::Hash;
 
 use rustc_ast::expand::allocator::AllocatorMethod;
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_metadata::EncodedMetadata;
 use rustc_metadata::creader::MetadataLoaderDyn;
-use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
+use rustc_middle::dep_graph::WorkProductMap;
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::util::Providers;
 use rustc_session::Session;
@@ -130,7 +129,7 @@ pub trait CodegenBackend {
         sess: &Session,
         outputs: &OutputFilenames,
         crate_info: &CrateInfo,
-    ) -> (CompiledModules, FxIndexMap<WorkProductId, WorkProduct>);
+    ) -> (CompiledModules, WorkProductMap);
 
     fn print_pass_timings(&self) {}
 
diff --git a/compiler/rustc_incremental/src/persist/save.rs b/compiler/rustc_incremental/src/persist/save.rs
index ab695dddf06e6..69705f28aa114 100644
--- a/compiler/rustc_incremental/src/persist/save.rs
+++ b/compiler/rustc_incremental/src/persist/save.rs
@@ -1,8 +1,7 @@
 use std::fs;
 
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sync::par_join;
-use rustc_middle::dep_graph::{DepGraph, WorkProduct, WorkProductId};
+use rustc_middle::dep_graph::{DepGraph, WorkProductMap};
 use rustc_middle::query::on_disk_cache;
 use rustc_middle::ty::TyCtxt;
 use rustc_serialize::Encodable as RustcEncodable;
@@ -93,7 +92,7 @@ pub(crate) fn save_dep_graph(tcx: TyCtxt<'_>) {
 pub fn save_work_product_index(
     sess: &Session,
     dep_graph: &DepGraph,
-    new_work_products: FxIndexMap<WorkProductId, WorkProduct>,
+    new_work_products: WorkProductMap,
 ) {
     if sess.opts.incremental.is_none() {
         return;
@@ -126,18 +125,16 @@ pub fn save_work_product_index(
 
     // Check that we did not delete one of the current work-products:
     debug_assert!({
-        new_work_products.iter().all(|(_, wp)| {
+        new_work_products.items().all(|(_, wp)| {
             wp.saved_files.items().all(|(_, path)| in_incr_comp_dir_sess(sess, path).exists())
         })
     });
 }
 
-fn encode_work_product_index(
-    work_products: &FxIndexMap<WorkProductId, WorkProduct>,
-    encoder: &mut FileEncoder,
-) {
+fn encode_work_product_index(work_products: &WorkProductMap, encoder: &mut FileEncoder) {
     let serialized_products: Vec<_> = work_products
-        .iter()
+        .to_sorted_stable_ord()
+        .into_iter()
         .map(|(id, work_product)| SerializedWorkProduct {
             id: *id,
             work_product: work_product.clone(),
diff --git a/compiler/rustc_interface/src/queries.rs b/compiler/rustc_interface/src/queries.rs
index 20ac6e258ed16..7a106e1089e2c 100644
--- a/compiler/rustc_interface/src/queries.rs
+++ b/compiler/rustc_interface/src/queries.rs
@@ -3,12 +3,11 @@ use std::sync::Arc;
 
 use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_codegen_ssa::{CompiledModules, CrateInfo};
-use rustc_data_structures::indexmap::IndexMap;
 use rustc_data_structures::svh::Svh;
 use rustc_errors::timings::TimingSection;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_metadata::EncodedMetadata;
-use rustc_middle::dep_graph::DepGraph;
+use rustc_middle::dep_graph::{DepGraph, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::config::{self, OutputFilenames, OutputType};
@@ -51,7 +50,7 @@ impl Linker {
         let (compiled_modules, mut work_products) = sess.time("finish_ongoing_codegen", || {
             match self.ongoing_codegen.downcast::<CompiledModules>() {
                 // This was a check only build
-                Ok(compiled_modules) => (*compiled_modules, IndexMap::default()),
+                Ok(compiled_modules) => (*compiled_modules, WorkProductMap::default()),
 
                 Err(ongoing_codegen) => codegen_backend.join_codegen(
                     ongoing_codegen,
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index d7d306918fd0d..4cb4876284706 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -14,11 +14,10 @@ use rustc_codegen_ssa::target_features::cfg_target_feature;
 use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_codegen_ssa::{CompiledModules, CrateInfo, TargetConfig};
 use rustc_data_structures::base_n::{CASE_INSENSITIVE, ToBaseN};
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::jobserver::Proxy;
 use rustc_data_structures::sync;
 use rustc_metadata::{DylibError, EncodedMetadata, load_symbol_from_dylib};
-use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
+use rustc_middle::dep_graph::WorkProductMap;
 use rustc_middle::ty::{CurrentGcx, TyCtxt};
 use rustc_query_impl::{CollectActiveJobsKind, collect_active_query_jobs};
 use rustc_session::config::{
@@ -418,8 +417,8 @@ impl CodegenBackend for DummyCodegenBackend {
         _sess: &Session,
         _outputs: &OutputFilenames,
         _crate_info: &CrateInfo,
-    ) -> (CompiledModules, FxIndexMap<WorkProductId, WorkProduct>) {
-        (*ongoing_codegen.downcast().unwrap(), FxIndexMap::default())
+    ) -> (CompiledModules, WorkProductMap) {
+        (*ongoing_codegen.downcast().unwrap(), WorkProductMap::default())
     }
 
     fn link(
diff --git a/tests/ui-fulldeps/codegen-backend/auxiliary/the_backend.rs b/tests/ui-fulldeps/codegen-backend/auxiliary/the_backend.rs
index 8a7cacf20e2e4..4b5f031241931 100644
--- a/tests/ui-fulldeps/codegen-backend/auxiliary/the_backend.rs
+++ b/tests/ui-fulldeps/codegen-backend/auxiliary/the_backend.rs
@@ -4,24 +4,17 @@
 #![deny(warnings)]
 
 extern crate rustc_codegen_ssa;
-extern crate rustc_data_structures;
-extern crate rustc_driver;
-extern crate rustc_errors;
-extern crate rustc_hir;
+extern crate rustc_driver as _;
 extern crate rustc_metadata;
 extern crate rustc_middle;
 extern crate rustc_session;
-extern crate rustc_span;
-extern crate rustc_symbol_mangling;
-extern crate rustc_target;
 
 use std::any::Any;
 
 use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_codegen_ssa::{CompiledModules, CrateInfo};
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_metadata::EncodedMetadata;
-use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
+use rustc_middle::dep_graph::{WorkProduct, WorkProductId, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::config::OutputFilenames;
@@ -47,11 +40,11 @@ impl CodegenBackend for TheBackend {
         _sess: &Session,
         _outputs: &OutputFilenames,
         _crate_info: &CrateInfo,
-    ) -> (CompiledModules, FxIndexMap<WorkProductId, WorkProduct>) {
+    ) -> (CompiledModules, WorkProductMap) {
         let codegen_results = ongoing_codegen
             .downcast::<CompiledModules>()
             .expect("in join_codegen: ongoing_codegen is not a CompiledModules");
-        (*codegen_results, FxIndexMap::default())
+        (*codegen_results, WorkProductMap::default())
     }
 
     fn link(

From 19d28a97c875a8a9212b0817801c2a52da29794a Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 4 Jun 2026 10:39:13 +0000
Subject: [PATCH 20/20] Assert incr comp in
 copy_cgu_workproduct_to_incr_comp_cache_dir

It was already only called when incr comp is enabled and this allows
cleaning up the callers a bit.
---
 compiler/rustc_codegen_ssa/src/back/write.rs        |  7 +++----
 .../rustc_incremental/src/persist/work_product.rs   |  8 +++++---
 compiler/rustc_interface/src/queries.rs             | 13 ++++++-------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 2262db392f54e..112cf45ebbf2e 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -489,14 +489,13 @@ fn copy_all_cgu_workproducts_to_incr_comp_cache_dir(
         if let Some(path) = &module.bytecode {
             files.push((OutputType::Bitcode.extension(), path.as_path()));
         }
-        if let Some((id, product)) = copy_cgu_workproduct_to_incr_comp_cache_dir(
+        let (id, product) = copy_cgu_workproduct_to_incr_comp_cache_dir(
             sess,
             &module.name,
             files.as_slice(),
             &module.links_from_incr_cache,
-        ) {
-            work_products.insert(id, product);
-        }
+        );
+        work_products.insert(id, product);
     }
 
     work_products
diff --git a/compiler/rustc_incremental/src/persist/work_product.rs b/compiler/rustc_incremental/src/persist/work_product.rs
index 7b1eb0a82e397..64dae5c0869b9 100644
--- a/compiler/rustc_incremental/src/persist/work_product.rs
+++ b/compiler/rustc_incremental/src/persist/work_product.rs
@@ -16,14 +16,16 @@ use crate::persist::fs::*;
 
 /// Copies a CGU work product to the incremental compilation directory, so next compilation can
 /// find and reuse it.
+///
+/// Panics when incr comp is disabled.
 pub fn copy_cgu_workproduct_to_incr_comp_cache_dir(
     sess: &Session,
     cgu_name: &str,
     files: &[(&'static str, &Path)],
     known_links: &[PathBuf],
-) -> Option<(WorkProductId, WorkProduct)> {
+) -> (WorkProductId, WorkProduct) {
     debug!(?cgu_name, ?files);
-    sess.opts.incremental.as_ref()?;
+    assert!(sess.opts.incremental.is_some());
 
     let mut saved_files = UnordMap::default();
     for (ext, path) in files {
@@ -50,7 +52,7 @@ pub fn copy_cgu_workproduct_to_incr_comp_cache_dir(
     let work_product = WorkProduct { cgu_name: cgu_name.to_string(), saved_files };
     debug!(?work_product);
     let work_product_id = WorkProductId::from_cgu_name(cgu_name);
-    Some((work_product_id, work_product))
+    (work_product_id, work_product)
 }
 
 /// Removes files for a given work product.
diff --git a/compiler/rustc_interface/src/queries.rs b/compiler/rustc_interface/src/queries.rs
index 7a106e1089e2c..6026cfd5f71fe 100644
--- a/compiler/rustc_interface/src/queries.rs
+++ b/compiler/rustc_interface/src/queries.rs
@@ -89,14 +89,13 @@ impl Linker {
 
         if sess.opts.incremental.is_some()
             && let Some(path) = self.metadata.path()
-            && let Some((id, product)) =
-                rustc_incremental::copy_cgu_workproduct_to_incr_comp_cache_dir(
-                    sess,
-                    "metadata",
-                    &[("rmeta", path)],
-                    &[],
-                )
         {
+            let (id, product) = rustc_incremental::copy_cgu_workproduct_to_incr_comp_cache_dir(
+                sess,
+                "metadata",
+                &[("rmeta", path)],
+                &[],
+            );
             work_products.insert(id, product);
         }