From 012c35624ed80e409f2bbb301e2824d547f01ef1 Mon Sep 17 00:00:00 2001
From: Makro <mnlkroiss@gmail.com>
Date: Wed, 29 Jul 2026 09:00:38 +0000
Subject: [PATCH 01/13] Select cache values to verify by key fingerprint, not
 value fingerprint

---
 compiler/rustc_middle/src/dep_graph/graph.rs |  9 +++++++
 compiler/rustc_query_impl/src/execution.rs   | 26 +++++++++++++-------
 compiler/rustc_query_impl/src/plumbing.rs    |  3 +--
 3 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_middle/src/dep_graph/graph.rs b/compiler/rustc_middle/src/dep_graph/graph.rs
index 7892404badef3..b59fc263eec9a 100644
--- a/compiler/rustc_middle/src/dep_graph/graph.rs
+++ b/compiler/rustc_middle/src/dep_graph/graph.rs
@@ -705,6 +705,15 @@ impl DepGraphData {
         self.previous.value_fingerprint_for_index(prev_index)
     }
 
+    /// The number of incremental sessions in this graph's lineage, from
+    /// [`SerializedDepGraph::session_count`]. Advances by one per successful
+    /// session; a failed session does not commit a graph, so a re-run sees
+    /// the same count.
+    #[inline]
+    pub fn session_count(&self) -> u64 {
+        self.previous.session_count()
+    }
+
     #[inline]
     pub(crate) fn prev_node_of(&self, prev_index: SerializedDepNodeIndex) -> &DepNode {
         self.previous.index_to_node(prev_index)
diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs
index a9192d0417712..a1d68fc0dc7ab 100644
--- a/compiler/rustc_query_impl/src/execution.rs
+++ b/compiler/rustc_query_impl/src/execution.rs
@@ -1,7 +1,7 @@
 use std::hash::Hash;
 use std::mem::ManuallyDrop;
 
-use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::fingerprint::{Fingerprint, PackedFingerprint};
 use rustc_data_structures::hash_table::{Entry, HashTable};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_data_structures::sync::{DynSend, DynSync};
@@ -490,12 +490,21 @@ fn execute_job_incr<'tcx, C: QueryCache>(
 /// specified, re-hash results from the cache and make sure that they have the
 /// expected fingerprint.
 ///
-/// If not, we still seek to verify a subset of fingerprints loaded from disk.
-/// Re-hashing results is fairly expensive, so we can't currently afford to
-/// verify every hash. This subset should still give us some coverage of
-/// potential bugs.
-pub(crate) fn should_verify_loaded_value(tcx: TyCtxt<'_>, prev_fingerprint: Fingerprint) -> bool {
-    prev_fingerprint.split().1.as_u64().is_multiple_of(32)
+/// If not, we still verify a subset: re-hashing is too expensive to do for
+/// every value. The subset rotates with the session count, covering the whole
+/// cache every 32 sessions, and is deterministic so that a verification
+/// failure reproduces on retry.
+///
+/// `to_smaller_hash` mixes both fingerprint halves because neither half is
+/// evenly distributed on its own (`DefPathHash` keys share the
+/// `StableCrateId`, `HirId` keys contain a sequential id).
+pub(crate) fn should_verify_loaded_value(
+    tcx: TyCtxt<'_>,
+    dep_graph_data: &DepGraphData,
+    key_fingerprint: PackedFingerprint,
+) -> bool {
+    let hash = Fingerprint::from(key_fingerprint).to_smaller_hash().as_u64();
+    hash % 32 == dep_graph_data.session_count() % 32
         || tcx.sess.opts.unstable_opts.incremental_verify_ich
 }
 
@@ -532,8 +541,7 @@ fn load_from_disk_or_invoke_provider_green<'tcx, C: QueryCache>(
                 dep_graph_data.mark_debug_loaded_from_disk(*dep_node)
             }
 
-            let prev_fingerprint = dep_graph_data.prev_value_fingerprint_of(prev_index);
-            let verify = should_verify_loaded_value(tcx, prev_fingerprint);
+            let verify = should_verify_loaded_value(tcx, dep_graph_data, dep_node.key_fingerprint);
 
             (value, verify)
         }
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index c53293447040b..83badcb269af6 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -179,8 +179,7 @@ pub(crate) fn promote_from_disk_inner<'tcx, C: QueryCache>(
 
     // Verify the fingerprints of the same subset of loaded values as
     // `load_from_disk_or_invoke_provider_green` does.
-    let prev_fingerprint = dep_graph_data.prev_value_fingerprint_of(prev_index);
-    if should_verify_loaded_value(tcx, prev_fingerprint) {
+    if should_verify_loaded_value(tcx, dep_graph_data, dep_node.key_fingerprint) {
         incremental_verify_ich(
             tcx,
             dep_graph_data,

From 833ec34ae8f7b582ea4f9202fd19b01943f89cbe Mon Sep 17 00:00:00 2001
From: jyn <github@jyn.dev>
Date: Thu, 18 Jun 2026 10:36:08 +0200
Subject: [PATCH 02/13] [blocked] Link to proposed LLM policy in CONTRIBUTING
 and pull request template

---
 .github/pull_request_template.md | 11 +++++++++++
 CONTRIBUTING.md                  |  9 +++++++++
 2 files changed, 20 insertions(+)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 93388ddd24075..872c8a0ade1ab 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,5 +1,16 @@
 <!-- homu-ignore:start -->
+
+- [ ] I did not use an LLM to create a change in this PR.
+- [ ] I used an LLM to create a change in this PR, and I have explained below how it was used.
+
 <!--
+Please read our [LLM policy] before opening a PR,
+and check one of the boxes above to indicate whether you've used an LLM.
+If you do not check a box, a reviewer may ask you whether an LLM was involved.
+LLM contributions are not banned, but are held to a higher standard of review and correctness.
+
+[LLM policy]: https://forge.rust-lang.org/policies/llm-usage.html
+
 If this PR is related to an unstable feature or an otherwise tracked effort,
 please link to the relevant tracking issue here. If you don't know of a related
 tracking issue or there are none, feel free to ignore this.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3f052eca48e61..08b0cdc34ff3a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -29,6 +29,15 @@ that you read and understand the [rustc-dev-guide] before making a contribution.
 talks about the different bots in the Rust ecosystem, the Rust development tools,
 bootstrapping, the compiler architecture, source code representation, and more.
 
+## LLM policy
+
+We have a policy for how LLMs are allowed to be used in contributions to `rust-lang/rust`.
+You can read it [on Forge][LLM policy].
+For suggestions about how to use LLMs *well*, and how to review LLM-created PRs, see [the dev-guide][llm-guidance].
+
+[LLM policy]: https://forge.rust-lang.org/policies/llm-usage.html
+[llm-guidance]: https://rustc-dev-guide.rust-lang.org/llm-guidance.html
+
 ## [Getting help](https://rustc-dev-guide.rust-lang.org/getting-started.html#asking-questions)
 
 There are many ways you can get help when you're stuck. Rust has two platforms for this:

From ac1e5f4e58041b9656bb4b129cb9cb665d8dcec4 Mon Sep 17 00:00:00 2001
From: Joao Roberto <dnreikronos2@gmail.com>
Date: Sun, 2 Aug 2026 13:19:20 -0300
Subject: [PATCH 03/13] Handle slice-tailed DSTs in autodiff type trees

Use codegen tail discovery so wrappers such as OsStr keep slice element
metadata without losing offsets for prefixed DSTs. Keep recursion tracking
scoped to the current traversal path.
---
 .../src/builder/autodiff.rs                   |  11 +-
 compiler/rustc_middle/src/ty/typetree.rs      | 112 ++++++++++--------
 .../type-trees/slice-dst-typetree/rmake.rs    |  18 +++
 .../slice-dst-typetree/slice-dst.check        |   9 ++
 .../type-trees/slice-dst-typetree/test.rs     |  38 ++++++
 5 files changed, 131 insertions(+), 57 deletions(-)
 create mode 100644 tests/run-make/autodiff/type-trees/slice-dst-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/slice-dst-typetree/slice-dst.check
 create mode 100644 tests/run-make/autodiff/type-trees/slice-dst-typetree/test.rs

diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index b0ac5c096efdf..8cefd8dc489a9 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -45,18 +45,13 @@ pub(crate) fn adjust_activity_to_abi<'tcx>(
     let mut del_activities = 0;
     for (i, ty) in sig.inputs().iter().enumerate() {
         if let Some(inner_ty) = ty.builtin_deref(true) {
-            if inner_ty.is_slice() {
+            let tail_ty = tcx.struct_tail_for_codegen(inner_ty, typing_env);
+            if let ty::Slice(element_ty) = tail_ty.kind() {
                 // Now we need to figure out the size of each slice element in memory to allow
                 // safety checks and usability improvements in the backend.
-                let sty = match inner_ty.builtin_index() {
-                    Some(sty) => sty,
-                    None => {
-                        panic!("slice element type unknown");
-                    }
-                };
                 let pci = PseudoCanonicalInput {
                     typing_env: TypingEnv::fully_monomorphized(),
-                    value: sty,
+                    value: *element_ty,
                 };
 
                 let layout = tcx.layout_of(pci);
diff --git a/compiler/rustc_middle/src/ty/typetree.rs b/compiler/rustc_middle/src/ty/typetree.rs
index d4cda033a7e87..90fb0316fe39b 100644
--- a/compiler/rustc_middle/src/ty/typetree.rs
+++ b/compiler/rustc_middle/src/ty/typetree.rs
@@ -62,20 +62,26 @@ fn handle_indirection<'a>(
     let Some(inner_ty) = ty.builtin_deref(true) else {
         bug!("incorrect autodiff typetree handling for type: {}", ty);
     };
-    // slices are represented as `&'{erased} mut [f32]`
-    // This reads as a reference to a slice of f32.
-    // So we'd end up with ptr->RustSlice->f32 without this extra handling
-    if inner_ty.is_slice() {
-        if let ty::Slice(element_ty) = inner_ty.kind() {
-            let element_tree =
-                typetree_from_ty_impl_inner(tcx, *element_ty, depth + 1, visited, false);
-            return TypeTree(vec![Type {
-                offset: -1,
-                size: tcx.data_layout.pointer_size().bytes_usize(),
-                kind: Kind::RustSlice,
-                child: element_tree,
-            }]);
-        }
+    // A pointer to a slice-tailed DST is a fat pointer `{data, len}`. `RustSlice` describes both
+    // LLVM arguments, while its child describes the memory reached through `data`.
+    let typing_env = ty::TypingEnv::fully_monomorphized();
+    if let ty::Slice(element_ty) = tcx.struct_tail_for_codegen(inner_ty, typing_env).kind() {
+        let child = if tcx
+            .layout_of(typing_env.as_query_input(inner_ty))
+            .is_ok_and(|layout| layout.size.bytes() == 0)
+        {
+            // Direct slices and transparent wrappers such as `OsStr` contain elements everywhere.
+            typetree_from_ty_impl_inner(tcx, *element_ty, depth + 1, visited, false)
+        } else {
+            // Preserve field offsets for a sized prefix before the slice tail.
+            typetree_from_ty_impl_inner(tcx, inner_ty, depth + 1, visited, true)
+        };
+        return TypeTree(vec![Type {
+            offset: -1,
+            size: tcx.data_layout.pointer_size().bytes_usize(),
+            kind: Kind::RustSlice,
+            child,
+        }]);
     }
 
     let child = typetree_from_ty_impl_inner(tcx, inner_ty, depth + 1, visited, true);
@@ -105,56 +111,60 @@ fn typetree_from_ty_impl_inner<'tcx>(
     }
     visited.push(ty);
 
-    match ty.kind() {
-        // See handle_indirection for an explanation on why we don't handle it here.
-        ty::Slice(..) => bug!("incorrect autodiff typetree handling for slice: {}", ty),
+    let tree = match ty.kind() {
+        // Direct slices are handled by `handle_indirection`. This arm describes a slice tail while
+        // recursing through a prefixed DST, so its caller can add the field offset.
+        ty::Slice(element_ty) => {
+            typetree_from_ty_impl_inner(tcx, *element_ty, depth + 1, visited, false)
+        }
         ty::Ref(..) | ty::RawPtr(..) => handle_indirection(ty, tcx, depth, visited),
         ty::Adt(def, _) if def.is_box() => handle_indirection(ty, tcx, depth, visited),
         ty::Array(element_ty, len_const) => {
             let len = len_const.try_to_target_usize(tcx).unwrap_or(0);
             if len == 0 {
-                return TypeTree::new();
-            }
-            let element_tree =
-                typetree_from_ty_impl_inner(tcx, *element_ty, depth + 1, visited, false);
-            let mut types = Vec::new();
-            for elem_type in &element_tree.0 {
-                types.push(Type::from_ty(-1, elem_type));
-            }
+                TypeTree::new()
+            } else {
+                let element_tree =
+                    typetree_from_ty_impl_inner(tcx, *element_ty, depth + 1, visited, false);
+                let mut types = Vec::new();
+                for elem_type in &element_tree.0 {
+                    types.push(Type::from_ty(-1, elem_type));
+                }
 
-            TypeTree(types)
+                TypeTree(types)
+            }
         }
         ty::Tuple(tuple_types) => {
             if tuple_types.is_empty() {
-                return TypeTree::new();
-            }
+                TypeTree::new()
+            } else {
+                let mut types = Vec::new();
+                let mut current_offset = 0;
 
-            let mut types = Vec::new();
-            let mut current_offset = 0;
+                for tuple_ty in tuple_types.iter() {
+                    let element_tree =
+                        typetree_from_ty_impl_inner(tcx, tuple_ty, depth + 1, visited, false);
 
-            for tuple_ty in tuple_types.iter() {
-                let element_tree =
-                    typetree_from_ty_impl_inner(tcx, tuple_ty, depth + 1, visited, false);
+                    let element_layout = tcx
+                        .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(tuple_ty))
+                        .ok()
+                        .map(|layout| layout.size.bytes_usize())
+                        .unwrap_or(0);
 
-                let element_layout = tcx
-                    .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(tuple_ty))
-                    .ok()
-                    .map(|layout| layout.size.bytes_usize())
-                    .unwrap_or(0);
+                    for elem_type in &element_tree.0 {
+                        let offset = if elem_type.offset == -1 {
+                            current_offset as isize
+                        } else {
+                            current_offset as isize + elem_type.offset
+                        };
+                        types.push(Type::from_ty(offset, elem_type));
+                    }
 
-                for elem_type in &element_tree.0 {
-                    let offset = if elem_type.offset == -1 {
-                        current_offset as isize
-                    } else {
-                        current_offset as isize + elem_type.offset
-                    };
-                    types.push(Type::from_ty(offset, elem_type));
+                    current_offset += element_layout;
                 }
 
-                current_offset += element_layout;
+                TypeTree(types)
             }
-
-            TypeTree(types)
         }
         ty::Adt(adt_def, args) if adt_def.is_struct() => {
             let struct_layout =
@@ -207,5 +217,9 @@ fn typetree_from_ty_impl_inner<'tcx>(
             TypeTree(vec![Type { offset, size, kind: enzyme_ty, child: TypeTree::new() }])
         }
         _ => TypeTree::new(),
-    }
+    };
+
+    let popped = visited.pop();
+    debug_assert_eq!(popped, Some(ty));
+    tree
 }
diff --git a/tests/run-make/autodiff/type-trees/slice-dst-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/slice-dst-typetree/rmake.rs
new file mode 100644
index 0000000000000..c19202fa41fe5
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/slice-dst-typetree/rmake.rs
@@ -0,0 +1,18 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    rustc()
+        .input("test.rs")
+        .arg("-Zautodiff=Enable,NoPostopt")
+        .opt_level("0")
+        .arg("-Clto=fat")
+        .emit("llvm-ir")
+        .run();
+
+    let ir = rfs::read("test.ll");
+    llvm_filecheck().patterns("slice-dst.check").check_prefix("OSSTR").stdin_buf(&ir).run();
+    llvm_filecheck().patterns("slice-dst.check").check_prefix("HEADER").stdin_buf(&ir).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/slice-dst-typetree/slice-dst.check b/tests/run-make/autodiff/type-trees/slice-dst-typetree/slice-dst.check
new file mode 100644
index 0000000000000..6031b728213ae
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/slice-dst-typetree/slice-dst.check
@@ -0,0 +1,9 @@
+; Preserve element metadata for the `OsStr` regression from #160327.
+OSSTR-LABEL: define void @split_once(
+OSSTR-NOT: define
+OSSTR: call void @llvm.memcpy{{.*}}"enzyme_type"="{[0]:Pointer, [0,0]:Pointer, [0,0,-1]:Integer, [0,16]:Pointer, [0,16,-1]:Integer}"
+
+; Preserve both data layout and length metadata for a prefixed slice-tail DST.
+HEADER-LABEL: define{{.*}}@header_sum(
+HEADER-SAME: ptr{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@float, [-1,4]:Float@float}"
+HEADER-SAME: i64 "enzyme_type"="{[0]:Integer}"
diff --git a/tests/run-make/autodiff/type-trees/slice-dst-typetree/test.rs b/tests/run-make/autodiff/type-trees/slice-dst-typetree/test.rs
new file mode 100644
index 0000000000000..8cd4d7b57f270
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/slice-dst-typetree/test.rs
@@ -0,0 +1,38 @@
+#![crate_type = "lib"]
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+use std::ffi::OsStr;
+
+// Reduced from `clap_lex::OsStrExt::split_once`.
+#[no_mangle]
+#[inline(never)]
+pub fn split_once<'s>(arg: &'s OsStr, needle: &str) -> Option<(&'s OsStr, &'s OsStr)> {
+    let bytes = arg.as_encoded_bytes();
+    let index = bytes.windows(needle.len()).position(|window| window == needle.as_bytes())?;
+    let (first, second) = bytes.split_at(index + needle.len());
+    unsafe {
+        Some((
+            OsStr::from_encoded_bytes_unchecked(first),
+            OsStr::from_encoded_bytes_unchecked(second),
+        ))
+    }
+}
+
+#[repr(C)]
+pub struct Header<T: ?Sized> {
+    tag: f32,
+    data: T,
+}
+
+#[autodiff_reverse(d_header_sum, Duplicated, Active)]
+#[no_mangle]
+#[inline(never)]
+pub fn header_sum(value: &Header<[f32]>) -> f32 {
+    value.tag + value.data.iter().sum::<f32>()
+}
+
+#[no_mangle]
+pub fn exercise_header_sum(value: &Header<[f32]>, derivative: &mut Header<[f32]>) -> f32 {
+    d_header_sum(value, derivative, 1.0)
+}

From 82317b3f682919e05172bb227a43dffe57d0ab5a Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sat, 1 Aug 2026 16:24:06 -0700
Subject: [PATCH 04/13] Split `SpannedTypeVisitor` into its own crate,
 `rustc_ty_walk`

`rustc_privacy` pulls in all of `rustc_ty_utils`, but only wants
`SpannedTypeVisitor` and `walk_types`. Move those to a small
`rustc_ty_walk` crate.

This allows `rustc_privacy` to start building much sooner.
---
 Cargo.lock                                          | 13 ++++++++++++-
 compiler/rustc_privacy/Cargo.toml                   |  2 +-
 compiler/rustc_privacy/src/lib.rs                   |  4 ++--
 compiler/rustc_ty_utils/Cargo.toml                  |  1 +
 compiler/rustc_ty_utils/src/lib.rs                  |  2 --
 compiler/rustc_ty_utils/src/opaque_types.rs         |  6 +++---
 compiler/rustc_ty_walk/Cargo.toml                   | 12 ++++++++++++
 .../src/sig_types.rs => rustc_ty_walk/src/lib.rs}   |  8 ++++++--
 8 files changed, 37 insertions(+), 11 deletions(-)
 create mode 100644 compiler/rustc_ty_walk/Cargo.toml
 rename compiler/{rustc_ty_utils/src/sig_types.rs => rustc_ty_walk/src/lib.rs} (96%)

diff --git a/Cargo.lock b/Cargo.lock
index 0addc566d6bdd..87074238ea5f6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4621,7 +4621,7 @@ dependencies = [
  "rustc_middle",
  "rustc_session",
  "rustc_span",
- "rustc_ty_utils",
+ "rustc_ty_walk",
  "tracing",
 ]
 
@@ -4908,6 +4908,17 @@ dependencies = [
  "rustc_span",
  "rustc_target",
  "rustc_trait_selection",
+ "rustc_ty_walk",
+ "tracing",
+]
+
+[[package]]
+name = "rustc_ty_walk"
+version = "0.0.0"
+dependencies = [
+ "rustc_hir",
+ "rustc_middle",
+ "rustc_span",
  "tracing",
 ]
 
diff --git a/compiler/rustc_privacy/Cargo.toml b/compiler/rustc_privacy/Cargo.toml
index ff59c19b6bb66..2fcaa58ce31aa 100644
--- a/compiler/rustc_privacy/Cargo.toml
+++ b/compiler/rustc_privacy/Cargo.toml
@@ -13,6 +13,6 @@ rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
-rustc_ty_utils = { path = "../rustc_ty_utils" }
+rustc_ty_walk = { path = "../rustc_ty_walk" }
 tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 96fb0c81a92d6..d5eb1a37a481d 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -1161,7 +1161,7 @@ impl<'tcx> TypePrivacyVisitor<'tcx> {
     }
 }
 
-impl<'tcx> rustc_ty_utils::sig_types::SpannedTypeVisitor<'tcx> for TypePrivacyVisitor<'tcx> {
+impl<'tcx> rustc_ty_walk::SpannedTypeVisitor<'tcx> for TypePrivacyVisitor<'tcx> {
     type Result = ControlFlow<()>;
     fn visit(&mut self, span: Span, value: impl TypeVisitable<TyCtxt<'tcx>>) -> Self::Result {
         self.span = span;
@@ -1754,7 +1754,7 @@ fn check_mod_privacy(tcx: TyCtxt<'_>, mod_id: LocalModId) {
 
     let module = tcx.hir_module_items(mod_id);
     for def_id in module.definitions() {
-        let _ = rustc_ty_utils::sig_types::walk_types(tcx, def_id, &mut visitor);
+        let _ = rustc_ty_walk::walk_types(tcx, def_id, &mut visitor);
 
         if let Some(body_id) = tcx.hir_maybe_body_owned_by(def_id) {
             visitor.visit_nested_body(body_id.id());
diff --git a/compiler/rustc_ty_utils/Cargo.toml b/compiler/rustc_ty_utils/Cargo.toml
index 45e71d8a38860..f633ef9950c09 100644
--- a/compiler/rustc_ty_utils/Cargo.toml
+++ b/compiler/rustc_ty_utils/Cargo.toml
@@ -19,5 +19,6 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
+rustc_ty_walk = { path = "../rustc_ty_walk" }
 tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_ty_utils/src/lib.rs b/compiler/rustc_ty_utils/src/lib.rs
index d775a7bfceff2..6eaf040f45f90 100644
--- a/compiler/rustc_ty_utils/src/lib.rs
+++ b/compiler/rustc_ty_utils/src/lib.rs
@@ -5,7 +5,6 @@
 //! This API is completely unstable and subject to change.
 
 // tidy-alphabetical-start
-#![feature(associated_type_defaults)]
 #![feature(deref_patterns)]
 #![feature(iterator_try_collect)]
 #![feature(never_type)]
@@ -26,7 +25,6 @@ mod needs_drop;
 mod nested_bodies;
 mod opaque_types;
 mod representability;
-pub mod sig_types;
 mod structural_match;
 mod ty;
 
diff --git a/compiler/rustc_ty_utils/src/opaque_types.rs b/compiler/rustc_ty_utils/src/opaque_types.rs
index 9594252b87db0..6dc23c45c5144 100644
--- a/compiler/rustc_ty_utils/src/opaque_types.rs
+++ b/compiler/rustc_ty_utils/src/opaque_types.rs
@@ -186,7 +186,7 @@ impl<'tcx> OpaqueTypeCollector<'tcx> {
             trace!(?define);
             let mode = std::mem::replace(&mut self.mode, CollectionMode::Taits);
             let n = self.opaques.len();
-            super::sig_types::walk_types(self.tcx, define, self);
+            rustc_ty_walk::walk_types(self.tcx, define, self);
             if n == self.opaques.len() {
                 self.tcx.dcx().span_err(span, "item does not contain any opaque types");
             }
@@ -198,7 +198,7 @@ impl<'tcx> OpaqueTypeCollector<'tcx> {
     }
 }
 
-impl<'tcx> super::sig_types::SpannedTypeVisitor<'tcx> for OpaqueTypeCollector<'tcx> {
+impl<'tcx> rustc_ty_walk::SpannedTypeVisitor<'tcx> for OpaqueTypeCollector<'tcx> {
     #[instrument(skip(self), ret, level = "trace")]
     fn visit(&mut self, span: Span, value: impl TypeVisitable<TyCtxt<'tcx>>) {
         self.visit_spanned(span, value);
@@ -328,7 +328,7 @@ fn opaque_types_defined_by<'tcx>(
     trace!(?kind);
     let mut collector = OpaqueTypeCollector::new(tcx, item);
     collector.collect_taits_from_defines_attr();
-    super::sig_types::walk_types(tcx, item, &mut collector);
+    rustc_ty_walk::walk_types(tcx, item, &mut collector);
 
     match kind {
         DefKind::AssocFn
diff --git a/compiler/rustc_ty_walk/Cargo.toml b/compiler/rustc_ty_walk/Cargo.toml
new file mode 100644
index 0000000000000..61efed19a7582
--- /dev/null
+++ b/compiler/rustc_ty_walk/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "rustc_ty_walk"
+version = "0.0.0"
+edition = "2024"
+
+[dependencies]
+# tidy-alphabetical-start
+rustc_hir = { path = "../rustc_hir" }
+rustc_middle = { path = "../rustc_middle" }
+rustc_span = { path = "../rustc_span" }
+tracing = "0.1"
+# tidy-alphabetical-end
diff --git a/compiler/rustc_ty_utils/src/sig_types.rs b/compiler/rustc_ty_walk/src/lib.rs
similarity index 96%
rename from compiler/rustc_ty_utils/src/sig_types.rs
rename to compiler/rustc_ty_walk/src/lib.rs
index 3a08114768cab..ae3cf23809da0 100644
--- a/compiler/rustc_ty_utils/src/sig_types.rs
+++ b/compiler/rustc_ty_walk/src/lib.rs
@@ -1,5 +1,9 @@
-//! This module contains helpers for walking all types of
-//! a signature, while preserving spans as much as possible
+//! This crate contains a helper for walking all types of a signature, while preserving spans as
+//! much as possible
+
+// tidy-alphabetical-start
+#![feature(associated_type_defaults)]
+// tidy-alphabetical-end
 
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;

From 0f80d01a0ae2051c9160dfb64fb335e535a71a09 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Mon, 3 Aug 2026 21:49:09 -0700
Subject: [PATCH 05/13] Bless bootstrap tests for new `rustc_ty_walk` crate

---
 .../src/core/builder/cli_paths/snapshots/x_bench.snap  |  1 +
 .../builder/cli_paths/snapshots/x_build_compiler.snap  |  1 +
 .../src/core/builder/cli_paths/snapshots/x_check.snap  |  1 +
 .../builder/cli_paths/snapshots/x_check_compiler.snap  |  1 +
 .../x_check_compiletest_include_default_paths.snap     |  1 +
 .../src/core/builder/cli_paths/snapshots/x_clippy.snap |  1 +
 .../src/core/builder/cli_paths/snapshots/x_fix.snap    |  1 +
 .../src/core/builder/cli_paths/snapshots/x_test.snap   |  1 +
 .../cli_paths/snapshots/x_test_skip_coverage.snap      |  1 +
 .../cli_paths/snapshots/x_test_skip_coverage_map.snap  |  1 +
 .../cli_paths/snapshots/x_test_skip_coverage_run.snap  |  1 +
 .../builder/cli_paths/snapshots/x_test_skip_tests.snap |  1 +
 .../snapshots/x_test_skip_tests_coverage.snap          |  1 +
 .../cli_paths/snapshots/x_test_skip_tests_etc.snap     |  1 +
 src/bootstrap/src/core/builder/tests.rs                | 10 +++++-----
 15 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_bench.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_bench.snap
index 369bdb4e519e1..2daa06d2f4b78 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_bench.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_bench.snap
@@ -91,6 +91,7 @@ expression: bench
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_build_compiler.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_build_compiler.snap
index 3d9354b912698..829ca411eb0e5 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_build_compiler.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_build_compiler.snap
@@ -73,6 +73,7 @@ expression: build compiler
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check.snap
index b47af601cdaf8..325f21b7fdd70 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check.snap
@@ -75,6 +75,7 @@ expression: check
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiler.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiler.snap
index e8eea8e143227..38693b1f636bf 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiler.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiler.snap
@@ -75,6 +75,7 @@ expression: check compiler
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiletest_include_default_paths.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiletest_include_default_paths.snap
index 399110b4d70d7..1d83aa61fdfc2 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiletest_include_default_paths.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiletest_include_default_paths.snap
@@ -75,6 +75,7 @@ expression: check compiletest --include-default-paths
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_clippy.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_clippy.snap
index a8a4d4ed2286b..b409b12093455 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_clippy.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_clippy.snap
@@ -90,6 +90,7 @@ expression: clippy
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_fix.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_fix.snap
index d3d3a46255917..15a849db3801e 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_fix.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_fix.snap
@@ -75,6 +75,7 @@ expression: fix
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap
index 289912de1bf98..346a86cb5bd6c 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap
@@ -139,6 +139,7 @@ expression: test
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap
index e3310a3d64e0d..d08c6a96942d8 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap
@@ -136,6 +136,7 @@ expression: test --skip=coverage
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage_map.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage_map.snap
index 6ffa385654c1a..b51654bb7d46b 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage_map.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage_map.snap
@@ -139,6 +139,7 @@ expression: test --skip=coverage-map
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage_run.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage_run.snap
index bc8356d1bcf5e..bffe4909c6305 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage_run.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage_run.snap
@@ -139,6 +139,7 @@ expression: test --skip=coverage-run
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests.snap
index 93d6100a01fef..3ee569401504f 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests.snap
@@ -100,6 +100,7 @@ expression: test --skip=tests
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_coverage.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_coverage.snap
index 7d13279ae6da7..c8212e05b46d0 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_coverage.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_coverage.snap
@@ -136,6 +136,7 @@ expression: test --skip=tests/coverage
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_etc.snap b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_etc.snap
index 5f2cb9e124dd4..e41050139f056 100644
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_etc.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_etc.snap
@@ -84,6 +84,7 @@ expression: test --skip=tests --skip=library --skip=tidyselftest
     - Set({compiler/rustc_traits})
     - Set({compiler/rustc_transmute})
     - Set({compiler/rustc_ty_utils})
+    - Set({compiler/rustc_ty_walk})
     - Set({compiler/rustc_type_ir})
     - Set({compiler/rustc_type_ir_macros})
     - Set({compiler/rustc_windows_rc})
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index f56de744883b8..bc4720f5a5283 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1775,7 +1775,7 @@ mod snapshot {
         insta::assert_snapshot!(
             ctx.config("check")
                 .path("compiler")
-                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (73 crates)");
+                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (74 crates)");
     }
 
     #[test]
@@ -1801,7 +1801,7 @@ mod snapshot {
             ctx.config("check")
                 .path("compiler")
                 .stage(1)
-                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (73 crates)");
+                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (74 crates)");
     }
 
     #[test]
@@ -1815,7 +1815,7 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
-        [check] rustc 1 <host> -> rustc 2 <host> (73 crates)
+        [check] rustc 1 <host> -> rustc 2 <host> (74 crates)
         ");
     }
 
@@ -1831,7 +1831,7 @@ mod snapshot {
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [check] rustc 1 <host> -> std 1 <target1>
-        [check] rustc 1 <host> -> rustc 2 <target1> (73 crates)
+        [check] rustc 1 <host> -> rustc 2 <target1> (74 crates)
         [check] rustc 1 <host> -> rustc 2 <target1>
         [check] rustc 1 <host> -> Rustdoc 2 <target1>
         [check] rustc 1 <host> -> rustc_codegen_cranelift 2 <target1>
@@ -1927,7 +1927,7 @@ mod snapshot {
             ctx.config("check")
                 .paths(&["library", "compiler"])
                 .args(&args)
-                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (73 crates)");
+                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (74 crates)");
     }
 
     #[test]

From e3464abaed1f7e7d7c03695cc7384a01628cae4c Mon Sep 17 00:00:00 2001
From: Roland Xu <rcu@live.com>
Date: Mon, 3 Aug 2026 21:50:17 +0800
Subject: [PATCH 06/13] Avoid resolving path keywords outside TypeNS

---
 compiler/rustc_resolve/src/ident.rs           |  6 +-----
 ...y-non-module-issue-160195.env_first.stderr |  8 +++++++
 ...-non-module-issue-160195.env_second.stderr |  8 +++++++
 ...cro-determinacy-non-module-issue-160195.rs | 21 +++++++++++++++++++
 4 files changed, 38 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/resolve/macro-determinacy-non-module-issue-160195.env_first.stderr
 create mode 100644 tests/ui/resolve/macro-determinacy-non-module-issue-160195.env_second.stderr
 create mode 100644 tests/ui/resolve/macro-determinacy-non-module-issue-160195.rs

diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 3f34af1d01d83..bf3dd49d295b2 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -419,7 +419,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ignore_import: Option<Import<'ra>>,
     ) -> Result<Decl<'ra>, Determinacy> {
         // Make sure `self`, `super` etc produce an error when passed to here.
-        if !matches!(scope_set, ScopeSet::Module(..)) && ident.name.is_path_segment_keyword() {
+        if ident.name.is_path_segment_keyword() {
             return Err(Determinacy::Determined);
         }
 
@@ -1077,10 +1077,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     {
                         let module = self.resolve_crate_root(ident);
                         return Ok(module.self_decl.unwrap());
-                    } else if ident.name == kw::Super {
-                        // FIXME: Implement these with renaming requirements so that e.g.
-                        // `use super;` doesn't work, but `use super as name;` does.
-                        // Fall through here to get an error from `early_resolve_...`.
                     }
                 }
 
diff --git a/tests/ui/resolve/macro-determinacy-non-module-issue-160195.env_first.stderr b/tests/ui/resolve/macro-determinacy-non-module-issue-160195.env_first.stderr
new file mode 100644
index 0000000000000..cf8c7221c2367
--- /dev/null
+++ b/tests/ui/resolve/macro-determinacy-non-module-issue-160195.env_first.stderr
@@ -0,0 +1,8 @@
+error: `env!()` takes 1 or 2 arguments
+  --> $DIR/macro-determinacy-non-module-issue-160195.rs:12:22
+   |
+LL |     include!(concat!(env!()));
+   |                      ^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/resolve/macro-determinacy-non-module-issue-160195.env_second.stderr b/tests/ui/resolve/macro-determinacy-non-module-issue-160195.env_second.stderr
new file mode 100644
index 0000000000000..cf8c7221c2367
--- /dev/null
+++ b/tests/ui/resolve/macro-determinacy-non-module-issue-160195.env_second.stderr
@@ -0,0 +1,8 @@
+error: `env!()` takes 1 or 2 arguments
+  --> $DIR/macro-determinacy-non-module-issue-160195.rs:12:22
+   |
+LL |     include!(concat!(env!()));
+   |                      ^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/resolve/macro-determinacy-non-module-issue-160195.rs b/tests/ui/resolve/macro-determinacy-non-module-issue-160195.rs
new file mode 100644
index 0000000000000..ca08a665e907b
--- /dev/null
+++ b/tests/ui/resolve/macro-determinacy-non-module-issue-160195.rs
@@ -0,0 +1,21 @@
+//@ revisions: env_first env_second
+
+#[cfg(env_first)]
+pub mod env {
+    #[derive(Default)]
+    pub struct BusinessData;
+}
+
+pub mod interface {
+    use crate::env::{self};
+
+    include!(concat!(env!())); //~ ERROR `env!()` takes 1 or 2 arguments
+}
+
+#[cfg(env_second)]
+pub mod env {
+    #[derive(Default)]
+    pub struct BusinessData;
+}
+
+fn main() {}

From e0830fa2bec1da2e1ec8ba8c3d9eb4be332e8136 Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Tue, 4 Aug 2026 16:01:41 +0200
Subject: [PATCH 07/13] implement unsafe speculative flag to be used by
 `CmRefCell::borrow`, which does tracked and untracked borrowing

---
 compiler/rustc_resolve/src/check_unused.rs    |  2 +-
 .../rustc_resolve/src/diagnostics/impls.rs    |  4 +-
 .../src/effective_visibilities.rs             |  4 +-
 compiler/rustc_resolve/src/ident.rs           | 25 +++---
 compiler/rustc_resolve/src/imports.rs         | 18 ++--
 .../rustc_resolve/src/late/diagnostics.rs     | 10 ++-
 compiler/rustc_resolve/src/lib.rs             | 86 +++++++++++++++----
 compiler/rustc_resolve/src/macros.rs          |  2 +-
 8 files changed, 107 insertions(+), 44 deletions(-)

diff --git a/compiler/rustc_resolve/src/check_unused.rs b/compiler/rustc_resolve/src/check_unused.rs
index 41573749abbe7..dcbda2f96323e 100644
--- a/compiler/rustc_resolve/src/check_unused.rs
+++ b/compiler/rustc_resolve/src/check_unused.rs
@@ -559,7 +559,7 @@ impl Resolver<'_, '_> {
         let mut check_redundant_imports = FxIndexSet::default();
         for module in &self.local_modules {
             for (_key, resolution) in self.resolutions(module.to_module()).iter() {
-                if let Some(decl) = resolution.borrow().best_decl()
+                if let Some(decl) = resolution.borrow(self).best_decl()
                     && let DeclKind::Import { import, .. } = decl.kind
                     && let ImportKind::Single { id, .. } = import.kind
                 {
diff --git a/compiler/rustc_resolve/src/diagnostics/impls.rs b/compiler/rustc_resolve/src/diagnostics/impls.rs
index cc2c72ad59906..4e451665398e9 100644
--- a/compiler/rustc_resolve/src/diagnostics/impls.rs
+++ b/compiler/rustc_resolve/src/diagnostics/impls.rs
@@ -1873,7 +1873,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     self.resolutions(parent_scope.module).iter().any(|(key, name_resolution)| {
                         if key.ns == TypeNS
                             && key.ident == *ident
-                            && let Some(decl) = name_resolution.borrow().best_decl()
+                            && let Some(decl) = name_resolution.borrow(self).best_decl()
                         {
                             match decl.res() {
                                 // No disambiguation needed if the identically named item we
@@ -3603,7 +3603,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 let mut res = false;
                 let m = r.expect_module(parent_module);
                 if m.is_local() {
-                    for importer in m.glob_importers.borrow().iter() {
+                    for importer in m.glob_importers.borrow(r).iter() {
                         if let Some(next_parent_module) = importer.parent_scope.module.opt_def_id()
                         {
                             if next_parent_module == module
diff --git a/compiler/rustc_resolve/src/effective_visibilities.rs b/compiler/rustc_resolve/src/effective_visibilities.rs
index ff976b080d40d..840a8a8682538 100644
--- a/compiler/rustc_resolve/src/effective_visibilities.rs
+++ b/compiler/rustc_resolve/src/effective_visibilities.rs
@@ -126,7 +126,7 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
     fn set_bindings_effective_visibilities(&mut self, module_id: LocalDefId) {
         let module = self.r.expect_module(module_id.to_def_id());
         for (_, name_resolution) in self.r.resolutions(module).iter() {
-            let Some(decl) = name_resolution.borrow().best_decl() else {
+            let Some(decl) = name_resolution.borrow(self.r).best_decl() else {
                 continue;
             };
             self.update_decl_chain(decl, ParentId::Def(module_id));
@@ -310,7 +310,7 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
         if self.macro_reachable.insert((module_def_id, defining_mod)) {
             let module = self.r.expect_module(module_def_id.to_def_id());
             for (_, name_resolution) in self.r.resolutions(module).iter() {
-                let Some(decl) = name_resolution.borrow().best_decl() else {
+                let Some(decl) = name_resolution.borrow(self.r).best_decl() else {
                     continue;
                 };
 
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 3f34af1d01d83..42fc5964f5aa1 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -714,7 +714,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
             Scope::MacroUsePrelude => match self.macro_use_prelude.get(&ident.name).cloned() {
                 Some(decl) => Ok(decl),
-                None => Err(Determinacy::determined(!self.graph_root.has_unexpanded_invocations())),
+                None => {
+                    Err(Determinacy::determined(!self.graph_root.has_unexpanded_invocations(&self)))
+                }
             },
             Scope::BuiltinAttrs => match self.builtin_attr_decls.get(&ident.name) {
                 Some(decl) => Ok(*decl),
@@ -727,9 +729,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     finalize.is_some(),
                 ) {
                     Some(decl) => Ok(decl),
-                    None => {
-                        Err(Determinacy::determined(!self.graph_root.has_unexpanded_invocations()))
-                    }
+                    None => Err(Determinacy::determined(
+                        !self.graph_root.has_unexpanded_invocations(&self),
+                    )),
                 }
             }
             Scope::ExternPreludeFlags => {
@@ -1158,7 +1160,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         if let Some(finalize) = finalize {
             // finalize implies that the module is fully expanded
-            assert!(!module.has_unexpanded_invocations());
+            assert!(!module.has_unexpanded_invocations(&self));
             return self.get_mut().finalize_module_binding(
                 ident,
                 orig_ident_span,
@@ -1195,7 +1197,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
 
         // Check if one of unexpanded macros can still define the name.
-        if module.has_unexpanded_invocations() {
+        if module.has_unexpanded_invocations(&self) {
             return Err(ControlFlow::Continue(Undetermined));
         }
 
@@ -1224,7 +1226,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         if let Some(finalize) = finalize {
             // finalize implies that the module is fully expanded
-            assert!(!module.has_unexpanded_invocations());
+            assert!(!module.has_unexpanded_invocations(&self));
             return self.get_mut().finalize_module_binding(
                 ident,
                 orig_ident_span,
@@ -1268,7 +1270,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // and prohibit access to macro-expanded `macro_export` macros instead (unless restricted
         // shadowing is enabled, see `macro_expanded_macro_export_errors`).
         if let Some(binding) = binding {
-            return if binding.determined() || ns == MacroNS || shadowing == Shadowing::Restricted {
+            return if binding.determined(&self)
+                || ns == MacroNS
+                || shadowing == Shadowing::Restricted
+            {
                 let accessible = self.is_accessible_from(binding.vis(), parent_scope.module);
                 if accessible { Ok(binding) } else { Err(ControlFlow::Break(Determined)) }
             } else {
@@ -1283,13 +1288,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // scopes we return `Undetermined` with `ControlFlow::Continue`.
         // Check if one of unexpanded macros can still define the name,
         // if it can then our "no resolution" result is not determined and can be invalidated.
-        if module.has_unexpanded_invocations() {
+        if module.has_unexpanded_invocations(&self) {
             return Err(ControlFlow::Continue(Undetermined));
         }
 
         // Check if one of glob imports can still define the name,
         // if it can then our "no resolution" result is not determined and can be invalidated.
-        for glob_import in module.globs.borrow().iter() {
+        for glob_import in module.globs.borrow(&self).iter() {
             if ignore_import == Some(*glob_import) {
                 continue;
             }
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 6e2ea9abf2de8..499f9ea297362 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -781,14 +781,22 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             let mut imports_to_resolve = mem::take(&mut self.indeterminate_imports);
 
-            self.assert_speculative = true;
+            // SAFETY: This is a "top-level" function used by the macro expansion code, unless some
+            // weird thing is done, all `tracked` borrows done in the previous call of
+            // `resolve_imports` are dropped when that call ended.
+            unsafe { self.speculative_flag.set(true) };
             rustc_data_structures::sync::par_for_each_slice(
                 &mut imports_to_resolve,
                 |(import, resolution, indeterminate_count)| {
                     (*resolution, *indeterminate_count) = self.resolve_import(*import);
                 },
             );
-            self.assert_speculative = false;
+            // SAFETY: All `untracked` borrows are dropped after the `par_for_each_slice` call,
+            // as they cannot escape since they are tied to the `CmRefCell` they borrowed from.
+            //
+            // Note: Some `CmRefCell`s are arena allocated and thus have the `'ra` lifetime,
+            // allowing these borrows to escape, but that does not and should not happen.
+            unsafe { self.speculative_flag.set(false) };
 
             self.write_import_resolutions(&imports_to_resolve);
 
@@ -1003,7 +1011,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     pub(crate) fn lint_reexports(&mut self, exported_ambiguities: FxHashSet<Decl<'ra>>) {
         for module in &self.local_modules {
             for (key, resolution) in self.resolutions(module.to_module()).iter() {
-                let resolution = resolution.borrow();
+                let resolution = resolution.borrow(self);
                 let Some(binding) = resolution.best_decl() else { continue };
 
                 // Report "cannot reexport" errors for exotic cases involving macros 2.0
@@ -1490,7 +1498,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                     return None;
                                 } // `use _` is never valid
 
-                                let resolution = resolution.borrow();
+                                let resolution = resolution.borrow(self);
                                 if let Some(name_binding) = resolution.best_decl() {
                                     match name_binding.kind {
                                         DeclKind::Import { source_decl, .. } => {
@@ -1800,7 +1808,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 .resolutions(module)
                 .iter()
                 .filter_map(|(key, resolution)| {
-                    let res = resolution.borrow();
+                    let res = resolution.borrow(self);
                     let decl = res.determined_decl()?;
                     let mut key = *key;
                     let scope = match key.ident.ctxt.update_unchecked(|ctxt| {
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 6350f79ed007f..b126272583692 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -194,7 +194,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
             if key.ident.name != assoc_name {
                 return None;
             }
-            let resolution = resolution.borrow();
+            let resolution = resolution.borrow(self.r);
             let binding = resolution.best_decl()?;
             match binding.res() {
                 Res::Def(DefKind::AssocTy, def_id) => Some(def_id),
@@ -1165,7 +1165,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         let find_doc_alias_name = |r: &mut Resolver<'ra, '_>, m: Module<'ra>, item_name: Symbol| {
             for resolution in r.resolutions(m).values() {
                 let Some(did) =
-                    resolution.borrow().best_decl().and_then(|binding| binding.res().opt_def_id())
+                    resolution.borrow(r).best_decl().and_then(|binding| binding.res().opt_def_id())
                 else {
                     continue;
                 };
@@ -1905,7 +1905,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                     .resolutions(module)
                     .iter()
                     .filter_map(|(key, resolution)| {
-                        let resolution = resolution.borrow();
+                        let resolution = resolution.borrow(self.r);
                         resolution.best_decl().map(|binding| binding.res()).and_then(|res| {
                             if filter_fn(res) {
                                 Some((key.ident.name, resolution.orig_ident_span, res))
@@ -2766,7 +2766,9 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
             .r
             .resolutions(*module)
             .iter()
-            .filter_map(|(key, res)| res.borrow().best_decl().map(|binding| (key, binding.res())))
+            .filter_map(|(key, res)| {
+                res.borrow(self.r).best_decl().map(|binding| (key, binding.res()))
+            })
             .filter(|(_, res)| match (kind, res) {
                 (AssocItemKind::Const(..), Res::Def(DefKind::AssocConst { .. }, _)) => true,
                 (AssocItemKind::Fn(_), Res::Def(DefKind::AssocFn, _)) => true,
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index a3c804e56ee22..b7e57ad8ec37e 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -21,7 +21,7 @@
 #![recursion_limit = "256"]
 // tidy-alphabetical-end
 
-use std::cell::{Ref, RefMut};
+use std::cell::RefMut;
 use std::collections::BTreeSet;
 use std::ops::ControlFlow;
 use std::sync::{Arc, OnceLock};
@@ -81,6 +81,7 @@ use crate::diagnostics::impls::{
     ImportSuggestion, LabelSuggestion, OnUnknownData, StructCtor, Suggestion,
 };
 use crate::imports::{ImportResolution, NameResolutionRef};
+use crate::ref_mut::speculative::SpeculativeFlag;
 use crate::ref_mut::{CmCell, CmRef, CmRefCell};
 
 mod build_reduced_graph;
@@ -767,8 +768,8 @@ impl<'ra> ModuleData<'ra> {
         self.kind.is_local()
     }
 
-    fn has_unexpanded_invocations(&self) -> bool {
-        !self.unexpanded_invocations.borrow().is_empty()
+    fn has_unexpanded_invocations<'tcx>(&self, r: &Resolver<'ra, 'tcx>) -> bool {
+        !self.unexpanded_invocations.borrow(r).is_empty()
     }
 
     fn res(&self) -> Option<Res> {
@@ -793,7 +794,7 @@ impl<'ra> Module<'ra> {
         mut f: impl FnMut(&R, IdentKey, Span, Namespace, Decl<'ra>),
     ) {
         for (key, name_resolution) in resolver.as_ref().resolutions(self).iter() {
-            let name_resolution = name_resolution.borrow();
+            let name_resolution = name_resolution.borrow(resolver.as_ref());
             if let Some(decl) = name_resolution.best_decl() {
                 f(resolver, key.ident, name_resolution.orig_ident_span, key.ns, decl);
             }
@@ -806,7 +807,7 @@ impl<'ra> Module<'ra> {
         mut f: impl FnMut(&mut R, IdentKey, Span, Namespace, Decl<'ra>),
     ) {
         for (key, name_resolution) in resolver.as_mut().resolutions(self).iter() {
-            let name_resolution = name_resolution.borrow();
+            let name_resolution = name_resolution.borrow(resolver.as_mut());
             if let Some(decl) = name_resolution.best_decl() {
                 f(resolver, key.ident, name_resolution.orig_ident_span, key.ns, decl);
             }
@@ -1252,10 +1253,11 @@ impl<'ra> DeclData<'ra> {
     /// the declaration may not be as "determined" as we think.
     /// FIXME: relationship between this function and similar `NameResolution::determined_decl`
     /// is unclear.
-    fn determined(&self) -> bool {
+    fn determined<'tcx>(&self, r: &Resolver<'ra, 'tcx>) -> bool {
         match &self.kind {
             DeclKind::Import { source_decl, import, .. } if import.is_glob() => {
-                !import.parent_scope.module.has_unexpanded_invocations() && source_decl.determined()
+                !import.parent_scope.module.has_unexpanded_invocations(r)
+                    && source_decl.determined(r)
             }
             _ => true,
         }
@@ -1336,7 +1338,7 @@ pub struct Resolver<'ra, 'tcx> {
     graph_root: LocalModule<'ra>,
 
     /// Assert that we are in speculative resolution mode (unsafe field).
-    assert_speculative: bool,
+    speculative_flag: SpeculativeFlag,
 
     prelude: Option<Module<'ra>> = None,
     extern_prelude: FxIndexMap<IdentKey, ExternPreludeEntry<'ra>>,
@@ -1810,7 +1812,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             // The outermost module has def ID 0; this is not reflected in the
             // AST.
             graph_root,
-            assert_speculative: false, // Only set/cleared in Resolver::resolve_imports for now
+            // Only set/cleared in Resolver::resolve_imports for now
+            speculative_flag: SpeculativeFlag::default(),
             extern_prelude,
 
             empty_module,
@@ -2011,7 +2014,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     /// Returns a conditionally mutable resolver that can be mutated.
     /// Will panic if the `assert_speculative` field is true.
     fn cm_mut(&mut self) -> CmResolver<'_, 'ra, 'tcx> {
-        assert!(!self.assert_speculative, "can't mutably borrow speculative resolver");
+        assert!(
+            !self.speculative_flag.is_speculative(),
+            "can't mutably borrow speculative resolver"
+        );
         CmResolver::Mut(self)
     }
 
@@ -2127,7 +2133,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         found_traits: &mut Vec<TraitCandidate<'tcx>>,
     ) {
         module.ensure_traits(self);
-        let traits = module.traits.borrow();
+        let traits = module.traits.borrow(self);
         for &(trait_name, trait_binding, trait_module, lint_ambiguous) in
             traits.as_ref().unwrap().iter()
         {
@@ -2178,7 +2184,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     fn resolutions(&self, module: Module<'ra>) -> CmRef<'ra, ResolutionTable<'ra>> {
         match &module.0.0.lazy_resolutions {
-            Resolutions::Local(local_res) => CmRef::Tracked(local_res.borrow()),
+            Resolutions::Local(local_res) => local_res.borrow(self),
             Resolutions::Extern(extern_res) => {
                 // It is fine to return a `CmRef::Untracked`, we never give out a `&mut`
                 // to an external table.
@@ -2206,8 +2212,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         &self,
         module: Module<'ra>,
         key: BindingKey,
-    ) -> Option<Ref<'ra, NameResolution<'ra>>> {
-        self.resolutions(module).get(&key).map(|resolution| resolution.0.borrow())
+    ) -> Option<CmRef<'ra, NameResolution<'ra>>> {
+        self.resolutions(module).get(&key).map(|resolution| resolution.0.borrow(self))
     }
 
     #[track_caller]
@@ -2917,7 +2923,7 @@ mod ref_mut {
         }
 
         pub(crate) fn set<'ra, 'tcx>(&self, val: T, r: &Resolver<'ra, 'tcx>) {
-            if r.assert_speculative {
+            if r.speculative_flag.is_speculative() {
                 panic!("not allowed to mutate a `CmCell` during speculative resolution")
             }
             self.0.set(val);
@@ -2946,6 +2952,27 @@ mod ref_mut {
         }
     }
 
+    pub(crate) mod speculative {
+        #[derive(Debug, Clone, Copy, Default)]
+        pub(crate) struct SpeculativeFlag(bool);
+
+        impl SpeculativeFlag {
+            /// # SAFETY
+            ///
+            /// All borrows created by `CmRefCell::borrow` must be dropped before changing
+            /// the speculative flag:
+            /// - `tracked` borrows before setting it to `true`.
+            /// - `untracked` borrows before setting it to `false`.
+            pub(crate) unsafe fn set(&mut self, value: bool) {
+                self.0 = value;
+            }
+
+            pub(crate) fn is_speculative(&self) -> bool {
+                self.0
+            }
+        }
+    }
+
     /// A wrapper around a [`RefCell`] that only allows writes (mutable borrows) based on a condition in the resolver.
     #[derive(Default)]
     pub(crate) struct CmRefCell<T>(RefCell<T>);
@@ -2965,21 +2992,42 @@ mod ref_mut {
             &self,
             r: &Resolver<'ra, 'tcx>,
         ) -> Result<RefMut<'_, T>, BorrowMutError> {
-            if r.assert_speculative {
+            if r.speculative_flag.is_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()
+        pub(crate) fn borrow<'ra, 'tcx>(&self, r: &Resolver<'ra, 'tcx>) -> CmRef<'_, T> {
+            if r.speculative_flag.is_speculative() {
+                // `try_borrow_unguarded` is unsafe because it returns a `&T` instead
+                // of `Ref<'_, T>`. It does provides an extra check to make sure no live
+                // `RefMut`s are still alive, but the other way can not be checked, so:
+                //
+                // SAFETY: This is only safe because we know that every `Untracked` borrow
+                // is only created during the import resolutions phase:
+                //
+                // ```rust
+                // // tracked borrows
+                // unsafe { resolver.speculative_flag.set_true() };
+                // import_resolution(); // untracked borrows
+                // unsafe { resolver.speculative_flag.set_true() };
+                // // tracked borrows
+                // ```
+                //
+                // `speculative::Flag` requires all of the borrows that happened during a
+                // particular phase are dropped before being set to true/false.
+                CmRef::Untracked(unsafe { self.0.try_borrow_unguarded().unwrap() })
+            } else {
+                CmRef::Tracked(self.0.borrow())
+            }
         }
     }
 
     impl<T: Default> CmRefCell<T> {
         pub(crate) fn take<'ra, 'tcx>(&self, r: &Resolver<'ra, 'tcx>) -> T {
-            if r.assert_speculative {
+            if r.speculative_flag.is_speculative() {
                 panic!("not allowed to mutate a CmRefCell during speculative resolution");
             }
             self.0.take()
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 1e9d60ca21551..6921d0ed595fe 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -562,7 +562,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
         star_span: Span,
     ) -> Result<Vec<(Ident, Option<Ident>)>, Indeterminate> {
         let target_trait = self.expect_module(trait_def_id);
-        if target_trait.has_unexpanded_invocations() {
+        if target_trait.has_unexpanded_invocations(self) {
             return Err(Indeterminate);
         }
         // FIXME: Instead of waiting try generating all trait methods, and pruning

From 180c6379b8ed8b8ff5d9545c716a17d2225c915c Mon Sep 17 00:00:00 2001
From: mejrs <59372212+mejrs@users.noreply.github.com>
Date: Mon, 3 Aug 2026 23:21:15 +0200
Subject: [PATCH 08/13] Remove rustc_middle dependency on rustc_hir_pretty

There is a `impl PpAnn for TyCtxt`  that is unneeded. None of the big crates (middle, trait_selection) actually do any hir pretty printing so it can be removed and can either be implemented for local structs elsewhere or done by casting to `&dyn PpAnn` instead.
---
 Cargo.lock                                    |   2 +-
 compiler/rustc_driver_impl/Cargo.toml         |   1 +
 compiler/rustc_driver_impl/src/pretty.rs      |  10 +-
 compiler/rustc_hir_typeck/src/_match.rs       |   2 +-
 compiler/rustc_hir_typeck/src/callee.rs       |   2 +-
 compiler/rustc_hir_typeck/src/expr.rs         |   5 +-
 compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs  |  10 +
 .../src/fn_ctxt/suggestions.rs                |   4 +-
 compiler/rustc_hir_typeck/src/lib.rs          | 244 +++++++++---------
 compiler/rustc_hir_typeck/src/pat.rs          |  17 +-
 compiler/rustc_middle/Cargo.toml              |   1 -
 compiler/rustc_middle/src/hir/map.rs          |   7 -
 .../rustc_public_bridge/src/context/impls.rs  |  14 +-
 src/librustdoc/json/conversions.rs            |   8 +-
 .../src/matches/match_wild_err_arm.rs         |   3 +-
 .../src/unnecessary_mut_passed.rs             |   5 +-
 16 files changed, 180 insertions(+), 155 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 76b17e02c2359..2190fa22b77ac 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3954,6 +3954,7 @@ dependencies = [
  "rustc_errors",
  "rustc_expand",
  "rustc_feature",
+ "rustc_hir",
  "rustc_hir_analysis",
  "rustc_hir_pretty",
  "rustc_index",
@@ -4414,7 +4415,6 @@ dependencies = [
  "rustc_graphviz",
  "rustc_hashes",
  "rustc_hir",
- "rustc_hir_pretty",
  "rustc_index",
  "rustc_lint_defs",
  "rustc_macros",
diff --git a/compiler/rustc_driver_impl/Cargo.toml b/compiler/rustc_driver_impl/Cargo.toml
index c7d3e4fae3fc5..4871c7eb9e8b0 100644
--- a/compiler/rustc_driver_impl/Cargo.toml
+++ b/compiler/rustc_driver_impl/Cargo.toml
@@ -16,6 +16,7 @@ rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_expand = { path = "../rustc_expand" }
 rustc_feature = { path = "../rustc_feature" }
+rustc_hir = { path = "../rustc_hir" }
 rustc_hir_analysis = { path = "../rustc_hir_analysis" }
 rustc_hir_pretty = { path = "../rustc_hir_pretty" }
 rustc_index = { path = "../rustc_index" }
diff --git a/compiler/rustc_driver_impl/src/pretty.rs b/compiler/rustc_driver_impl/src/pretty.rs
index 3a0a6687dd812..4bf1a3d875866 100644
--- a/compiler/rustc_driver_impl/src/pretty.rs
+++ b/compiler/rustc_driver_impl/src/pretty.rs
@@ -7,7 +7,9 @@ use std::io;
 
 use rustc_ast as ast;
 use rustc_ast_pretty::pprust as pprust_ast;
+use rustc_hir::intravisit;
 use rustc_hir_pretty as pprust_hir;
+use rustc_hir_pretty::PpAnn;
 use rustc_middle::bug;
 use rustc_middle::mir::{write_mir_graphviz, write_mir_pretty};
 use rustc_middle::ty::{self, TyCtxt};
@@ -71,7 +73,8 @@ struct HirIdentifiedAnn<'tcx> {
 
 impl<'tcx> pprust_hir::PpAnn for HirIdentifiedAnn<'tcx> {
     fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) {
-        self.tcx.nested(state, nested)
+        let this = &self.tcx as &dyn intravisit::HirTyCtxt<'_>;
+        this.nested(state, nested)
     }
 
     fn pre(&self, s: &mut pprust_hir::State<'_>, node: pprust_hir::AnnNode<'_>) {
@@ -149,11 +152,12 @@ struct HirTypedAnn<'tcx> {
 
 impl<'tcx> pprust_hir::PpAnn for HirTypedAnn<'tcx> {
     fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) {
+        let this = &self.tcx as &dyn intravisit::HirTyCtxt<'_>;
         let old_maybe_typeck_results = self.maybe_typeck_results.get();
         if let pprust_hir::Nested::Body(id) = nested {
             self.maybe_typeck_results.set(Some(self.tcx.typeck_body(id)));
         }
-        self.tcx.nested(state, nested);
+        this.nested(state, nested);
         self.maybe_typeck_results.set(old_maybe_typeck_results);
     }
 
@@ -281,7 +285,7 @@ pub fn print<'tcx>(sess: &Session, ppm: PpMode, ex: PrintExtra<'tcx>) {
                 )
             };
             match s {
-                PpHirMode::Normal => f(&tcx),
+                PpHirMode::Normal => f(&(&tcx as &dyn intravisit::HirTyCtxt<'_>) as &dyn PpAnn),
                 PpHirMode::Identified => {
                     let annotation = HirIdentifiedAnn { tcx };
                     f(&annotation)
diff --git a/compiler/rustc_hir_typeck/src/_match.rs b/compiler/rustc_hir_typeck/src/_match.rs
index ebf9907e64e64..a1ff036574fdc 100644
--- a/compiler/rustc_hir_typeck/src/_match.rs
+++ b/compiler/rustc_hir_typeck/src/_match.rs
@@ -421,7 +421,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     return self.get_fn_decl(hir_id).map(|(_, fn_decl)| {
                         let (ty, span) = match fn_decl.output {
                             hir::FnRetTy::DefaultReturn(span) => ("()".to_string(), span),
-                            hir::FnRetTy::Return(ty) => (ty_to_string(&self.tcx, ty), ty.span),
+                            hir::FnRetTy::Return(ty) => (ty_to_string(self, ty), ty.span),
                         };
                         (span, format!("expected `{ty}` because of this return type"))
                     });
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index 288a1903bf675..3074a5900773d 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -903,7 +903,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             };
             let removal_span = callee_expr.span.shrink_to_hi().to(call_expr.span.shrink_to_hi());
             unit_variant =
-                Some((removal_span, descr, rustc_hir_pretty::qpath_to_string(&self.tcx, qpath)));
+                Some((removal_span, descr, rustc_hir_pretty::qpath_to_string(self, qpath)));
         }
 
         let callee_ty = self.resolve_vars_if_possible(callee_ty);
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index f89d67eced3fb..12e7f82cadd43 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -50,7 +50,7 @@ use crate::diagnostics::{
 use crate::op::contains_let_in_chain;
 use crate::{
     BreakableCtxt, CoroutineTypes, Diverges, FnCtxt, GatherLocalsVisitor, Needs,
-    TupleArgumentsFlag, cast, fatally_break_rust, report_unexpected_variant_res, type_error_struct,
+    TupleArgumentsFlag, cast, fatally_break_rust, type_error_struct,
 };
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
@@ -589,8 +589,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 Ty::new_error(tcx, e)
             }
             Res::Def(DefKind::Variant, _) => {
-                let e = report_unexpected_variant_res(
-                    tcx,
+                let e = self.report_unexpected_variant_res(
                     res,
                     Some(expr),
                     &[],
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
index 287e3857087e7..7a5eeccb98260 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
@@ -220,6 +220,16 @@ impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
     }
 }
 
+impl<'tcx> rustc_hir_pretty::PpAnn for FnCtxt<'_, 'tcx> {
+    fn nested(&self, state: &mut rustc_hir_pretty::State<'_>, nested: rustc_hir_pretty::Nested) {
+        rustc_hir_pretty::PpAnn::nested(
+            &(&self.tcx as &dyn rustc_hir::intravisit::HirTyCtxt<'_>),
+            state,
+            nested,
+        )
+    }
+}
+
 impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
     fn tcx(&self) -> TyCtxt<'tcx> {
         self.tcx
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index b28eb8ad940d9..fc99dd67289bb 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -723,12 +723,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let hir::FnDecl { inputs, output, .. } = fn_ptr_ty.decl;
 
         let inputs_str =
-            inputs.iter().map(|ty| rustc_hir_pretty::ty_to_string(&self.tcx, ty)).join(", ");
+            inputs.iter().map(|ty| rustc_hir_pretty::ty_to_string(self, ty)).join(", ");
 
         let output_str = match output {
             hir::FnRetTy::DefaultReturn(_) => String::new(),
             hir::FnRetTy::Return(ty) => {
-                format!(" -> {}", rustc_hir_pretty::ty_to_string(&self.tcx, ty))
+                format!(" -> {}", rustc_hir_pretty::ty_to_string(self, ty))
             }
         };
 
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index c67b8f7cdaf5c..d20d8375fc228 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -478,134 +478,138 @@ impl<'tcx> EnclosingBreakables<'tcx> {
         }
     }
 }
-
-fn report_unexpected_variant_res(
-    tcx: TyCtxt<'_>,
-    res: Res,
-    expr: Option<&hir::Expr<'_>>,
-    sub_pats: &[hir::Pat<'_>],
-    qpath: &hir::QPath<'_>,
-    span: Span,
-    err_code: ErrCode,
-    expected: &str,
-) -> ErrorGuaranteed {
-    let res_descr = match res {
-        Res::Def(DefKind::Variant, _) => "struct variant",
-        _ => res.descr(),
-    };
-    let path_str = rustc_hir_pretty::qpath_to_string(&tcx, qpath);
-    let mut err = tcx
-        .dcx()
-        .struct_span_err(span, format!("expected {expected}, found {res_descr} `{path_str}`"))
-        .with_code(err_code);
-    match res {
-        Res::Def(DefKind::Fn | DefKind::AssocFn, _) if err_code == E0164 => {
-            let patterns_url = "https://doc.rust-lang.org/book/ch19-00-patterns.html";
-            err.with_span_label(span, "`fn` calls are not allowed in patterns")
-                .with_help(format!("for more information, visit {patterns_url}"))
-        }
-        Res::Def(DefKind::Variant, _) if let Some(expr) = expr => {
-            err.span_label(span, format!("not a {expected}"));
-            let variant = tcx.expect_variant_res(res);
-            let sugg = if variant.fields.is_empty() {
-                " {}".to_string()
-            } else {
-                format!(
-                    " {{ {} }}",
-                    variant
-                        .fields
-                        .iter()
-                        .map(|f| format!("{}: /* value */", f.name))
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                )
-            };
-            let descr = "you might have meant to create a new value of the struct";
-            let mut suggestion = vec![];
-            match tcx.parent_hir_node(expr.hir_id) {
-                hir::Node::Expr(hir::Expr {
-                    kind: hir::ExprKind::Call(..),
-                    span: call_span,
-                    ..
-                }) => {
-                    suggestion.push((span.shrink_to_hi().with_hi(call_span.hi()), sugg));
-                }
-                hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Binary(..), hir_id, .. }) => {
-                    suggestion.push((expr.span.shrink_to_lo(), "(".to_string()));
-                    if let hir::Node::Expr(parent) = tcx.parent_hir_node(*hir_id)
-                        && let hir::ExprKind::If(condition, block, None) = parent.kind
-                        && condition.hir_id == *hir_id
-                        && let hir::ExprKind::Block(block, _) = block.kind
-                        && block.stmts.is_empty()
-                        && let Some(expr) = block.expr
-                        && let hir::ExprKind::Path(..) = expr.kind
-                    {
-                        // Special case: you can incorrectly write an equality condition:
-                        // if foo == Struct { field } { /* if body */ }
-                        // which should have been written
-                        // if foo == (Struct { field }) { /* if body */ }
-                        suggestion.push((block.span.shrink_to_hi(), ")".to_string()));
-                    } else {
-                        suggestion.push((span.shrink_to_hi().with_hi(expr.span.hi()), sugg));
+impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
+    fn report_unexpected_variant_res(
+        &self,
+        res: Res,
+        expr: Option<&hir::Expr<'_>>,
+        sub_pats: &[hir::Pat<'_>],
+        qpath: &hir::QPath<'_>,
+        span: Span,
+        err_code: ErrCode,
+        expected: &str,
+    ) -> ErrorGuaranteed {
+        let tcx = self.tcx;
+        let res_descr = match res {
+            Res::Def(DefKind::Variant, _) => "struct variant",
+            _ => res.descr(),
+        };
+        let path_str = rustc_hir_pretty::qpath_to_string(self, qpath);
+        let mut err = tcx
+            .dcx()
+            .struct_span_err(span, format!("expected {expected}, found {res_descr} `{path_str}`"))
+            .with_code(err_code);
+        match res {
+            Res::Def(DefKind::Fn | DefKind::AssocFn, _) if err_code == E0164 => {
+                let patterns_url = "https://doc.rust-lang.org/book/ch19-00-patterns.html";
+                err.with_span_label(span, "`fn` calls are not allowed in patterns")
+                    .with_help(format!("for more information, visit {patterns_url}"))
+            }
+            Res::Def(DefKind::Variant, _) if let Some(expr) = expr => {
+                err.span_label(span, format!("not a {expected}"));
+                let variant = tcx.expect_variant_res(res);
+                let sugg = if variant.fields.is_empty() {
+                    " {}".to_string()
+                } else {
+                    format!(
+                        " {{ {} }}",
+                        variant
+                            .fields
+                            .iter()
+                            .map(|f| format!("{}: /* value */", f.name))
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    )
+                };
+                let descr = "you might have meant to create a new value of the struct";
+                let mut suggestion = vec![];
+                match tcx.parent_hir_node(expr.hir_id) {
+                    hir::Node::Expr(hir::Expr {
+                        kind: hir::ExprKind::Call(..),
+                        span: call_span,
+                        ..
+                    }) => {
+                        suggestion.push((span.shrink_to_hi().with_hi(call_span.hi()), sugg));
+                    }
+                    hir::Node::Expr(hir::Expr {
+                        kind: hir::ExprKind::Binary(..), hir_id, ..
+                    }) => {
+                        suggestion.push((expr.span.shrink_to_lo(), "(".to_string()));
+                        if let hir::Node::Expr(parent) = tcx.parent_hir_node(*hir_id)
+                            && let hir::ExprKind::If(condition, block, None) = parent.kind
+                            && condition.hir_id == *hir_id
+                            && let hir::ExprKind::Block(block, _) = block.kind
+                            && block.stmts.is_empty()
+                            && let Some(expr) = block.expr
+                            && let hir::ExprKind::Path(..) = expr.kind
+                        {
+                            // Special case: you can incorrectly write an equality condition:
+                            // if foo == Struct { field } { /* if body */ }
+                            // which should have been written
+                            // if foo == (Struct { field }) { /* if body */ }
+                            suggestion.push((block.span.shrink_to_hi(), ")".to_string()));
+                        } else {
+                            suggestion.push((span.shrink_to_hi().with_hi(expr.span.hi()), sugg));
+                        }
+                    }
+                    _ => {
+                        suggestion.push((span.shrink_to_hi(), sugg));
                     }
                 }
-                _ => {
-                    suggestion.push((span.shrink_to_hi(), sugg));
-                }
+
+                err.multipart_suggestion(descr, suggestion, Applicability::HasPlaceholders);
+                err
             }
+            Res::Def(DefKind::Variant, _) if expr.is_none() => {
+                err.span_label(span, format!("not a {expected}"));
 
-            err.multipart_suggestion(descr, suggestion, Applicability::HasPlaceholders);
-            err
-        }
-        Res::Def(DefKind::Variant, _) if expr.is_none() => {
-            err.span_label(span, format!("not a {expected}"));
-
-            let fields = &tcx.expect_variant_res(res).fields.raw;
-            let span = qpath.span().shrink_to_hi().to(span.shrink_to_hi());
-            let (msg, sugg) = if fields.is_empty() {
-                ("use the struct variant pattern syntax", " {}".to_string())
-            } else {
-                let msg = if fields.is_empty() {
-                    "use struct variant pattern syntax"
+                let fields = &tcx.expect_variant_res(res).fields.raw;
+                let span = qpath.span().shrink_to_hi().to(span.shrink_to_hi());
+                let (msg, sugg) = if fields.is_empty() {
+                    ("use the struct variant pattern syntax", " {}".to_string())
                 } else {
-                    "add the names to match a struct variant's fields"
+                    let msg = if fields.is_empty() {
+                        "use struct variant pattern syntax"
+                    } else {
+                        "add the names to match a struct variant's fields"
+                    };
+                    let fields_sugg = fields
+                        .iter()
+                        .enumerate()
+                        .map(|(i, field)| {
+                            let field_name = field.ident(tcx).to_string();
+
+                            let pat_snippet = sub_pats
+                                .get(i)
+                                .and_then(|sub_pat| {
+                                    tcx.sess.source_map().span_to_snippet(sub_pat.span).ok()
+                                })
+                                .unwrap_or_else(|| "_".to_string());
+
+                            if field_name == pat_snippet {
+                                field_name
+                            } else {
+                                format!("{field_name}: {pat_snippet}")
+                            }
+                        })
+                        .collect::<Vec<_>>()
+                        .join(", ");
+                    let sugg = format!(" {{ {} }}", fields_sugg);
+                    (msg, sugg)
                 };
-                let fields_sugg = fields
-                    .iter()
-                    .enumerate()
-                    .map(|(i, field)| {
-                        let field_name = field.ident(tcx).to_string();
-
-                        let pat_snippet = sub_pats
-                            .get(i)
-                            .and_then(|sub_pat| {
-                                tcx.sess.source_map().span_to_snippet(sub_pat.span).ok()
-                            })
-                            .unwrap_or_else(|| "_".to_string());
-
-                        if field_name == pat_snippet {
-                            field_name
-                        } else {
-                            format!("{field_name}: {pat_snippet}")
-                        }
-                    })
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                let sugg = format!(" {{ {} }}", fields_sugg);
-                (msg, sugg)
-            };
-
-            err.span_suggestion_verbose(
-                qpath.span().shrink_to_hi().to(span.shrink_to_hi()),
-                msg,
-                sugg,
-                Applicability::HasPlaceholders,
-            );
-            err
+
+                err.span_suggestion_verbose(
+                    qpath.span().shrink_to_hi().to(span.shrink_to_hi()),
+                    msg,
+                    sugg,
+                    Applicability::HasPlaceholders,
+                );
+                err
+            }
+            _ => err.with_span_label(span, format!("not a {expected}")),
         }
-        _ => err.with_span_label(span, format!("not a {expected}")),
+        .emit()
     }
-    .emit()
 }
 
 /// Controls whether all arguments are tupled. This is used for the call operator only.
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index 52602b8041d66..01c48c0ae790c 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -32,7 +32,6 @@ use tracing::{debug, instrument, trace};
 use ty::VariantDef;
 use ty::adjustment::{PatAdjust, PatAdjustment};
 
-use super::report_unexpected_variant_res;
 use crate::expectation::Expectation;
 use crate::gather_locals::DeclOrigin;
 use crate::{FnCtxt, diagnostics};
@@ -1585,8 +1584,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
             Res::Def(DefKind::AssocFn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::Variant, _) => {
                 let expected = "unit struct, unit variant or constant";
-                let e = report_unexpected_variant_res(
-                    tcx,
+                let e = self.report_unexpected_variant_res(
                     res,
                     None,
                     &[],
@@ -1604,8 +1602,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 {
                     // Ok, we allow unit struct ctors in patterns only.
                 } else {
-                    let e = report_unexpected_variant_res(
-                        tcx,
+                    let e = self.report_unexpected_variant_res(
                         res,
                         None,
                         &[],
@@ -1775,8 +1772,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 hir::PatKind::TupleStruct(_, sub_pats, _) => sub_pats,
                 _ => &[],
             };
-            let e = report_unexpected_variant_res(
-                tcx, res, None, sub_pats, qpath, pat.span, E0164, expected,
+            let e = self.report_unexpected_variant_res(
+                res, None, sub_pats, qpath, pat.span, E0164, expected,
             );
             Err(e)
         };
@@ -2237,7 +2234,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         {
             let has_shorthand_field_name = field_patterns.iter().any(|field| field.is_shorthand);
             if has_shorthand_field_name {
-                let path = rustc_hir_pretty::qpath_to_string(&self.tcx, qpath);
+                let path = rustc_hir_pretty::qpath_to_string(self, qpath);
                 let mut err = struct_span_code_err!(
                     self.dcx(),
                     pat.span,
@@ -2422,7 +2419,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // we don't care to report errors for a struct if the struct itself is tainted
             variant.has_errors()?;
 
-            let path = rustc_hir_pretty::qpath_to_string(&self.tcx, qpath);
+            let path = rustc_hir_pretty::qpath_to_string(self, qpath);
             let mut err = struct_span_code_err!(
                 self.dcx(),
                 pat.span,
@@ -2472,7 +2469,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             f
                         }
                     }
-                    Err(_) => rustc_hir_pretty::pat_to_string(&self.tcx, field.pat),
+                    Err(_) => rustc_hir_pretty::pat_to_string(self, field.pat),
                 }
             })
             .collect::<Vec<String>>()
diff --git a/compiler/rustc_middle/Cargo.toml b/compiler/rustc_middle/Cargo.toml
index f624fcee78f59..55608083d3751 100644
--- a/compiler/rustc_middle/Cargo.toml
+++ b/compiler/rustc_middle/Cargo.toml
@@ -22,7 +22,6 @@ rustc_feature = { path = "../rustc_feature" }
 rustc_graphviz = { path = "../rustc_graphviz" }
 rustc_hashes = { path = "../rustc_hashes" }
 rustc_hir = { path = "../rustc_hir" }
-rustc_hir_pretty = { path = "../rustc_hir_pretty" }
 rustc_index = { path = "../rustc_index" }
 rustc_lint_defs = { path = "../rustc_lint_defs" }
 rustc_macros = { path = "../rustc_macros" }
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index c01d9e98e9b9c..8ec27921a5787 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -15,7 +15,6 @@ use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::lints::DelayedLints;
 use rustc_hir::*;
-use rustc_hir_pretty as pprust_hir;
 use rustc_span::def_id::{CRATE_MOD_ID, StableCrateId};
 use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol, kw, with_metavar_spans};
 
@@ -1156,12 +1155,6 @@ impl<'tcx> intravisit::HirTyCtxt<'tcx> for TyCtxt<'tcx> {
     }
 }
 
-impl<'tcx> pprust_hir::PpAnn for TyCtxt<'tcx> {
-    fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) {
-        pprust_hir::PpAnn::nested(&(self as &dyn intravisit::HirTyCtxt<'_>), state, nested)
-    }
-}
-
 pub(super) fn crate_hash(tcx: TyCtxt<'_>, _: LocalCrate) -> Svh {
     let krate = tcx.hir_crate_items(());
     let upstream_crates = upstream_crates(tcx);
diff --git a/compiler/rustc_public_bridge/src/context/impls.rs b/compiler/rustc_public_bridge/src/context/impls.rs
index 4a2fbb8f8b7af..f648a85249dfc 100644
--- a/compiler/rustc_public_bridge/src/context/impls.rs
+++ b/compiler/rustc_public_bridge/src/context/impls.rs
@@ -52,6 +52,16 @@ impl<'tcx, B: Bridge> AllocRangeHelpers<'tcx> for CompilerCtxt<'tcx, B> {
     }
 }
 
+impl<'tcx, B: Bridge> rustc_hir_pretty::PpAnn for CompilerCtxt<'tcx, B> {
+    fn nested(&self, state: &mut rustc_hir_pretty::State<'_>, nested: rustc_hir_pretty::Nested) {
+        rustc_hir_pretty::PpAnn::nested(
+            &(&self.tcx as &dyn rustc_hir::intravisit::HirTyCtxt<'_>),
+            state,
+            nested,
+        )
+    }
+}
+
 impl<'tcx, B: Bridge> CompilerCtxt<'tcx, B> {
     pub fn lift<T: ty::Lift<TyCtxt<'tcx>>>(&self, value: T) -> T::Lifted {
         self.tcx.lift(value)
@@ -295,7 +305,7 @@ impl<'tcx, B: Bridge> CompilerCtxt<'tcx, B> {
             .get_attrs_by_path(def_id, &attr_name)
             .filter_map(|attribute| {
                 if let Attribute::Unparsed(u) = attribute {
-                    let attr_str = rustc_hir_pretty::attribute_to_string(&self.tcx, attribute);
+                    let attr_str = rustc_hir_pretty::attribute_to_string(self, attribute);
                     Some((attr_str, u.span))
                 } else {
                     None
@@ -314,7 +324,7 @@ impl<'tcx, B: Bridge> CompilerCtxt<'tcx, B> {
         attrs_iter
             .filter_map(|attribute| {
                 if let Attribute::Unparsed(u) = attribute {
-                    let attr_str = rustc_hir_pretty::attribute_to_string(&self.tcx, attribute);
+                    let attr_str = rustc_hir_pretty::attribute_to_string(self, attribute);
                     Some((attr_str, u.span))
                 } else {
                     None
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index 7e46b2f593e49..eb382f368905f 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -12,7 +12,8 @@ use rustc_hir::attrs::{
 };
 use rustc_hir::def::{CtorKind, DefKind};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{HeaderSafety, Safety, find_attr};
+use rustc_hir::{HeaderSafety, Safety, find_attr, intravisit};
+use rustc_hir_pretty::PpAnn;
 use rustc_metadata::rendered_const;
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::{bug, ty};
@@ -1243,7 +1244,10 @@ fn maybe_from_hir_attr(attr: &hir::Attribute, item_id: ItemId, tcx: TyCtxt<'_>)
 }
 
 fn other_attr(tcx: TyCtxt<'_>, attr: &hir::Attribute) -> Attribute {
-    let mut s = rustc_hir_pretty::attribute_to_string(&tcx, attr);
+    let mut s = rustc_hir_pretty::attribute_to_string(
+        &(&tcx as &dyn intravisit::HirTyCtxt<'_>) as &dyn PpAnn,
+        attr,
+    );
     assert_eq!(s.pop(), Some('\n'));
     Attribute::Other(s)
 }
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs b/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs
index e38ba801c0bf7..9fc9f9944465c 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -6,6 +6,7 @@ use clippy_utils::{is_in_const_context, is_wild, peel_blocks_with_stmt};
 use rustc_hir::{Arm, Expr, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::{kw, sym};
+use rustc_hir::intravisit;
 
 use super::MATCH_WILD_ERR_ARM;
 
@@ -19,7 +20,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'
     if ex_ty.is_diag_item(cx, sym::Result) {
         for arm in arms {
             if let PatKind::TupleStruct(ref path, inner, _) = arm.pat.kind {
-                let path_str = rustc_hir_pretty::qpath_to_string(&cx.tcx, path);
+                let path_str = rustc_hir_pretty::qpath_to_string(#[allow(trivial_casts)] &(&cx.tcx as &dyn intravisit::HirTyCtxt<'_>), path);
                 if path_str == "Err" {
                     let mut matching_wild = inner.iter().any(is_wild);
                     let mut ident_bind_name = kw::Underscore;
diff --git a/src/tools/clippy/clippy_lints/src/unnecessary_mut_passed.rs b/src/tools/clippy/clippy_lints/src/unnecessary_mut_passed.rs
index 60a6688927ab5..43721fa252837 100644
--- a/src/tools/clippy/clippy_lints/src/unnecessary_mut_passed.rs
+++ b/src/tools/clippy/clippy_lints/src/unnecessary_mut_passed.rs
@@ -6,6 +6,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::declare_lint_pass;
 use std::iter;
+use rustc_hir_pretty::PpAnn;
+use rustc_hir::intravisit;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -51,7 +53,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
                         cx,
                         &mut arguments.iter(),
                         cx.typeck_results().expr_ty(fn_expr),
-                        &rustc_hir_pretty::qpath_to_string(&cx.tcx, path),
+                        #[allow(trivial_casts)]
+                        &rustc_hir_pretty::qpath_to_string(&(&cx.tcx as &dyn intravisit::HirTyCtxt<'_>) as &dyn PpAnn, path),
                         "function",
                     );
                 }

From 18e0dd9aa8993a19e332fd080904a72270d18a0d Mon Sep 17 00:00:00 2001
From: Joao Roberto <dnreikronos2@gmail.com>
Date: Tue, 4 Aug 2026 15:31:15 -0300
Subject: [PATCH 09/13] Document zero-sized autodiff slice handling

Clarify that slice-tail layout checks apply to the sized prefix rather
than the slice element, and cover zero-sized slice elements in the
type-tree run-make test.
---
 compiler/rustc_middle/src/ty/typetree.rs            |  6 ++++--
 .../autodiff/type-trees/slice-dst-typetree/rmake.rs |  1 +
 .../type-trees/slice-dst-typetree/slice-dst.check   |  5 +++++
 .../autodiff/type-trees/slice-dst-typetree/test.rs  | 13 +++++++++++++
 4 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/typetree.rs b/compiler/rustc_middle/src/ty/typetree.rs
index 90fb0316fe39b..100c3170e12a9 100644
--- a/compiler/rustc_middle/src/ty/typetree.rs
+++ b/compiler/rustc_middle/src/ty/typetree.rs
@@ -66,14 +66,16 @@ fn handle_indirection<'a>(
     // LLVM arguments, while its child describes the memory reached through `data`.
     let typing_env = ty::TypingEnv::fully_monomorphized();
     if let ty::Slice(element_ty) = tcx.struct_tail_for_codegen(inner_ty, typing_env).kind() {
+        // `layout.size` here is the sized prefix of `inner_ty`, not the slice element size.
+        // Direct slices, transparent wrappers (`OsStr`), and ZST-prefixed DSTs have no byte
+        // offset to preserve. Nonzero prefixes (e.g. `Header<[f32]>`) keep field offsets.
+        // ZST elements still take this path and yield an empty child TypeTree (size 0).
         let child = if tcx
             .layout_of(typing_env.as_query_input(inner_ty))
             .is_ok_and(|layout| layout.size.bytes() == 0)
         {
-            // Direct slices and transparent wrappers such as `OsStr` contain elements everywhere.
             typetree_from_ty_impl_inner(tcx, *element_ty, depth + 1, visited, false)
         } else {
-            // Preserve field offsets for a sized prefix before the slice tail.
             typetree_from_ty_impl_inner(tcx, inner_ty, depth + 1, visited, true)
         };
         return TypeTree(vec![Type {
diff --git a/tests/run-make/autodiff/type-trees/slice-dst-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/slice-dst-typetree/rmake.rs
index c19202fa41fe5..e0c8c87ca9e33 100644
--- a/tests/run-make/autodiff/type-trees/slice-dst-typetree/rmake.rs
+++ b/tests/run-make/autodiff/type-trees/slice-dst-typetree/rmake.rs
@@ -15,4 +15,5 @@ fn main() {
     let ir = rfs::read("test.ll");
     llvm_filecheck().patterns("slice-dst.check").check_prefix("OSSTR").stdin_buf(&ir).run();
     llvm_filecheck().patterns("slice-dst.check").check_prefix("HEADER").stdin_buf(&ir).run();
+    llvm_filecheck().patterns("slice-dst.check").check_prefix("ZST").stdin_buf(&ir).run();
 }
diff --git a/tests/run-make/autodiff/type-trees/slice-dst-typetree/slice-dst.check b/tests/run-make/autodiff/type-trees/slice-dst-typetree/slice-dst.check
index 6031b728213ae..4b149c9ee090c 100644
--- a/tests/run-make/autodiff/type-trees/slice-dst-typetree/slice-dst.check
+++ b/tests/run-make/autodiff/type-trees/slice-dst-typetree/slice-dst.check
@@ -7,3 +7,8 @@ OSSTR: call void @llvm.memcpy{{.*}}"enzyme_type"="{[0]:Pointer, [0,0]:Pointer, [
 HEADER-LABEL: define{{.*}}@header_sum(
 HEADER-SAME: ptr{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@float, [-1,4]:Float@float}"
 HEADER-SAME: i64 "enzyme_type"="{[0]:Integer}"
+
+; ZST elements produce no child metadata under the slice data pointer.
+ZST-LABEL: define{{.*}}@zst_slice_len(
+ZST-SAME: ptr{{.*}}"enzyme_type"="{[-1]:Pointer}"
+ZST-SAME: i64 "enzyme_type"="{[0]:Integer}"
diff --git a/tests/run-make/autodiff/type-trees/slice-dst-typetree/test.rs b/tests/run-make/autodiff/type-trees/slice-dst-typetree/test.rs
index 8cd4d7b57f270..e34a8c71f4cc5 100644
--- a/tests/run-make/autodiff/type-trees/slice-dst-typetree/test.rs
+++ b/tests/run-make/autodiff/type-trees/slice-dst-typetree/test.rs
@@ -36,3 +36,16 @@ pub fn header_sum(value: &Header<[f32]>) -> f32 {
 pub fn exercise_header_sum(value: &Header<[f32]>, derivative: &mut Header<[f32]>) -> f32 {
     d_header_sum(value, derivative, 1.0)
 }
+
+// ZST slice elements yield an empty child TypeTree; element size 0 is expected.
+#[autodiff_reverse(d_zst_slice_len, Duplicated, Active)]
+#[no_mangle]
+#[inline(never)]
+pub fn zst_slice_len(slice: &[()]) -> f32 {
+    slice.len() as f32
+}
+
+#[no_mangle]
+pub fn exercise_zst_slice_len(slice: &[()], derivative: &mut [()]) -> f32 {
+    d_zst_slice_len(slice, derivative, 1.0)
+}

From 679481475548fc354e162809e4c64591423c66ef Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Mon, 3 Aug 2026 22:52:37 +0000
Subject: [PATCH 10/13] Add some tests for specialization.

---
 tests/crashes/{126268.rs => 102252-2.rs}      |   5 +-
 tests/crashes/125014.rs                       |  17 ---
 ...associated-types-in-default-impl-bounds.rs |  18 +++
 ...efault-assoc-type-recursion-issue-80700.rs |  35 +++++
 ...ault-impl-coherence-overlap-issue-77026.rs |  27 ++++
 ...-impl-coherence-overlap-issue-77026.stderr |  12 ++
 ...efault-impl-not-a-candidate-issue-48515.rs |  64 +++++++++
 ...lt-impl-not-a-candidate-issue-48515.stderr |  63 +++++++++
 .../default-impl-not-an-impl.rs               |  71 ++++++++++
 .../default-impl-not-an-impl.stderr           |  69 ++++++++++
 .../default-impl-partial-and-inherits.rs      | 111 +++++++++++++++
 .../default-type-normalize-issue-50318.rs     |  24 ++++
 .../default-type-normalize-issue-50318.stderr |  18 +++
 ...lf-projection-ice-issue-125014.next.stderr |  66 +++++++++
 ...t-type-self-projection-ice-issue-125014.rs |  27 ++++
 .../spec-influences-inference-issue-36262.rs  | 128 ++++++++++++++++++
 ...specialized-impl-projection-issue-32483.rs |  27 ++++
 .../trait-alias-specialization-issue-74809.rs |  44 ++++++
 18 files changed, 808 insertions(+), 18 deletions(-)
 rename tests/crashes/{126268.rs => 102252-2.rs} (86%)
 delete mode 100644 tests/crashes/125014.rs
 create mode 100644 tests/ui/specialization/associated-types-in-default-impl-bounds.rs
 create mode 100644 tests/ui/specialization/default-assoc-type-recursion-issue-80700.rs
 create mode 100644 tests/ui/specialization/default-impl-coherence-overlap-issue-77026.rs
 create mode 100644 tests/ui/specialization/default-impl-coherence-overlap-issue-77026.stderr
 create mode 100644 tests/ui/specialization/default-impl-not-a-candidate-issue-48515.rs
 create mode 100644 tests/ui/specialization/default-impl-not-a-candidate-issue-48515.stderr
 create mode 100644 tests/ui/specialization/default-impl-not-an-impl.rs
 create mode 100644 tests/ui/specialization/default-impl-not-an-impl.stderr
 create mode 100644 tests/ui/specialization/default-impl-partial-and-inherits.rs
 create mode 100644 tests/ui/specialization/default-type-normalize-issue-50318.rs
 create mode 100644 tests/ui/specialization/default-type-normalize-issue-50318.stderr
 create mode 100644 tests/ui/specialization/default-type-self-projection-ice-issue-125014.next.stderr
 create mode 100644 tests/ui/specialization/default-type-self-projection-ice-issue-125014.rs
 create mode 100644 tests/ui/specialization/spec-influences-inference-issue-36262.rs
 create mode 100644 tests/ui/specialization/specialized-impl-projection-issue-32483.rs
 create mode 100644 tests/ui/specialization/trait-alias-specialization-issue-74809.rs

diff --git a/tests/crashes/126268.rs b/tests/crashes/102252-2.rs
similarity index 86%
rename from tests/crashes/126268.rs
rename to tests/crashes/102252-2.rs
index 82e52fa115dc9..ccb15b82736e2 100644
--- a/tests/crashes/126268.rs
+++ b/tests/crashes/102252-2.rs
@@ -1,4 +1,5 @@
-//@ known-bug: #126268
+//@ known-bug: #102252
+
 #![feature(min_specialization)]
 
 trait Trait {}
@@ -16,3 +17,5 @@ struct DatasetIter<'a, R: Data> {
 pub struct ArrayBase {}
 
 impl<'a> Trait for DatasetIter<'a, ArrayBase> {}
+
+fn main() {}
diff --git a/tests/crashes/125014.rs b/tests/crashes/125014.rs
deleted file mode 100644
index b29042ee5983a..0000000000000
--- a/tests/crashes/125014.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ known-bug: rust-lang/rust#125014
-//@ compile-flags: -Znext-solver=coherence
-#![feature(specialization)]
-
-trait Foo {}
-
-impl Foo for <u16 as Assoc>::Output {}
-
-impl Foo for u32 {}
-
-trait Assoc {
-    type Output;
-}
-impl Output for u32 {}
-impl Assoc for <u16 as Assoc>::Output {
-    default type Output = bool;
-}
diff --git a/tests/ui/specialization/associated-types-in-default-impl-bounds.rs b/tests/ui/specialization/associated-types-in-default-impl-bounds.rs
new file mode 100644
index 0000000000000..ea7188810db07
--- /dev/null
+++ b/tests/ui/specialization/associated-types-in-default-impl-bounds.rs
@@ -0,0 +1,18 @@
+//@ check-pass
+
+#![allow(incomplete_features)]
+#![feature(specialization)]
+
+// Tests that you can use a trait's associated types in the bounds of a default impl.
+// Regression test for #52396.
+
+trait Foo {
+    type Baz;
+    fn bar(&self, _: Self::Baz);
+}
+
+default impl<A: Foo<Baz = isize>> Foo for A {
+    fn bar(&self, _: isize) { }
+}
+
+fn main() {}
diff --git a/tests/ui/specialization/default-assoc-type-recursion-issue-80700.rs b/tests/ui/specialization/default-assoc-type-recursion-issue-80700.rs
new file mode 100644
index 0000000000000..e013610121efe
--- /dev/null
+++ b/tests/ui/specialization/default-assoc-type-recursion-issue-80700.rs
@@ -0,0 +1,35 @@
+//@ check-pass
+
+#![feature(specialization)]
+#![allow(incomplete_features)]
+
+// Tests that a blanket impl supplying a `default type` does not make a
+// recursive trait requirement diverge.
+// Regression test for #80700.
+
+use std::marker::PhantomData;
+
+struct Nil;
+struct Cons<Head, Tail>(PhantomData<(Head, Tail)>);
+struct Error;
+
+trait GetLast {
+    type Output;
+}
+
+impl<T> GetLast for T {
+    default type Output = Error;
+}
+
+impl<Head> GetLast for Cons<Head, Nil> {
+    type Output = Nil;
+}
+
+impl<Head, Head2, Tail2> GetLast for Cons<Head, Cons<Head2, Tail2>>
+where
+    Cons<Head2, Tail2>: GetLast,
+{
+    type Output = <Cons<Head2, Tail2> as GetLast>::Output;
+}
+
+fn main() {}
diff --git a/tests/ui/specialization/default-impl-coherence-overlap-issue-77026.rs b/tests/ui/specialization/default-impl-coherence-overlap-issue-77026.rs
new file mode 100644
index 0000000000000..6d610805608af
--- /dev/null
+++ b/tests/ui/specialization/default-impl-coherence-overlap-issue-77026.rs
@@ -0,0 +1,27 @@
+//@ check-fail
+
+#![feature(specialization)]
+#![allow(incomplete_features)]
+
+// `default impl` still participates in coherence. However, we shouldn't get an overflow here.
+// Regresion test for #77026.
+
+pub enum Either<L, R> {
+    Left(L),
+    Right(R),
+}
+
+default impl<L, R> From<L> for Either<L, R> {
+    fn from(l: L) -> Self {
+        Either::Left(l)
+    }
+}
+
+impl<L, R> From<R> for Either<L, R> {
+    //~^ ERROR conflicting implementations of trait `From<_>` for type `Either<_, _>`
+    fn from(r: R) -> Self {
+        Either::Right(r)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/specialization/default-impl-coherence-overlap-issue-77026.stderr b/tests/ui/specialization/default-impl-coherence-overlap-issue-77026.stderr
new file mode 100644
index 0000000000000..c9b30bf2f6495
--- /dev/null
+++ b/tests/ui/specialization/default-impl-coherence-overlap-issue-77026.stderr
@@ -0,0 +1,12 @@
+error[E0119]: conflicting implementations of trait `From<_>` for type `Either<_, _>`
+  --> $DIR/default-impl-coherence-overlap-issue-77026.rs:20:1
+   |
+LL | default impl<L, R> From<L> for Either<L, R> {
+   | ------------------------------------------- first implementation here
+...
+LL | impl<L, R> From<R> for Either<L, R> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Either<_, _>`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/default-impl-not-a-candidate-issue-48515.rs b/tests/ui/specialization/default-impl-not-a-candidate-issue-48515.rs
new file mode 100644
index 0000000000000..4e31dcf117daa
--- /dev/null
+++ b/tests/ui/specialization/default-impl-not-a-candidate-issue-48515.rs
@@ -0,0 +1,64 @@
+//@ check-fail
+
+#![feature(specialization)]
+#![allow(incomplete_features)]
+
+// Tests that we don't overflow when using `default impl`.
+// Regression test for #48515, #98478, and #117909.
+
+// #48515
+
+trait TypeString {
+    fn type_string() -> &'static str;
+}
+
+default impl<T> TypeString for T {
+    fn type_string() -> &'static str {
+        "unknown type"
+    }
+}
+
+impl TypeString for () {
+    fn type_string() -> &'static str {
+        "()"
+    }
+}
+
+// #98478
+
+trait Spam {}
+
+trait SpamMore: Spam {}
+
+default impl<T> Spam for T where T: SpamMore {}
+
+struct A;
+
+impl SpamMore for A {}
+//~^ ERROR the trait bound `A: Spam` is not satisfied
+
+fn needs_spam<T: Spam>() {}
+
+// #117909
+
+trait Set<T> {
+    fn contains(&self, bit: T);
+}
+
+default impl<T, S> Set<&T> for S
+where
+    S: Set<T>,
+{
+    fn contains(&self, _: &T) {}
+}
+
+fn main() {
+    let _ = <usize as TypeString>::type_string();
+    //~^ ERROR the trait bound `usize: TypeString` is not satisfied
+
+    needs_spam::<A>();
+    //~^ ERROR the trait bound `A: Spam` is not satisfied
+
+    0u32.contains(());
+    //~^ ERROR no method named `contains` found for type `u32` in the current scope
+}
diff --git a/tests/ui/specialization/default-impl-not-a-candidate-issue-48515.stderr b/tests/ui/specialization/default-impl-not-a-candidate-issue-48515.stderr
new file mode 100644
index 0000000000000..91df5005d7095
--- /dev/null
+++ b/tests/ui/specialization/default-impl-not-a-candidate-issue-48515.stderr
@@ -0,0 +1,63 @@
+error[E0277]: the trait bound `A: Spam` is not satisfied
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:37:19
+   |
+LL | impl SpamMore for A {}
+   |                   ^ unsatisfied trait bound
+   |
+help: the trait `Spam` is not implemented for `A`
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:35:1
+   |
+LL | struct A;
+   | ^^^^^^^^
+note: required by a bound in `SpamMore`
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:31:17
+   |
+LL | trait SpamMore: Spam {}
+   |                 ^^^^ required by this bound in `SpamMore`
+
+error[E0277]: the trait bound `usize: TypeString` is not satisfied
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:56:14
+   |
+LL |     let _ = <usize as TypeString>::type_string();
+   |              ^^^^^ the trait `TypeString` is not implemented for `usize`
+   |
+help: the trait `TypeString` is implemented for `()`
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:21:1
+   |
+LL | impl TypeString for () {
+   | ^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `A: Spam` is not satisfied
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:59:18
+   |
+LL |     needs_spam::<A>();
+   |                  ^ unsatisfied trait bound
+   |
+help: the trait `Spam` is not implemented for `A`
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:35:1
+   |
+LL | struct A;
+   | ^^^^^^^^
+note: required by a bound in `needs_spam`
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:40:18
+   |
+LL | fn needs_spam<T: Spam>() {}
+   |                  ^^^^ required by this bound in `needs_spam`
+
+error[E0599]: no method named `contains` found for type `u32` in the current scope
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:62:10
+   |
+LL |     0u32.contains(());
+   |          ^^^^^^^^ method not found in `u32`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `Set` defines an item `contains`, perhaps you need to implement it
+  --> $DIR/default-impl-not-a-candidate-issue-48515.rs:44:1
+   |
+LL | trait Set<T> {
+   | ^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0277, E0599.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/default-impl-not-an-impl.rs b/tests/ui/specialization/default-impl-not-an-impl.rs
new file mode 100644
index 0000000000000..2b0902173158e
--- /dev/null
+++ b/tests/ui/specialization/default-impl-not-an-impl.rs
@@ -0,0 +1,71 @@
+//@ check-fail
+
+#![feature(specialization)]
+#![allow(incomplete_features)]
+
+// Tests that a `default impl` does not count as an *actual* impl, so it cannot
+// be used to satisfy trait bounds.
+
+// A `default impl` may omit trait items, but a real impl may not.
+
+trait Gapped {
+    fn a(&self) -> u32;
+    fn b(&self) -> u32;
+}
+
+default impl<T> Gapped for T {
+    fn a(&self) -> u32 {
+        1
+    }
+}
+
+impl Gapped for u8 {}
+//~^ ERROR not all trait items implemented, missing: `b`
+
+// A `default impl` that defines *every* trait item is still not an impl.
+
+trait Foo {
+    fn f(&self) -> u32;
+}
+
+default impl<T> Foo for T {
+    fn f(&self) -> u32 {
+        1
+    }
+}
+
+fn need_foo<T: Foo>(t: &T) -> u32 {
+    t.f()
+}
+
+trait Bar {
+    fn b(&self) -> u32;
+}
+
+impl<T: Foo> Bar for T {
+    fn b(&self) -> u32 {
+        self.f()
+    }
+}
+
+fn need_bar<T: Bar>(t: &T) -> u32 {
+    t.b()
+}
+
+fn main() {
+    // as a bound (UFCS `<u32 as Foo>::f` is the same trait-selection path, omitted)
+    need_foo(&0u32);
+    //~^ ERROR the trait bound `u32: Foo` is not satisfied
+
+    // as a method-probe candidate
+    0u32.f();
+    //~^ ERROR no method named `f` found for type `u32` in the current scope
+
+    // when building a vtable
+    let _: &dyn Foo = &0u32;
+    //~^ ERROR the trait bound `u32: Foo` is not satisfied
+
+    // transitively, as another impl's where-clause
+    need_bar(&0i64);
+    //~^ ERROR the trait bound `i64: Bar` is not satisfied
+}
diff --git a/tests/ui/specialization/default-impl-not-an-impl.stderr b/tests/ui/specialization/default-impl-not-an-impl.stderr
new file mode 100644
index 0000000000000..cde757b3f98a7
--- /dev/null
+++ b/tests/ui/specialization/default-impl-not-an-impl.stderr
@@ -0,0 +1,69 @@
+error[E0046]: not all trait items implemented, missing: `b`
+  --> $DIR/default-impl-not-an-impl.rs:22:1
+   |
+LL |     fn b(&self) -> u32;
+   |     ------------------- `b` from trait
+...
+LL | impl Gapped for u8 {}
+   | ^^^^^^^^^^^^^^^^^^ missing `b` in implementation
+
+error[E0277]: the trait bound `u32: Foo` is not satisfied
+  --> $DIR/default-impl-not-an-impl.rs:57:14
+   |
+LL |     need_foo(&0u32);
+   |     -------- ^^^^^ the trait `Foo` is not implemented for `u32`
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `need_foo`
+  --> $DIR/default-impl-not-an-impl.rs:37:16
+   |
+LL | fn need_foo<T: Foo>(t: &T) -> u32 {
+   |                ^^^ required by this bound in `need_foo`
+
+error[E0599]: no method named `f` found for type `u32` in the current scope
+  --> $DIR/default-impl-not-an-impl.rs:61:10
+   |
+LL |     0u32.f();
+   |          ^ method not found in `u32`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `Foo` defines an item `f`, perhaps you need to implement it
+  --> $DIR/default-impl-not-an-impl.rs:27:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^
+
+error[E0277]: the trait bound `u32: Foo` is not satisfied
+  --> $DIR/default-impl-not-an-impl.rs:65:23
+   |
+LL |     let _: &dyn Foo = &0u32;
+   |                       ^^^^^ the trait `Foo` is not implemented for `u32`
+   |
+   = note: required for the cast from `&u32` to `&dyn Foo`
+
+error[E0277]: the trait bound `i64: Bar` is not satisfied
+  --> $DIR/default-impl-not-an-impl.rs:69:14
+   |
+LL |     need_bar(&0i64);
+   |     -------- ^^^^^ the trait `Foo` is not implemented for `i64`
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required for `i64` to implement `Bar`
+  --> $DIR/default-impl-not-an-impl.rs:45:14
+   |
+LL | impl<T: Foo> Bar for T {
+   |         ---  ^^^     ^
+   |         |
+   |         unsatisfied trait bound introduced here
+note: required by a bound in `need_bar`
+  --> $DIR/default-impl-not-an-impl.rs:51:16
+   |
+LL | fn need_bar<T: Bar>(t: &T) -> u32 {
+   |                ^^^ required by this bound in `need_bar`
+
+error: aborting due to 5 previous errors
+
+Some errors have detailed explanations: E0046, E0277, E0599.
+For more information about an error, try `rustc --explain E0046`.
diff --git a/tests/ui/specialization/default-impl-partial-and-inherits.rs b/tests/ui/specialization/default-impl-partial-and-inherits.rs
new file mode 100644
index 0000000000000..a2c622daafb08
--- /dev/null
+++ b/tests/ui/specialization/default-impl-partial-and-inherits.rs
@@ -0,0 +1,111 @@
+//@ run-pass
+
+#![feature(specialization)]
+#![allow(incomplete_features)]
+
+// Tests that a `default impl` does not need all items, but does contribute to
+// the chain of specialization.
+
+// A partial `default impl` at each level of a 3-level chain.
+
+trait Foo {
+    type Assoc;
+    const N: u32;
+    fn from_root(&self) -> &'static str;
+    fn from_mid(&self) -> &'static str;
+    fn from_leaf(&self) -> &'static str;
+    fn from_trait(&self) -> &'static str {
+        "trait body"
+    }
+}
+
+// root: assoc type, assoc const, one method
+default impl<T> Foo for T {
+    type Assoc = u8;
+    const N: u32 = 1;
+    fn from_root(&self) -> &'static str {
+        "root"
+    }
+}
+
+// middle: one method
+default impl<T: Copy> Foo for T {
+    fn from_mid(&self) -> &'static str {
+        "mid"
+    }
+}
+
+// leaf: one method. Everything else must come from the two ancestors, except
+// `from_trait`, which no impl in the chain defines.
+impl Foo for u32 {
+    fn from_leaf(&self) -> &'static str {
+        "leaf"
+    }
+}
+
+// sibling leaf: overrides every inherited item, including assoc type and const
+impl Foo for i8 {
+    type Assoc = bool;
+    const N: u32 = 2;
+    fn from_root(&self) -> &'static str {
+        "i8 root"
+    }
+    fn from_mid(&self) -> &'static str {
+        "i8 mid"
+    }
+    fn from_leaf(&self) -> &'static str {
+        "i8 leaf"
+    }
+    fn from_trait(&self) -> &'static str {
+        "i8 trait"
+    }
+}
+
+fn generic<T: Foo>(t: &T) -> [&'static str; 4] {
+    [t.from_root(), t.from_mid(), t.from_leaf(), t.from_trait()]
+}
+
+// An empty `default impl`, and an empty real impl that inherits every item.
+
+trait Marker {
+    type A;
+    fn m(&self) -> &'static str;
+}
+
+// Contributes nothing at all, and is still accepted.
+default impl<T> Marker for T {}
+
+// Covers every item of the trait.
+default impl<T: Copy> Marker for T {
+    type A = u8;
+    fn m(&self) -> &'static str {
+        "from default impl"
+    }
+}
+
+// Declaration of intent and nothing else. This is what the `default impl` above
+// is missing, and the only thing it is missing.
+impl Marker for u32 {}
+
+fn main() {
+    // inherited across the chain, via a concrete receiver...
+    assert_eq!(0u32.from_root(), "root");
+    assert_eq!(0u32.from_mid(), "mid");
+    assert_eq!(0u32.from_leaf(), "leaf");
+    assert_eq!(0u32.from_trait(), "trait body");
+    assert_eq!(<u32 as Foo>::N, 1);
+    // The omitting impl finalizes the ancestor's definition, so this normalizes.
+    let _: <u32 as Foo>::Assoc = 0u8;
+
+    // ...and through a generic bound
+    assert_eq!(generic(&0u32), ["root", "mid", "leaf", "trait body"]);
+    assert_eq!(generic(&0i8), ["i8 root", "i8 mid", "i8 leaf", "i8 trait"]);
+    assert_eq!(<i8 as Foo>::N, 2);
+    let _: <i8 as Foo>::Assoc = true;
+
+    // empty impl really does implement: method, projection, and vtable
+    assert_eq!(0u32.m(), "from default impl");
+    let _: <u32 as Marker>::A = 0u8;
+    let _: &dyn Marker<A = u8> = &0u32;
+
+}
diff --git a/tests/ui/specialization/default-type-normalize-issue-50318.rs b/tests/ui/specialization/default-type-normalize-issue-50318.rs
new file mode 100644
index 0000000000000..b69acfe47a929
--- /dev/null
+++ b/tests/ui/specialization/default-type-normalize-issue-50318.rs
@@ -0,0 +1,24 @@
+//@ check-fail
+//@ known-bug: #50318
+
+#![feature(specialization)]
+#![allow(incomplete_features)]
+
+// Tests that we can normalize a `default type`.
+
+trait Trait {
+    type AssocType;
+}
+
+struct Struct {}
+
+impl Trait for Struct {
+    default type AssocType = i32;
+}
+
+type AssocType = <Struct as Trait>::AssocType;
+
+fn main() {
+    assert_eq!(std::any::type_name::<AssocType>(), "i32");
+    let x: AssocType = 0;
+}
diff --git a/tests/ui/specialization/default-type-normalize-issue-50318.stderr b/tests/ui/specialization/default-type-normalize-issue-50318.stderr
new file mode 100644
index 0000000000000..b0d69287adac2
--- /dev/null
+++ b/tests/ui/specialization/default-type-normalize-issue-50318.stderr
@@ -0,0 +1,18 @@
+error[E0308]: mismatched types
+  --> $DIR/default-type-normalize-issue-50318.rs:23:24
+   |
+LL |     let x: AssocType = 0;
+   |            ---------   ^ expected associated type, found integer
+   |            |
+   |            expected due to this
+   |
+   = note: expected associated type `<Struct as Trait>::AssocType`
+                         found type `{integer}`
+   = help: consider constraining the associated type `<Struct as Trait>::AssocType` to `{integer}` or calling a method that returns `<Struct as Trait>::AssocType`
+   = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
+   = note: the associated type `<Struct as Trait>::AssocType` is defined as `{integer}` in the implementation, but the where-bound `Struct` shadows this definition
+           see issue #152409 <https://github.com/rust-lang/rust/issues/152409> for more information
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/specialization/default-type-self-projection-ice-issue-125014.next.stderr b/tests/ui/specialization/default-type-self-projection-ice-issue-125014.next.stderr
new file mode 100644
index 0000000000000..7280c8213e5dd
--- /dev/null
+++ b/tests/ui/specialization/default-type-self-projection-ice-issue-125014.next.stderr
@@ -0,0 +1,66 @@
+error[E0277]: the trait bound `u16: A` is not satisfied
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:18:12
+   |
+LL | impl A for <u16 as A>::B {
+   |            ^^^^^^^^^^^^^ the trait `A` is not implemented for `u16`
+   |
+help: the trait `A` is implemented for `<u16 as A>::B`
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:18:1
+   |
+LL | impl A for <u16 as A>::B {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `u16: A` is not satisfied
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:18:12
+   |
+LL | impl A for <u16 as A>::B {
+   |            ^^^^^^^^^^^^^ the trait `A` is not implemented for `u16`
+   |
+help: the trait `A` is implemented for `<u16 as A>::B`
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:18:1
+   |
+LL | impl A for <u16 as A>::B {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0277]: the trait bound `u16: A` is not satisfied
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:23:22
+   |
+LL |     default type B = ();
+   |                      ^^ the trait `A` is not implemented for `u16`
+   |
+help: the trait `A` is implemented for `<u16 as A>::B`
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:18:1
+   |
+LL | impl A for <u16 as A>::B {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `u16: A` is not satisfied
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:18:12
+   |
+LL | impl A for <u16 as A>::B {
+   |            ^^^^^^^^^^^^^ the trait `A` is not implemented for `u16`
+   |
+help: the trait `A` is implemented for `<u16 as A>::B`
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:18:1
+   |
+LL | impl A for <u16 as A>::B {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0277]: the trait bound `u16: A` is not satisfied
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:18:12
+   |
+LL | impl A for <u16 as A>::B {
+   |            ^^^^^^^^^^^^^ the trait `A` is not implemented for `u16`
+   |
+help: the trait `A` is implemented for `<u16 as A>::B`
+  --> $DIR/default-type-self-projection-ice-issue-125014.rs:18:1
+   |
+LL | impl A for <u16 as A>::B {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/default-type-self-projection-ice-issue-125014.rs b/tests/ui/specialization/default-type-self-projection-ice-issue-125014.rs
new file mode 100644
index 0000000000000..9b4e3eade03b6
--- /dev/null
+++ b/tests/ui/specialization/default-type-self-projection-ice-issue-125014.rs
@@ -0,0 +1,27 @@
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+//@[current] known-bug: #125014
+//@[current] failure-status: 101
+//@[current] dont-check-compiler-stderr
+
+// Tests that we don't ICE when a `default type` is potentially used as a self-type in an impl.
+// Regression for #125014.
+
+#![feature(specialization)]
+#![allow(incomplete_features)]
+
+trait A {
+    type B;
+}
+
+impl A for <u16 as A>::B {
+    //[next]~^ ERROR the trait bound `u16: A` is not satisfied
+    //[next]~^^ ERROR the trait bound `u16: A` is not satisfied
+    //[next]~^^^ ERROR the trait bound `u16: A` is not satisfied
+    //[next]~^^^^ ERROR the trait bound `u16: A` is not satisfied
+    default type B = ();
+    //[next]~^ ERROR the trait bound `u16: A` is not satisfied
+}
+
+fn main() {}
diff --git a/tests/ui/specialization/spec-influences-inference-issue-36262.rs b/tests/ui/specialization/spec-influences-inference-issue-36262.rs
new file mode 100644
index 0000000000000..1e96fd5065097
--- /dev/null
+++ b/tests/ui/specialization/spec-influences-inference-issue-36262.rs
@@ -0,0 +1,128 @@
+//@ edition: 2021
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+//@[next] check-pass
+//@[current] known-bug: #36262
+//@[current] dont-check-compiler-stderr
+
+// Tests that specialization does not leak into type inference.
+// Regression for #36262 and duplicate issues.
+
+#![feature(specialization)]
+#![allow(incomplete_features)]
+
+// Site 1: the receiver's type parameter, observed through a return position (#36262).
+mod receiver_return {
+    struct My<T>(T);
+
+    trait Conv<T> {
+        fn conv(self) -> T;
+    }
+
+    impl<T> Conv<T> for My<T> {
+        default fn conv(self) -> T {
+            self.0
+        }
+    }
+
+    impl Conv<u32> for My<u32> {
+        fn conv(self) -> u32 {
+            self.0
+        }
+    }
+
+    fn use_it() {
+        // Should infer `i32`; the sole `My<u32>` impl steers it to `u32`.
+        let x = My(0);
+        let _ = x.conv() + 0i32;
+    }
+}
+
+// Site 2: a method argument's trait type parameter (#91973, #38516, #67918).
+mod method_arg {
+    struct Foo;
+
+    trait Bar<T> {
+        fn bar(&self, _: T);
+    }
+
+    impl<T> Bar<T> for Foo {
+        default fn bar(&self, _: T) {}
+    }
+
+    impl Bar<bool> for Foo {
+        fn bar(&self, _: bool) {}
+    }
+
+    fn use_it() {
+        // Should infer `{integer}`; the sole `Bar<bool>` impl steers it to `bool`.
+        Foo.bar(42);
+    }
+}
+
+// Site 3: an explicit `_` in a UFCS trait reference (#40718).
+mod ufcs_infer {
+    use std::vec;
+
+    struct Foo<T>(T);
+
+    impl<T> Foo<T> {
+        fn build<I: IntoIterator<Item = T>>(it: I) -> Foo<T> {
+            // The second argument should infer to `I::IntoIter`; the sole
+            // `vec::IntoIter<T>` impl steers it there.
+            <Self as SpecExtend<_, _>>::from_iter(it.into_iter())
+        }
+    }
+
+    trait SpecExtend<T, I> {
+        fn from_iter(iter: I) -> Self;
+    }
+
+    impl<T, I> SpecExtend<T, I> for Foo<T>
+    where
+        I: Iterator<Item = T>,
+    {
+        default fn from_iter(_: I) -> Self {
+            panic!()
+        }
+    }
+
+    impl<T> SpecExtend<T, vec::IntoIter<T>> for Foo<T> {
+        fn from_iter(_: vec::IntoIter<T>) -> Self {
+            panic!()
+        }
+    }
+}
+
+// Site 4: an operator, where the sole specialization is derive-generated (#55243).
+mod derived_specializer {
+    use std::borrow::Borrow;
+
+    #[derive(PartialEq)]
+    struct MyString(String);
+
+    impl Borrow<str> for MyString {
+        fn borrow(&self) -> &str {
+            &self.0
+        }
+    }
+
+    impl<Rhs> PartialEq<Rhs> for MyString
+    where
+        Rhs: ?Sized + Borrow<str>,
+    {
+        default fn eq(&self, rhs: &Rhs) -> bool {
+            self.0 == rhs.borrow()
+        }
+    }
+
+    fn use_it() {
+        // Should select `PartialEq<str>`; the derived `PartialEq<MyString>` is the
+        // sole specialization and inference commits `Rhs = MyString`.
+        let s = MyString(String::from("Hello, world!"));
+        let _ = s == "Hello, world!";
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/specialization/specialized-impl-projection-issue-32483.rs b/tests/ui/specialization/specialized-impl-projection-issue-32483.rs
new file mode 100644
index 0000000000000..5b26679422a40
--- /dev/null
+++ b/tests/ui/specialization/specialized-impl-projection-issue-32483.rs
@@ -0,0 +1,27 @@
+//@ check-pass
+
+#![allow(incomplete_features)]
+#![feature(specialization)]
+
+// Tests that we allow some projections in specialized impls.
+// Regression test for issue #32483.
+
+pub trait Foo {
+    type TypeA;
+    type TypeB: Bar<Self::TypeA>;
+}
+
+pub trait Bar<T> {
+}
+
+pub struct ImplsBar;
+impl<T> Bar<T> for ImplsBar {
+}
+
+impl<T> Foo for T {
+    type TypeA = u8;
+    // WF checking `TypeB` here requires us to project `Self::TypeA`
+    default type TypeB = ImplsBar;
+}
+
+fn main() {}
diff --git a/tests/ui/specialization/trait-alias-specialization-issue-74809.rs b/tests/ui/specialization/trait-alias-specialization-issue-74809.rs
new file mode 100644
index 0000000000000..e62532e8ab033
--- /dev/null
+++ b/tests/ui/specialization/trait-alias-specialization-issue-74809.rs
@@ -0,0 +1,44 @@
+//@ check-pass
+
+#![feature(specialization)]
+#![feature(trait_alias)]
+#![allow(incomplete_features)]
+
+// Tests that we can specialize on a trait alias.
+// Regression test for #74809.
+
+pub trait Marker1<T> {}
+pub trait Marker2 {}
+
+pub trait CombinedMarker<T> = Marker1<T> + Marker2;
+
+pub struct Container<T, U> {
+    p: std::marker::PhantomData<(T, U)>,
+}
+
+pub struct Struct;
+impl<T> Marker1<T> for Struct {}
+
+pub trait Trait {
+    fn do_thing(&self);
+}
+
+impl<T, U: Marker1<T>> Trait for Container<T, U> {
+    default fn do_thing(&self) {
+        println!("default behavior");
+    }
+}
+
+impl<T, U: CombinedMarker<T>> Trait for Container<T, U> {
+    default fn do_thing(&self) {
+        println!("partially specialized behavior");
+    }
+}
+
+impl<T> Trait for Container<T, Struct> {
+    fn do_thing(&self) {
+        println!("fully specialized behavior")
+    }
+}
+
+fn main() {}

From 228bbb36ad155d5fbd2d1f783742a4c7ecd2e0c5 Mon Sep 17 00:00:00 2001
From: Jamie Hill-Daniel <jamie@osec.io>
Date: Tue, 4 Aug 2026 20:11:32 +0100
Subject: [PATCH 11/13] fix(bootstrap): Normalize the names of proc macro
 dependency crates

---
 src/bootstrap/src/utils/proc_macro_deps.rs | 56 +++++++++++-----------
 src/tools/tidy/src/deps.rs                 | 11 ++++-
 2 files changed, 37 insertions(+), 30 deletions(-)

diff --git a/src/bootstrap/src/utils/proc_macro_deps.rs b/src/bootstrap/src/utils/proc_macro_deps.rs
index 8e91f95e18f3f..02d8fe41f5869 100644
--- a/src/bootstrap/src/utils/proc_macro_deps.rs
+++ b/src/bootstrap/src/utils/proc_macro_deps.rs
@@ -6,46 +6,46 @@ pub static CRATES: &[&str] = &[
     "anyhow",
     "askama_derive",
     "askama_parser",
-    "basic-toml",
+    "basic_toml",
     "bitflags",
-    "block-buffer",
+    "block_buffer",
     "bumpalo",
-    "cfg-if",
+    "cfg_if",
     "cpufeatures",
-    "crypto-common",
+    "crypto_common",
     "darling",
     "darling_core",
     "derive_builder_core",
     "digest",
     "equivalent",
-    "fluent-bundle",
-    "fluent-langneg",
-    "fluent-syntax",
+    "fluent_bundle",
+    "fluent_langneg",
+    "fluent_syntax",
     "fnv",
     "foldhash",
-    "generic-array",
+    "generic_array",
     "glob",
     "hashbrown",
     "heck",
-    "id-arena",
+    "id_arena",
     "ident_case",
     "indexmap",
-    "intl-memoizer",
+    "intl_memoizer",
     "intl_pluralrules",
     "itoa",
     "leb128fmt",
     "libc",
     "log",
     "memchr",
-    "minimal-lexical",
+    "minimal_lexical",
     "nom",
     "pest",
     "pest_generator",
     "pest_meta",
     "prettyplease",
-    "proc-macro2",
+    "proc_macro2",
     "quote",
-    "rustc-hash",
+    "rustc_hash",
     "ryu",
     "self_cell",
     "semver",
@@ -61,25 +61,25 @@ pub static CRATES: &[&str] = &[
     "synstructure",
     "thiserror",
     "tinystr",
-    "type-map",
+    "type_map",
     "typenum",
-    "ucd-trie",
-    "unic-langid",
-    "unic-langid-impl",
-    "unic-langid-macros",
-    "unicode-ident",
-    "unicode-xid",
+    "ucd_trie",
+    "unic_langid",
+    "unic_langid_impl",
+    "unic_langid_macros",
+    "unicode_ident",
+    "unicode_xid",
     "version_check",
-    "wasm-bindgen-macro-support",
-    "wasm-bindgen-shared",
-    "wasm-encoder",
-    "wasm-metadata",
+    "wasm_bindgen_macro_support",
+    "wasm_bindgen_shared",
+    "wasm_encoder",
+    "wasm_metadata",
     "wasmparser",
     "winnow",
-    "wit-bindgen-core",
-    "wit-bindgen-rust",
-    "wit-component",
-    "wit-parser",
+    "wit_bindgen_core",
+    "wit_bindgen_rust",
+    "wit_component",
+    "wit_parser",
     "yoke",
     "zerofrom",
     "zerovec",
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 479199414d7ec..734ca79518090 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -719,8 +719,15 @@ fn check_proc_macro_dep_list(root: &Path, cargo: &Path, bless: bool, check: &mut
     // Remove the proc-macro crates themselves
     proc_macro_deps.retain(|pkg| !is_proc_macro_pkg(&metadata[pkg]));
     // Sort and deduplicate the crate names.
-    let proc_macro_deps =
-        proc_macro_deps.into_iter().map(|dep| metadata[dep].name.as_ref()).collect::<BTreeSet<_>>();
+    // Cargo package names may contain `-`, but will normalize these to `_` before passing to rustc.
+    // As bootstrap parses the `--crate-name` flag, use the name of the actual lib target which has
+    // been normalized.
+    let proc_macro_deps = proc_macro_deps
+        .into_iter()
+        .filter_map(|dep| {
+            metadata[dep].targets.iter().find_map(|target| target.is_lib().then_some(&target.name))
+        })
+        .collect::<BTreeSet<_>>();
 
     let expected = {
         use std::fmt::Write;

From a6dfd0cc18614a4232d0e533539bad9981a49efd Mon Sep 17 00:00:00 2001
From: derek-homel <jewboi896@gmail.com>
Date: Tue, 4 Aug 2026 19:02:23 -0400
Subject: [PATCH 12/13] docs: fix typo in AllowExprMetavar comment

Fixes a small typo in the documentation comment for AllowExprMetavar.
Changes decrarative to `declarative`.

Change in compiler/rustc_attr_parsing/src/parser.rs: Line 492
---
 compiler/rustc_attr_parsing/src/parser.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
index c4b2a5b509051..76587ba9f0ead 100644
--- a/compiler/rustc_attr_parsing/src/parser.rs
+++ b/compiler/rustc_attr_parsing/src/parser.rs
@@ -489,7 +489,7 @@ fn expr_to_lit<'sess>(
     }
 }
 
-/// Whether expansions of `expr` metavariables from decrarative macros
+/// Whether expansions of `expr` metavariables from declarative  macros
 /// are permitted. Used when parsing meta items; currently, only `cfg` predicates
 /// enable this option
 #[derive(Clone, Copy, PartialEq, Eq)]

From eace512093ce4d96afcb7352f595bb72f1ba6bb8 Mon Sep 17 00:00:00 2001
From: YingqiDuan <141370165+YingqiDuan@users.noreply.github.com>
Date: Wed, 5 Aug 2026 05:31:06 +0000
Subject: [PATCH 13/13] Suggest cast_signed for overflowing integer literals

Co-authored-by: Roland Xu <rcu@live.com>
---
 compiler/rustc_lint/src/lints.rs              | 39 +++++++++++++------
 compiler/rustc_lint/src/types/literal.rs      | 26 +++++++++----
 .../no-inline-literals-out-of-range.stderr    |  9 +++--
 tests/ui/lint/type-overflow.stderr            | 14 ++++---
 4 files changed, 59 insertions(+), 29 deletions(-)

diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index bff3b79df8655..07279a04b0c8c 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -2030,18 +2030,33 @@ pub(crate) enum OverflowingBinHexSub<'a> {
 }
 
 #[derive(Subdiagnostic)]
-#[suggestion(
-    "to use as a negative number (decimal `{$negative_val}`), consider using the type `{$uint_ty}` for the literal and cast it to `{$int_ty}`",
-    code = "{lit_no_suffix}{uint_ty} as {int_ty}",
-    applicability = "maybe-incorrect"
-)]
-pub(crate) struct OverflowingBinHexSignBitSub<'a> {
-    #[primary_span]
-    pub span: Span,
-    pub lit_no_suffix: &'a str,
-    pub negative_val: String,
-    pub uint_ty: &'a str,
-    pub int_ty: &'a str,
+pub(crate) enum OverflowingBinHexSignBitSub<'a> {
+    #[suggestion(
+        "to use as a negative number (decimal `{$negative_val}`), consider using the type `{$uint_ty}` for the literal and cast it to `{$int_ty}`",
+        code = "{lit_no_suffix}{uint_ty}.cast_signed()",
+        applicability = "maybe-incorrect"
+    )]
+    CastSigned {
+        #[primary_span]
+        span: Span,
+        lit_no_suffix: &'a str,
+        negative_val: String,
+        uint_ty: &'a str,
+        int_ty: &'a str,
+    },
+    #[suggestion(
+        "to use as a negative number (decimal `{$negative_val}`), consider using the type `{$uint_ty}` for the literal and cast it to `{$int_ty}`",
+        code = "{lit_no_suffix}{uint_ty} as {int_ty}",
+        applicability = "maybe-incorrect"
+    )]
+    AsCast {
+        #[primary_span]
+        span: Span,
+        lit_no_suffix: &'a str,
+        negative_val: String,
+        uint_ty: &'a str,
+        int_ty: &'a str,
+    },
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_lint/src/types/literal.rs b/compiler/rustc_lint/src/types/literal.rs
index bed26ee6f3d25..4759f087ed08b 100644
--- a/compiler/rustc_lint/src/types/literal.rs
+++ b/compiler/rustc_lint/src/types/literal.rs
@@ -205,13 +205,25 @@ fn report_bin_hex_error(
                     &repr_str
                 };
 
-            Some(OverflowingBinHexSignBitSub {
-                span,
-                lit_no_suffix,
-                negative_val: actually,
-                int_ty: int_ty.name_str(),
-                uint_ty: Integer::fit_unsigned(val).uint_ty_str(),
-            })
+            let uint_ty = Integer::fit_unsigned(val);
+            // `cast_signed` only supports equal-width integer casts.
+            if uint_ty.size() == size {
+                Some(OverflowingBinHexSignBitSub::CastSigned {
+                    span,
+                    lit_no_suffix,
+                    negative_val: actually,
+                    uint_ty: uint_ty.uint_ty_str(),
+                    int_ty: int_ty.name_str(),
+                })
+            } else {
+                Some(OverflowingBinHexSignBitSub::AsCast {
+                    span,
+                    lit_no_suffix,
+                    negative_val: actually,
+                    uint_ty: uint_ty.uint_ty_str(),
+                    int_ty: int_ty.name_str(),
+                })
+            }
         })
         .flatten();
 
diff --git a/tests/ui/fmt/no-inline-literals-out-of-range.stderr b/tests/ui/fmt/no-inline-literals-out-of-range.stderr
index 0800fb2497619..744a4e5625fef 100644
--- a/tests/ui/fmt/no-inline-literals-out-of-range.stderr
+++ b/tests/ui/fmt/no-inline-literals-out-of-range.stderr
@@ -13,8 +13,9 @@ LL +     format_args!("{}", 0x8f_u8); // issue #115423
    |
 help: to use as a negative number (decimal `-113`), consider using the type `u8` for the literal and cast it to `i8`
    |
-LL |     format_args!("{}", 0x8f_u8 as i8); // issue #115423
-   |                             +++++
+LL -     format_args!("{}", 0x8f_i8); // issue #115423
+LL +     format_args!("{}", 0x8f_u8.cast_signed()); // issue #115423
+   |
 
 error: literal out of range for `u8`
   --> $DIR/no-inline-literals-out-of-range.rs:6:24
@@ -50,8 +51,8 @@ LL |     format_args!("{}", 0xffff_ffff); // treat unsuffixed literals as i32
    = help: consider using the type `u32` instead
 help: to use as a negative number (decimal `-1`), consider using the type `u32` for the literal and cast it to `i32`
    |
-LL |     format_args!("{}", 0xffff_ffffu32 as i32); // treat unsuffixed literals as i32
-   |                                   ++++++++++
+LL |     format_args!("{}", 0xffff_ffffu32.cast_signed()); // treat unsuffixed literals as i32
+   |                                   +++++++++++++++++
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/lint/type-overflow.stderr b/tests/ui/lint/type-overflow.stderr
index 065c530adcf57..66d856dac3bdf 100644
--- a/tests/ui/lint/type-overflow.stderr
+++ b/tests/ui/lint/type-overflow.stderr
@@ -26,8 +26,9 @@ LL +     let fail = 0b1000_0001u8;
    |
 help: to use as a negative number (decimal `-127`), consider using the type `u8` for the literal and cast it to `i8`
    |
-LL |     let fail = 0b1000_0001u8 as i8;
-   |                           +++++
+LL -     let fail = 0b1000_0001i8;
+LL +     let fail = 0b1000_0001u8.cast_signed();
+   |
 
 warning: literal out of range for `i64`
   --> $DIR/type-overflow.rs:15:16
@@ -43,8 +44,9 @@ LL +     let fail = 0x8000_0000_0000_0000u64;
    |
 help: to use as a negative number (decimal `-9223372036854775808`), consider using the type `u64` for the literal and cast it to `i64`
    |
-LL |     let fail = 0x8000_0000_0000_0000u64 as i64;
-   |                                     ++++++
+LL -     let fail = 0x8000_0000_0000_0000i64;
+LL +     let fail = 0x8000_0000_0000_0000u64.cast_signed();
+   |
 
 warning: literal out of range for `u32`
   --> $DIR/type-overflow.rs:19:16
@@ -64,8 +66,8 @@ LL |     let fail: i128 = 0x8000_0000_0000_0000_0000_0000_0000_0000;
    = help: consider using the type `u128` instead
 help: to use as a negative number (decimal `-170141183460469231731687303715884105728`), consider using the type `u128` for the literal and cast it to `i128`
    |
-LL |     let fail: i128 = 0x8000_0000_0000_0000_0000_0000_0000_0000u128 as i128;
-   |                                                               ++++++++++++
+LL |     let fail: i128 = 0x8000_0000_0000_0000_0000_0000_0000_0000u128.cast_signed();
+   |                                                               ++++++++++++++++++
 
 warning: literal out of range for `i32`
   --> $DIR/type-overflow.rs:27:16