From a0f9a15b4a916c92d51131418e9fe080c83f9d3c Mon Sep 17 00:00:00 2001
From: Andreas Liljeqvist <bonega@gmail.com>
Date: Sat, 17 Jan 2026 11:36:25 +0100
Subject: [PATCH 01/27] Fix is_ascii performance regression on AVX-512 CPUs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When `[u8]::is_ascii()` is compiled with `-C target-cpu=native` on
AVX-512 CPUs, LLVM generates inefficient code. Because `is_ascii` is
marked `#[inline]`, it gets inlined and recompiled with the user's
target settings. The previous implementation used a counting loop that
LLVM auto-vectorizes to `pmovmskb` on SSE2, but with AVX-512 enabled,
LLVM uses k-registers and extracts bits individually with ~31
`kshiftrd` instructions.

This fix replaces the counting loop with explicit SSE2 intrinsics
(`_mm_loadu_si128`, `_mm_or_si128`, `_mm_movemask_epi8`) for x86_64.
`_mm_movemask_epi8` compiles to `pmovmskb`, forcing efficient codegen
regardless of CPU features.

Benchmark results on AMD Ryzen 5 7500F (Zen 4 with AVX-512):
- Default build: ~73 GB/s → ~74 GB/s (no regression)
- With -C target-cpu=native: ~3 GB/s → ~67 GB/s (22x improvement)

The loongarch64 implementation retains the original counting loop
since it doesn't have this issue.

Regression from: https://github.com/rust-lang/rust/pull/130733
---
 library/core/src/slice/ascii.rs              | 86 +++++++++++++++++---
 tests/assembly-llvm/slice-is-ascii-avx512.rs | 18 ++++
 tests/codegen-llvm/slice-is-ascii.rs         |  9 +-
 3 files changed, 98 insertions(+), 15 deletions(-)
 create mode 100644 tests/assembly-llvm/slice-is-ascii-avx512.rs

diff --git a/library/core/src/slice/ascii.rs b/library/core/src/slice/ascii.rs
index 3e8c553f9f159..c9e168d6cbf83 100644
--- a/library/core/src/slice/ascii.rs
+++ b/library/core/src/slice/ascii.rs
@@ -3,10 +3,7 @@
 use core::ascii::EscapeDefault;
 
 use crate::fmt::{self, Write};
-#[cfg(not(any(
-    all(target_arch = "x86_64", target_feature = "sse2"),
-    all(target_arch = "loongarch64", target_feature = "lsx")
-)))]
+#[cfg(not(all(target_arch = "loongarch64", target_feature = "lsx")))]
 use crate::intrinsics::const_eval_select;
 use crate::{ascii, iter, ops};
 
@@ -463,19 +460,84 @@ const fn is_ascii(s: &[u8]) -> bool {
     )
 }
 
-/// ASCII test optimized to use the `pmovmskb` instruction on `x86-64` and the
-/// `vmskltz.b` instruction on `loongarch64`.
+/// SSE2 implementation using `_mm_movemask_epi8` (compiles to `pmovmskb`) to
+/// avoid LLVM's broken AVX-512 auto-vectorization of counting loops.
+///
+/// # Safety
+/// Requires SSE2 support (guaranteed on x86_64).
+#[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
+#[target_feature(enable = "sse2")]
+unsafe fn is_ascii_sse2(bytes: &[u8]) -> bool {
+    use crate::arch::x86_64::{__m128i, _mm_loadu_si128, _mm_movemask_epi8, _mm_or_si128};
+
+    const CHUNK_SIZE: usize = 32;
+
+    let mut i = 0;
+
+    while i + CHUNK_SIZE <= bytes.len() {
+        // SAFETY: We have verified that `i + CHUNK_SIZE <= bytes.len()`.
+        let ptr = unsafe { bytes.as_ptr().add(i) };
+
+        // Load two 16-byte chunks and combine them.
+        // SAFETY: We verified `i + 32 <= len`, so ptr is valid for 32 bytes.
+        // `_mm_loadu_si128` allows unaligned loads.
+        let chunk1 = unsafe { _mm_loadu_si128(ptr as *const __m128i) };
+        // SAFETY: Same as above - ptr.add(16) is within the valid 32-byte range.
+        let chunk2 = unsafe { _mm_loadu_si128(ptr.add(16) as *const __m128i) };
+
+        // OR them together - if any byte has the high bit set, the result will too
+        let combined = _mm_or_si128(chunk1, chunk2);
+
+        // Create a mask from the MSBs of each byte.
+        // If any byte is >= 128, its MSB is 1, so the mask will be non-zero.
+        let mask = _mm_movemask_epi8(combined);
+
+        if mask != 0 {
+            return false;
+        }
+
+        i += CHUNK_SIZE;
+    }
+
+    // Handle remaining bytes with simple loop
+    while i < bytes.len() {
+        if !bytes[i].is_ascii() {
+            return false;
+        }
+        i += 1;
+    }
+
+    true
+}
+
+/// ASCII test optimized to use the `pmovmskb` instruction on `x86-64`.
+///
+/// Uses explicit SSE2 intrinsics to prevent LLVM from auto-vectorizing with
+/// broken AVX-512 code that extracts mask bits one-by-one.
+#[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
+#[inline]
+#[rustc_allow_const_fn_unstable(const_eval_select)]
+const fn is_ascii(bytes: &[u8]) -> bool {
+    const_eval_select!(
+        @capture { bytes: &[u8] } -> bool:
+        if const {
+            is_ascii_simple(bytes)
+        } else {
+            // SAFETY: SSE2 is guaranteed available on x86_64
+            unsafe { is_ascii_sse2(bytes) }
+        }
+    )
+}
+
+/// ASCII test optimized to use the `vmskltz.b` instruction on `loongarch64`.
 ///
 /// Other platforms are not likely to benefit from this code structure, so they
 /// use SWAR techniques to test for ASCII in `usize`-sized chunks.
-#[cfg(any(
-    all(target_arch = "x86_64", target_feature = "sse2"),
-    all(target_arch = "loongarch64", target_feature = "lsx")
-))]
+#[cfg(all(target_arch = "loongarch64", target_feature = "lsx"))]
 #[inline]
 const fn is_ascii(bytes: &[u8]) -> bool {
     // Process chunks of 32 bytes at a time in the fast path to enable
-    // auto-vectorization and use of `pmovmskb`. Two 128-bit vector registers
+    // auto-vectorization and use of `vmskltz.b`. Two 128-bit vector registers
     // can be OR'd together and then the resulting vector can be tested for
     // non-ASCII bytes.
     const CHUNK_SIZE: usize = 32;
@@ -485,7 +547,7 @@ const fn is_ascii(bytes: &[u8]) -> bool {
     while i + CHUNK_SIZE <= bytes.len() {
         let chunk_end = i + CHUNK_SIZE;
 
-        // Get LLVM to produce a `pmovmskb` instruction on x86-64 which
+        // Get LLVM to produce a `vmskltz.b` instruction on loongarch64 which
         // creates a mask from the most significant bit of each byte.
         // ASCII bytes are less than 128 (0x80), so their most significant
         // bit is unset.
diff --git a/tests/assembly-llvm/slice-is-ascii-avx512.rs b/tests/assembly-llvm/slice-is-ascii-avx512.rs
new file mode 100644
index 0000000000000..d3a441fec96cb
--- /dev/null
+++ b/tests/assembly-llvm/slice-is-ascii-avx512.rs
@@ -0,0 +1,18 @@
+//@ only-x86_64
+//@ compile-flags: -C opt-level=3 -C target-cpu=znver4
+//@ compile-flags: -C llvm-args=-x86-asm-syntax=intel
+//@ assembly-output: emit-asm
+#![crate_type = "lib"]
+
+// Verify is_ascii uses pmovmskb/vpmovmskb instead of kshiftrd with AVX-512.
+// The fix uses explicit SSE2 intrinsics to avoid LLVM's broken auto-vectorization.
+//
+// See: https://github.com/rust-lang/rust/issues/129293
+
+// CHECK-LABEL: test_is_ascii
+#[no_mangle]
+pub fn test_is_ascii(s: &[u8]) -> bool {
+    // CHECK-NOT: kshiftrd
+    // CHECK-NOT: kshiftrq
+    s.is_ascii()
+}
diff --git a/tests/codegen-llvm/slice-is-ascii.rs b/tests/codegen-llvm/slice-is-ascii.rs
index 67537c871a0a3..1f41b69e43966 100644
--- a/tests/codegen-llvm/slice-is-ascii.rs
+++ b/tests/codegen-llvm/slice-is-ascii.rs
@@ -1,10 +1,13 @@
-//@ only-x86_64
-//@ compile-flags: -C opt-level=3 -C target-cpu=x86-64
+//@ only-loongarch64
+//@ compile-flags: -C opt-level=3
 #![crate_type = "lib"]
 
-/// Check that the fast-path of `is_ascii` uses a `pmovmskb` instruction.
+/// Check that the fast-path of `is_ascii` uses a `vmskltz.b` instruction.
 /// Platforms lacking an equivalent instruction use other techniques for
 /// optimizing `is_ascii`.
+///
+/// Note: x86_64 uses explicit SSE2 intrinsics instead of relying on
+/// auto-vectorization. See `slice-is-ascii-avx512.rs`.
 // CHECK-LABEL: @is_ascii_autovectorized
 #[no_mangle]
 pub fn is_ascii_autovectorized(s: &[u8]) -> bool {

From 08432c892758a06a6bab9fa0584effb7e7881303 Mon Sep 17 00:00:00 2001
From: Andreas Liljeqvist <bonega@gmail.com>
Date: Sun, 18 Jan 2026 22:49:37 +0100
Subject: [PATCH 02/27] Optimize small input path for is_ascii on x86_64

For inputs smaller than 32 bytes, use usize-at-a-time processing
instead of calling the SSE2 function. This avoids function call
overhead from #[target_feature(enable = "sse2")] which prevents
inlining.

Also moves CHUNK_SIZE to module level so it can be shared between
is_ascii and is_ascii_sse2.
---
 library/core/src/slice/ascii.rs | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/library/core/src/slice/ascii.rs b/library/core/src/slice/ascii.rs
index c9e168d6cbf83..25b8a10af3555 100644
--- a/library/core/src/slice/ascii.rs
+++ b/library/core/src/slice/ascii.rs
@@ -460,6 +460,10 @@ const fn is_ascii(s: &[u8]) -> bool {
     )
 }
 
+/// Chunk size for vectorized ASCII checking (two 16-byte SSE registers).
+#[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
+const CHUNK_SIZE: usize = 32;
+
 /// SSE2 implementation using `_mm_movemask_epi8` (compiles to `pmovmskb`) to
 /// avoid LLVM's broken AVX-512 auto-vectorization of counting loops.
 ///
@@ -470,8 +474,6 @@ const fn is_ascii(s: &[u8]) -> bool {
 unsafe fn is_ascii_sse2(bytes: &[u8]) -> bool {
     use crate::arch::x86_64::{__m128i, _mm_loadu_si128, _mm_movemask_epi8, _mm_or_si128};
 
-    const CHUNK_SIZE: usize = 32;
-
     let mut i = 0;
 
     while i + CHUNK_SIZE <= bytes.len() {
@@ -518,11 +520,27 @@ unsafe fn is_ascii_sse2(bytes: &[u8]) -> bool {
 #[inline]
 #[rustc_allow_const_fn_unstable(const_eval_select)]
 const fn is_ascii(bytes: &[u8]) -> bool {
+    const USIZE_SIZE: usize = size_of::<usize>();
+    const NONASCII_MASK: usize = usize::MAX / 255 * 0x80;
+
     const_eval_select!(
         @capture { bytes: &[u8] } -> bool:
         if const {
             is_ascii_simple(bytes)
         } else {
+            // For small inputs, use usize-at-a-time processing to avoid SSE2 call overhead.
+            if bytes.len() < CHUNK_SIZE {
+                let chunks = bytes.chunks_exact(USIZE_SIZE);
+                let remainder = chunks.remainder();
+                for chunk in chunks {
+                    let word = usize::from_ne_bytes(chunk.try_into().unwrap());
+                    if (word & NONASCII_MASK) != 0 {
+                        return false;
+                    }
+                }
+                return remainder.iter().all(|b| b.is_ascii());
+            }
+
             // SAFETY: SSE2 is guaranteed available on x86_64
             unsafe { is_ascii_sse2(bytes) }
         }

From 03fa11abb4de71301c2fb11299c82a982d373a1c Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 3 Oct 2025 21:35:29 +0000
Subject: [PATCH 03/27] Remove a couple of unnecessary impls

---
 library/proc_macro/src/bridge/client.rs |  6 ------
 library/proc_macro/src/bridge/handle.rs |  8 +-------
 library/proc_macro/src/bridge/server.rs | 11 -----------
 3 files changed, 1 insertion(+), 24 deletions(-)

diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index bdaa865a998d6..48a43a7bac34c 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -52,12 +52,6 @@ macro_rules! define_client_handles {
                 }
             }
 
-            impl<S> Encode<S> for &mut $oty {
-                fn encode(self, w: &mut Writer, s: &mut S) {
-                    self.handle.encode(w, s);
-                }
-            }
-
             impl<S> Decode<'_, '_, S> for $oty {
                 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
                     $oty {
diff --git a/library/proc_macro/src/bridge/handle.rs b/library/proc_macro/src/bridge/handle.rs
index 8c53bb609f60c..f0c01e39de32d 100644
--- a/library/proc_macro/src/bridge/handle.rs
+++ b/library/proc_macro/src/bridge/handle.rs
@@ -3,7 +3,7 @@
 use std::collections::BTreeMap;
 use std::hash::Hash;
 use std::num::NonZero;
-use std::ops::{Index, IndexMut};
+use std::ops::Index;
 use std::sync::atomic::{AtomicU32, Ordering};
 
 use super::fxhash::FxHashMap;
@@ -47,12 +47,6 @@ impl<T> Index<Handle> for OwnedStore<T> {
     }
 }
 
-impl<T> IndexMut<Handle> for OwnedStore<T> {
-    fn index_mut(&mut self, h: Handle) -> &mut T {
-        self.data.get_mut(&h).expect("use-after-free in `proc_macro` handle")
-    }
-}
-
 /// Like `OwnedStore`, but avoids storing any value more than once.
 pub(super) struct InternedStore<T: 'static> {
     owned: OwnedStore<T>,
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index e9ef26c07f24f..27cc5e5d57e33 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -47,17 +47,6 @@ macro_rules! define_server_handles {
                     &s.$oty[handle::Handle::decode(r, &mut ())]
                 }
             }
-
-            impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>
-                for &'s mut Marked<S::$oty, client::$oty>
-            {
-                fn decode(
-                    r: &mut Reader<'_>,
-                    s: &'s mut HandleStore<MarkedTypes<S>>
-                ) -> Self {
-                    &mut s.$oty[handle::Handle::decode(r, &mut ())]
-                }
-            }
         )*
 
         $(

From 8c1e51f8f9c74f93c9c25dd64a8e08a7c6ce6adc Mon Sep 17 00:00:00 2001
From: Brian Cain <brian.cain@oss.qualcomm.com>
Date: Thu, 22 Jan 2026 11:12:13 -0600
Subject: [PATCH 04/27] hexagon: Add HVX target features

This will be used in order to emit HVX intrinsics
---
 compiler/rustc_target/src/target_features.rs | 17 ++++++++++++++++-
 tests/ui/check-cfg/target_feature.stderr     | 15 +++++++++++++++
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 4eba426dda59f..fde7dfcabb701 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -492,7 +492,22 @@ static X86_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
 const HEXAGON_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     // tidy-alphabetical-start
     ("hvx", Unstable(sym::hexagon_target_feature), &[]),
+    ("hvx-ieee-fp", Unstable(sym::hexagon_target_feature), &["hvx"]),
+    ("hvx-length64b", Unstable(sym::hexagon_target_feature), &["hvx"]),
     ("hvx-length128b", Unstable(sym::hexagon_target_feature), &["hvx"]),
+    ("hvx-qfloat", Unstable(sym::hexagon_target_feature), &["hvx"]),
+    ("hvxv60", Unstable(sym::hexagon_target_feature), &["hvx"]),
+    ("hvxv62", Unstable(sym::hexagon_target_feature), &["hvxv60"]),
+    ("hvxv65", Unstable(sym::hexagon_target_feature), &["hvxv62"]),
+    ("hvxv66", Unstable(sym::hexagon_target_feature), &["hvxv65", "zreg"]),
+    ("hvxv67", Unstable(sym::hexagon_target_feature), &["hvxv66"]),
+    ("hvxv68", Unstable(sym::hexagon_target_feature), &["hvxv67"]),
+    ("hvxv69", Unstable(sym::hexagon_target_feature), &["hvxv68"]),
+    ("hvxv71", Unstable(sym::hexagon_target_feature), &["hvxv69"]),
+    ("hvxv73", Unstable(sym::hexagon_target_feature), &["hvxv71"]),
+    ("hvxv75", Unstable(sym::hexagon_target_feature), &["hvxv73"]),
+    ("hvxv79", Unstable(sym::hexagon_target_feature), &["hvxv75"]),
+    ("zreg", Unstable(sym::hexagon_target_feature), &[]),
     // tidy-alphabetical-end
 ];
 
@@ -949,7 +964,7 @@ const SPARC_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'stat
     &[/*(64, "vis")*/];
 
 const HEXAGON_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
-    &[/*(512, "hvx-length64b"),*/ (1024, "hvx-length128b")];
+    &[(512, "hvx-length64b"), (1024, "hvx-length128b")];
 const MIPS_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
     &[(128, "msa")];
 const CSKY_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
diff --git a/tests/ui/check-cfg/target_feature.stderr b/tests/ui/check-cfg/target_feature.stderr
index 6125e66320c8a..89123c9100825 100644
--- a/tests/ui/check-cfg/target_feature.stderr
+++ b/tests/ui/check-cfg/target_feature.stderr
@@ -131,7 +131,21 @@ LL |     cfg!(target_feature = "_UNEXPECTED_VALUE");
 `high-registers`
 `high-word`
 `hvx`
+`hvx-ieee-fp`
 `hvx-length128b`
+`hvx-length64b`
+`hvx-qfloat`
+`hvxv60`
+`hvxv62`
+`hvxv65`
+`hvxv66`
+`hvxv67`
+`hvxv68`
+`hvxv69`
+`hvxv71`
+`hvxv73`
+`hvxv75`
+`hvxv79`
 `hwdiv`
 `i8mm`
 `isa-68000`
@@ -431,6 +445,7 @@ LL |     cfg!(target_feature = "_UNEXPECTED_VALUE");
 `zksed`
 `zksh`
 `zkt`
+`zreg`
 `ztso`
 `zvbb`
 `zvbc`

From c65076a0f0367e5e1cf1e556566b09e9a7f2fff5 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 3 Oct 2025 21:27:26 +0000
Subject: [PATCH 05/27] Handle FreeFunctions outside with_api_handle_types

It is a singleton which doesn't actually need to be passed through over
the bridge.
---
 library/proc_macro/src/bridge/client.rs | 1 +
 library/proc_macro/src/bridge/mod.rs    | 5 +++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index 48a43a7bac34c..e75902eca6bb6 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -120,6 +120,7 @@ impl fmt::Debug for Span {
     }
 }
 
+pub(crate) use super::FreeFunctions;
 pub(crate) use super::symbol::Symbol;
 
 macro_rules! define_client_side {
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index b0ee9c0cc3027..15a81bd5f96f2 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -49,7 +49,6 @@ macro_rules! with_api {
     ($S:ident, $self:ident, $m:ident) => {
         $m! {
             FreeFunctions {
-                fn drop($self: $S::FreeFunctions);
                 fn injected_env_var(var: &str) -> Option<String>;
                 fn track_env_var(var: &str, value: Option<&str>);
                 fn track_path(path: &str);
@@ -109,7 +108,7 @@ macro_rules! with_api_handle_types {
     ($m:ident) => {
         $m! {
             'owned:
-            FreeFunctions,
+            // FreeFunctions is handled manually
             TokenStream,
 
             'interned:
@@ -119,6 +118,8 @@ macro_rules! with_api_handle_types {
     };
 }
 
+pub(crate) struct FreeFunctions;
+
 #[allow(unsafe_code)]
 mod arena;
 #[allow(unsafe_code)]

From 5dd7c0b5aba324bf127e07bf1406926b329b031b Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Wed, 31 Dec 2025 21:49:48 +0000
Subject: [PATCH 06/27] Rationalise the Armv7-A, Armv7-R and Armv8-R bare-metal
 target configs

---
 .../src/spec/targets/armv7a_none_eabi.rs      | 45 +++++--------------
 .../src/spec/targets/armv7a_none_eabihf.rs    | 37 +++++----------
 .../src/spec/targets/armv7r_none_eabi.rs      | 17 ++-----
 .../src/spec/targets/armv7r_none_eabihf.rs    | 17 ++-----
 .../src/spec/targets/armv8r_none_eabihf.rs    | 14 +-----
 5 files changed, 28 insertions(+), 102 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs
index 6b7707a47390a..e8c5c16d8eb5e 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs
@@ -1,40 +1,8 @@
-// Generic ARMv7-A target for bare-metal code - floating point disabled
-//
-// This is basically the `armv7-unknown-linux-gnueabi` target with some changes
-// (listed below) to bring it closer to the bare-metal `thumb` & `aarch64`
-// targets:
-//
-// - `TargetOptions.features`: added `+strict-align`. rationale: unaligned
-// memory access is disabled on boot on these cores
-// - linker changed to LLD. rationale: C is not strictly needed to build
-// bare-metal binaries (the `gcc` linker has the advantage that it knows where C
-// libraries and crt*.o are but it's not much of an advantage here); LLD is also
-// faster
-// - `panic_strategy` set to `abort`. rationale: matches `thumb` targets
-// - `relocation-model` set to `static`; also no PIE, no relro and no dynamic
-// linking. rationale: matches `thumb` targets
+// Targets the Little-endian Cortex-A8 (and similar) processors (ARMv7-A)
 
-use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
-};
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
-    let opts = TargetOptions {
-        abi: Abi::Eabi,
-        llvm_floatabi: Some(FloatAbi::Soft),
-        linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
-        linker: Some("rust-lld".into()),
-        features: "+v7,+thumb2,+soft-float,-neon,+strict-align".into(),
-        relocation_model: RelocModel::Static,
-        disable_redzone: true,
-        max_atomic_width: Some(64),
-        panic_strategy: PanicStrategy::Abort,
-        emit_debug_gdb_scripts: false,
-        c_enum_min_bits: Some(8),
-        has_thumb_interworking: true,
-        ..Default::default()
-    };
     Target {
         llvm_target: "armv7a-none-eabi".into(),
         metadata: TargetMetadata {
@@ -46,6 +14,13 @@ pub(crate) fn target() -> Target {
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
-        options: opts,
+        options: TargetOptions {
+            abi: Abi::Eabi,
+            llvm_floatabi: Some(FloatAbi::Soft),
+            features: "+soft-float,-neon,+strict-align".into(),
+            max_atomic_width: Some(64),
+            has_thumb_interworking: true,
+            ..base::arm_none::opts()
+        },
     }
 }
diff --git a/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs
index 993390543b96d..32a79e346adcf 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs
@@ -1,32 +1,8 @@
-// Generic ARMv7-A target for bare-metal code - floating point enabled (assumes
-// FPU is present and emits FPU instructions)
-//
-// This is basically the `armv7-unknown-linux-gnueabihf` target with some
-// changes (list in `armv7a_none_eabi.rs`) to bring it closer to the bare-metal
-// `thumb` & `aarch64` targets.
+// Targets the Little-endian Cortex-A8 (and similar) processors (ARMv7-A)
 
-use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
-};
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
-    let opts = TargetOptions {
-        abi: Abi::EabiHf,
-        llvm_floatabi: Some(FloatAbi::Hard),
-        linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
-        linker: Some("rust-lld".into()),
-        features: "+v7,+vfp3d16,+thumb2,-neon,+strict-align".into(),
-        relocation_model: RelocModel::Static,
-        disable_redzone: true,
-        max_atomic_width: Some(64),
-        panic_strategy: PanicStrategy::Abort,
-        emit_debug_gdb_scripts: false,
-        // GCC defaults to 8 for arm-none here.
-        c_enum_min_bits: Some(8),
-        has_thumb_interworking: true,
-        ..Default::default()
-    };
     Target {
         llvm_target: "armv7a-none-eabihf".into(),
         metadata: TargetMetadata {
@@ -38,6 +14,13 @@ pub(crate) fn target() -> Target {
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
-        options: opts,
+        options: TargetOptions {
+            abi: Abi::EabiHf,
+            llvm_floatabi: Some(FloatAbi::Hard),
+            features: "+vfp3d16,-neon,+strict-align".into(),
+            max_atomic_width: Some(64),
+            has_thumb_interworking: true,
+            ..base::arm_none::opts()
+        },
     }
 }
diff --git a/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs
index 551cbf4a589fa..114b079f360b7 100644
--- a/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs
@@ -1,15 +1,12 @@
 // Targets the Little-endian Cortex-R4/R5 processor (ARMv7-R)
 
-use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
-};
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
         llvm_target: "armv7r-none-eabi".into(),
         metadata: TargetMetadata {
-            description: Some("Armv7-R".into()),
+            description: Some("Bare Armv7-R".into()),
             tier: Some(2),
             host_tools: Some(false),
             std: Some(false),
@@ -17,20 +14,12 @@ pub(crate) fn target() -> Target {
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
-
         options: TargetOptions {
             abi: Abi::Eabi,
             llvm_floatabi: Some(FloatAbi::Soft),
-            linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
-            linker: Some("rust-lld".into()),
-            relocation_model: RelocModel::Static,
-            panic_strategy: PanicStrategy::Abort,
             max_atomic_width: Some(64),
-            emit_debug_gdb_scripts: false,
-            // GCC defaults to 8 for arm-none here.
-            c_enum_min_bits: Some(8),
             has_thumb_interworking: true,
-            ..Default::default()
+            ..base::arm_none::opts()
         },
     }
 }
diff --git a/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs
index 97c911ec80909..1c6114f9fc83a 100644
--- a/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs
@@ -1,15 +1,12 @@
 // Targets the Little-endian Cortex-R4F/R5F processor (ARMv7-R)
 
-use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
-};
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
         llvm_target: "armv7r-none-eabihf".into(),
         metadata: TargetMetadata {
-            description: Some("Armv7-R, hardfloat".into()),
+            description: Some("Bare Armv7-R, hardfloat".into()),
             tier: Some(2),
             host_tools: Some(false),
             std: Some(false),
@@ -17,21 +14,13 @@ pub(crate) fn target() -> Target {
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
         arch: Arch::Arm,
-
         options: TargetOptions {
             abi: Abi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
-            linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
-            linker: Some("rust-lld".into()),
-            relocation_model: RelocModel::Static,
-            panic_strategy: PanicStrategy::Abort,
             features: "+vfp3d16".into(),
             max_atomic_width: Some(64),
-            emit_debug_gdb_scripts: false,
-            // GCC defaults to 8 for arm-none here.
-            c_enum_min_bits: Some(8),
             has_thumb_interworking: true,
-            ..Default::default()
+            ..base::arm_none::opts()
         },
     }
 }
diff --git a/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs
index e36240b9c2234..16006e4c52cfb 100644
--- a/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs
@@ -1,9 +1,6 @@
 // Targets the Little-endian Cortex-R52 processor (ARMv8-R)
 
-use crate::spec::{
-    Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata,
-    TargetOptions,
-};
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
 
 pub(crate) fn target() -> Target {
     Target {
@@ -21,10 +18,6 @@ pub(crate) fn target() -> Target {
         options: TargetOptions {
             abi: Abi::EabiHf,
             llvm_floatabi: Some(FloatAbi::Hard),
-            linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
-            linker: Some("rust-lld".into()),
-            relocation_model: RelocModel::Static,
-            panic_strategy: PanicStrategy::Abort,
             // Armv8-R requires a minimum set of floating-point features equivalent to:
             // fp-armv8, SP-only, with 16 DP (32 SP) registers
             // LLVM defines Armv8-R to include these features automatically.
@@ -36,11 +29,8 @@ pub(crate) fn target() -> Target {
             // Arm Cortex-R52 Processor Technical Reference Manual
             // - Chapter 15 Advanced SIMD and floating-point support
             max_atomic_width: Some(64),
-            emit_debug_gdb_scripts: false,
-            // GCC defaults to 8 for arm-none here.
-            c_enum_min_bits: Some(8),
             has_thumb_interworking: true,
-            ..Default::default()
+            ..base::arm_none::opts()
         },
     }
 }

From 96647dde7752334ac9a2137ffca9cc4f909ceee8 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Wed, 31 Dec 2025 21:52:36 +0000
Subject: [PATCH 07/27] Add Thumb-mode targets for Armv7-R, Armv7-A and
 Armv8-R.

---
 compiler/rustc_target/src/spec/mod.rs         |  5 +++
 .../src/spec/targets/thumbv7a_none_eabi.rs    | 26 ++++++++++++++
 .../src/spec/targets/thumbv7a_none_eabihf.rs  | 26 ++++++++++++++
 .../src/spec/targets/thumbv7r_none_eabi.rs    | 25 +++++++++++++
 .../src/spec/targets/thumbv7r_none_eabihf.rs  | 26 ++++++++++++++
 .../src/spec/targets/thumbv8r_none_eabihf.rs  | 36 +++++++++++++++++++
 src/bootstrap/src/core/sanity.rs              |  5 +++
 src/doc/rustc/src/platform-support.md         |  9 +++--
 .../src/platform-support/armv7a-none-eabi.md  | 10 +++---
 .../src/platform-support/armv7r-none-eabi.md  |  8 +++--
 .../platform-support/armv8r-none-eabihf.md    | 10 +++---
 tests/assembly-llvm/targets/targets-elf.rs    | 15 ++++++++
 12 files changed, 188 insertions(+), 13 deletions(-)
 create mode 100644 compiler/rustc_target/src/spec/targets/thumbv7a_none_eabi.rs
 create mode 100644 compiler/rustc_target/src/spec/targets/thumbv7a_none_eabihf.rs
 create mode 100644 compiler/rustc_target/src/spec/targets/thumbv7r_none_eabi.rs
 create mode 100644 compiler/rustc_target/src/spec/targets/thumbv7r_none_eabihf.rs
 create mode 100644 compiler/rustc_target/src/spec/targets/thumbv8r_none_eabihf.rs

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index ef475630d4943..c5a7f119118c9 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1596,8 +1596,11 @@ supported_targets! {
     ("armebv7r-none-eabi", armebv7r_none_eabi),
     ("armebv7r-none-eabihf", armebv7r_none_eabihf),
     ("armv7r-none-eabi", armv7r_none_eabi),
+    ("thumbv7r-none-eabi", thumbv7r_none_eabi),
     ("armv7r-none-eabihf", armv7r_none_eabihf),
+    ("thumbv7r-none-eabihf", thumbv7r_none_eabihf),
     ("armv8r-none-eabihf", armv8r_none_eabihf),
+    ("thumbv8r-none-eabihf", thumbv8r_none_eabihf),
 
     ("armv7-rtems-eabihf", armv7_rtems_eabihf),
 
@@ -1649,7 +1652,9 @@ supported_targets! {
     ("thumbv8m.main-none-eabihf", thumbv8m_main_none_eabihf),
 
     ("armv7a-none-eabi", armv7a_none_eabi),
+    ("thumbv7a-none-eabi", thumbv7a_none_eabi),
     ("armv7a-none-eabihf", armv7a_none_eabihf),
+    ("thumbv7a-none-eabihf", thumbv7a_none_eabihf),
     ("armv7a-nuttx-eabi", armv7a_nuttx_eabi),
     ("armv7a-nuttx-eabihf", armv7a_nuttx_eabihf),
     ("armv7a-vex-v5", armv7a_vex_v5),
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabi.rs
new file mode 100644
index 0000000000000..ce11e3f0875c9
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabi.rs
@@ -0,0 +1,26 @@
+// Targets the Little-endian Cortex-A8 (and similar) processors (ARMv7-A)
+
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+
+pub(crate) fn target() -> Target {
+    Target {
+        llvm_target: "thumbv7a-none-eabi".into(),
+        metadata: TargetMetadata {
+            description: Some("Thumb-mode Bare Armv7-A".into()),
+            tier: Some(2),
+            host_tools: Some(false),
+            std: Some(false),
+        },
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
+        arch: Arch::Arm,
+        options: TargetOptions {
+            abi: Abi::Eabi,
+            llvm_floatabi: Some(FloatAbi::Soft),
+            features: "+soft-float,-neon,+strict-align".into(),
+            max_atomic_width: Some(64),
+            has_thumb_interworking: true,
+            ..base::arm_none::opts()
+        },
+    }
+}
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabihf.rs
new file mode 100644
index 0000000000000..12210e9c2b014
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/thumbv7a_none_eabihf.rs
@@ -0,0 +1,26 @@
+// Targets the Little-endian Cortex-A8 (and similar) processors (ARMv7-A)
+
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+
+pub(crate) fn target() -> Target {
+    Target {
+        llvm_target: "thumbv7a-none-eabihf".into(),
+        metadata: TargetMetadata {
+            description: Some("Thumb-mode Bare Armv7-A, hardfloat".into()),
+            tier: Some(2),
+            host_tools: Some(false),
+            std: Some(false),
+        },
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
+        arch: Arch::Arm,
+        options: TargetOptions {
+            abi: Abi::EabiHf,
+            llvm_floatabi: Some(FloatAbi::Hard),
+            features: "+vfp3d16,-neon,+strict-align".into(),
+            max_atomic_width: Some(64),
+            has_thumb_interworking: true,
+            ..base::arm_none::opts()
+        },
+    }
+}
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabi.rs
new file mode 100644
index 0000000000000..bf71d31a06ecf
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabi.rs
@@ -0,0 +1,25 @@
+// Targets the Little-endian Cortex-R4/R5 processor (ARMv7-R)
+
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+
+pub(crate) fn target() -> Target {
+    Target {
+        llvm_target: "thumbv7r-none-eabi".into(),
+        metadata: TargetMetadata {
+            description: Some("Thumb-mode Bare Armv7-R".into()),
+            tier: Some(2),
+            host_tools: Some(false),
+            std: Some(false),
+        },
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
+        arch: Arch::Arm,
+        options: TargetOptions {
+            abi: Abi::Eabi,
+            llvm_floatabi: Some(FloatAbi::Soft),
+            max_atomic_width: Some(64),
+            has_thumb_interworking: true,
+            ..base::arm_none::opts()
+        },
+    }
+}
diff --git a/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabihf.rs
new file mode 100644
index 0000000000000..88b5e67644035
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/thumbv7r_none_eabihf.rs
@@ -0,0 +1,26 @@
+// Targets the Little-endian Cortex-R4F/R5F processor (ARMv7-R)
+
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+
+pub(crate) fn target() -> Target {
+    Target {
+        llvm_target: "thumbv7r-none-eabihf".into(),
+        metadata: TargetMetadata {
+            description: Some("Thumb-mode Bare Armv7-R, hardfloat".into()),
+            tier: Some(2),
+            host_tools: Some(false),
+            std: Some(false),
+        },
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
+        arch: Arch::Arm,
+        options: TargetOptions {
+            abi: Abi::EabiHf,
+            llvm_floatabi: Some(FloatAbi::Hard),
+            features: "+vfp3d16".into(),
+            max_atomic_width: Some(64),
+            has_thumb_interworking: true,
+            ..base::arm_none::opts()
+        },
+    }
+}
diff --git a/compiler/rustc_target/src/spec/targets/thumbv8r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv8r_none_eabihf.rs
new file mode 100644
index 0000000000000..87434cd7353c0
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/thumbv8r_none_eabihf.rs
@@ -0,0 +1,36 @@
+// Targets the Little-endian Cortex-R52 processor (ARMv8-R)
+
+use crate::spec::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base};
+
+pub(crate) fn target() -> Target {
+    Target {
+        llvm_target: "thumbv8r-none-eabihf".into(),
+        metadata: TargetMetadata {
+            description: Some("Thumb-mode Bare Armv8-R, hardfloat".into()),
+            tier: Some(2),
+            host_tools: Some(false),
+            std: Some(false),
+        },
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
+        arch: Arch::Arm,
+
+        options: TargetOptions {
+            abi: Abi::EabiHf,
+            llvm_floatabi: Some(FloatAbi::Hard),
+            // Armv8-R requires a minimum set of floating-point features equivalent to:
+            // fp-armv8, SP-only, with 16 DP (32 SP) registers
+            // LLVM defines Armv8-R to include these features automatically.
+            //
+            // The Cortex-R52 supports these default features and optionally includes:
+            // neon-fp-armv8, SP+DP, with 32 DP registers
+            //
+            // Reference:
+            // Arm Cortex-R52 Processor Technical Reference Manual
+            // - Chapter 15 Advanced SIMD and floating-point support
+            max_atomic_width: Some(64),
+            has_thumb_interworking: true,
+            ..base::arm_none::opts()
+        },
+    }
+}
diff --git a/src/bootstrap/src/core/sanity.rs b/src/bootstrap/src/core/sanity.rs
index 607b9a384d196..235bbf8ddb783 100644
--- a/src/bootstrap/src/core/sanity.rs
+++ b/src/bootstrap/src/core/sanity.rs
@@ -38,6 +38,11 @@ pub struct Finder {
 const STAGE0_MISSING_TARGETS: &[&str] = &[
     // just a dummy comment so the list doesn't get onelined
     "x86_64-unknown-linux-gnuasan",
+    "thumbv7a-none-eabi",
+    "thumbv7a-none-eabihf",
+    "thumbv7r-none-eabi",
+    "thumbv7r-none-eabihf",
+    "thumbv8r-none-eabihf",
 ];
 
 /// Minimum version threshold for libstdc++ required when using prebuilt LLVM
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 889f96f5fefab..9362c8b98fe3d 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -411,17 +411,22 @@ target | std | host | notes
 [`thumbv4t-none-eabi`](platform-support/armv4t-none-eabi.md) | * |  | Thumb-mode Bare Armv4T
 [`thumbv5te-none-eabi`](platform-support/armv5te-none-eabi.md) | * |  | Thumb-mode Bare Armv5TE
 [`thumbv6m-nuttx-eabi`](platform-support/nuttx.md) | ✓ |  | ARMv6M with NuttX
-`thumbv7a-pc-windows-msvc` |  |  |
-[`thumbv7a-uwp-windows-msvc`](platform-support/uwp-windows-msvc.md) |  |  |
+[`thumbv7a-none-eabi`](platform-support/armv7a-none-eabi.md) | * |  | Thumb-mode Bare Armv7-A
+[`thumbv7a-none-eabihf`](platform-support/armv7a-none-eabi.md) | * |  | Thumb-mode Bare Armv7-A, hardfloat
 [`thumbv7a-nuttx-eabi`](platform-support/nuttx.md) | ✓ |  | ARMv7-A with NuttX
 [`thumbv7a-nuttx-eabihf`](platform-support/nuttx.md) | ✓ |  | ARMv7-A with NuttX, hardfloat
+`thumbv7a-pc-windows-msvc` |  |  |
+[`thumbv7a-uwp-windows-msvc`](platform-support/uwp-windows-msvc.md) |  |  |
 [`thumbv7em-nuttx-eabi`](platform-support/nuttx.md) | ✓ |  | ARMv7EM with NuttX
 [`thumbv7em-nuttx-eabihf`](platform-support/nuttx.md) | ✓ |  | ARMv7EM with NuttX, hardfloat
 [`thumbv7m-nuttx-eabi`](platform-support/nuttx.md) | ✓ |  | ARMv7M with NuttX
 `thumbv7neon-unknown-linux-musleabihf` | ? |  | Thumb2-mode Armv7-A Linux with NEON, musl 1.2.5
+[`thumbv7r-none-eabi`](platform-support/armv7r-none-eabi.md) | * |  | Thumb-mode Bare Armv7-R
+[`thumbv7r-none-eabihf`](platform-support/armv7r-none-eabi.md) | * |  | Thumb-mode Bare Armv7-R, hardfloat
 [`thumbv8m.base-nuttx-eabi`](platform-support/nuttx.md) | ✓ |  | ARMv8M Baseline with NuttX
 [`thumbv8m.main-nuttx-eabi`](platform-support/nuttx.md) | ✓ |  | ARMv8M Mainline with NuttX
 [`thumbv8m.main-nuttx-eabihf`](platform-support/nuttx.md) | ✓ |  | ARMv8M Mainline with NuttX, hardfloat
+[`thumbv8r-none-eabihf`](platform-support/armv8r-none-eabihf.md) | * |  | Thumb-mode Bare Armv8-R, hardfloat
 [`wasm64-unknown-unknown`](platform-support/wasm64-unknown-unknown.md) | ? |  | WebAssembly
 [`wasm32-wali-linux-musl`](platform-support/wasm32-wali-linux.md) | ? |  | WebAssembly with [WALI](https://github.com/arjunr2/WALI)
 [`wasm32-wasip3`](platform-support/wasm32-wasip3.md) | ✓ |  | WebAssembly with WASIp3
diff --git a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
index 05afb4f4321be..6e08bbb26e466 100644
--- a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
@@ -1,10 +1,12 @@
-# `armv7a-none-eabi` and `armv7a-none-eabihf`
+# `armv7a-none-eabi` and `thumbv7a-none-eabihf`
 
-* **Tier: 2**
+* **Tier: 2** (`armv7a-none-eabi`)
+* **Tier: 3** (`thumbv7a-none-eabi`)
 * **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
-Bare-metal target for CPUs in the Armv7-A architecture family, supporting
-dual ARM/Thumb mode, with ARM mode as the default.
+Bare-metal target for CPUs in the Armv7-A architecture family, supporting dual
+ARM/Thumb mode. The `armv7a-none-eabi` target uses Arm mode by default and
+the `thumbv7a-none-eabihf` target uses Thumb mode by default.
 
 Note, this is for processors running in AArch32 mode. For the AArch64 mode
 added in Armv8-A, see [`aarch64-unknown-none`](aarch64-unknown-none.md) instead.
diff --git a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
index 7f22a29f2ee68..16755ff8c520c 100644
--- a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
@@ -1,10 +1,12 @@
 # `armv7r-none-eabi` and `armv7r-none-eabihf`
 
-* **Tier: 2**
+* **Tier: 2** (`armv7r-none-eabi`)
+* **Tier: 3** (`thumbv7r-none-eabi`)
 * **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
-Bare-metal target for CPUs in the Armv7-R architecture family, supporting
-dual ARM/Thumb mode, with ARM mode as the default.
+Bare-metal target for CPUs in the Armv7-R architecture family, supporting dual
+ARM/Thumb mode. The `armv7r-none-eabi` target uses Arm mode by default and
+the `thumbv7r-none-eabihf` target uses Thumb mode by default.
 
 Processors in this family include the [Arm Cortex-R4, 5, 7, and 8][cortex-r].
 
diff --git a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
index 369e86dbfc7e8..ad4764122446e 100644
--- a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
+++ b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
@@ -1,10 +1,12 @@
-# `armv8r-none-eabihf`
+# `armv8r-none-eabihf` and `thumbv8r-none-eabihf`
 
-* **Tier: 2**
+* **Tier: 2**: `armv8r-none-eabihf`
+* **Tier: 3**: `thumbv8r-none-eabihf`
 * **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
-Bare-metal target for CPUs in the Armv8-R architecture family, supporting
-dual ARM/Thumb mode, with ARM mode as the default.
+Bare-metal target for CPUs in the Armv8-R architecture family, supporting dual
+ARM/Thumb mode. The `armv8r-none-eabi` target uses Arm mode by default and
+the `thumbv8r-none-eabihf` target uses Thumb mode by default.
 
 Processors in this family include the Arm [Cortex-R52][cortex-r52]
 and [Cortex-R52+][cortex-r52-plus].
diff --git a/tests/assembly-llvm/targets/targets-elf.rs b/tests/assembly-llvm/targets/targets-elf.rs
index 0eced9df3c46d..17553fc8f4e40 100644
--- a/tests/assembly-llvm/targets/targets-elf.rs
+++ b/tests/assembly-llvm/targets/targets-elf.rs
@@ -559,6 +559,21 @@
 //@ revisions: thumbv5te_none_eabi
 //@ [thumbv5te_none_eabi] compile-flags: --target thumbv5te-none-eabi
 //@ [thumbv5te_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7a_none_eabi
+//@ [thumbv7a_none_eabi] compile-flags: --target thumbv7a-none-eabi
+//@ [thumbv7a_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7a_none_eabihf
+//@ [thumbv7a_none_eabihf] compile-flags: --target thumbv7a-none-eabihf
+//@ [thumbv7a_none_eabihf] needs-llvm-components: arm
+//@ revisions: thumbv7r_none_eabi
+//@ [thumbv7r_none_eabi] compile-flags: --target thumbv7r-none-eabi
+//@ [thumbv7r_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7r_none_eabihf
+//@ [thumbv7r_none_eabihf] compile-flags: --target thumbv7r-none-eabihf
+//@ [thumbv7r_none_eabihf] needs-llvm-components: arm
+//@ revisions: thumbv8r_none_eabihf
+//@ [thumbv8r_none_eabihf] compile-flags: --target thumbv8r-none-eabihf
+//@ [thumbv8r_none_eabihf] needs-llvm-components: arm
 //@ revisions: thumbv6m_none_eabi
 //@ [thumbv6m_none_eabi] compile-flags: --target thumbv6m-none-eabi
 //@ [thumbv6m_none_eabi] needs-llvm-components: arm

From fb05cac2aa0c5eb23a8b1603955daa9426f9ae85 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Thu, 1 Jan 2026 17:18:48 +0000
Subject: [PATCH 08/27] Update SUMMARY.md too

---
 src/doc/rustc/src/SUMMARY.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 8ceeff2c9685e..5d000c900aaaf 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -56,15 +56,15 @@
     - [arm-none-eabi](platform-support/arm-none-eabi.md)
       - [{arm,thumb}v4t-none-eabi](platform-support/armv4t-none-eabi.md)
       - [{arm,thumb}v5te-none-eabi](platform-support/armv5te-none-eabi.md)
-      - [armv7a-none-eabi{,hf}](platform-support/armv7a-none-eabi.md)
-      - [armv7r-none-eabi{,hf}](platform-support/armv7r-none-eabi.md)
-      - [armebv7r-none-eabi{,hf}](platform-support/armebv7r-none-eabi.md)
-      - [armv8r-none-eabihf](platform-support/armv8r-none-eabihf.md)
+      - [{arm,thumb}v7a-none-eabi{,hf}](platform-support/armv7a-none-eabi.md)
+      - [{arm,thumb}v7r-none-eabi{,hf}](platform-support/armv7r-none-eabi.md)
+      - [{arm,thumb}v8r-none-eabihf](platform-support/armv8r-none-eabihf.md)
       - [thumbv6m-none-eabi](./platform-support/thumbv6m-none-eabi.md)
       - [thumbv7em-none-eabi\*](./platform-support/thumbv7em-none-eabi.md)
       - [thumbv7m-none-eabi](./platform-support/thumbv7m-none-eabi.md)
       - [thumbv8m.base-none-eabi](./platform-support/thumbv8m.base-none-eabi.md)
       - [thumbv8m.main-none-eabi\*](./platform-support/thumbv8m.main-none-eabi.md)
+      - [armebv7r-none-eabi{,hf}](platform-support/armebv7r-none-eabi.md)
     - [arm\*-unknown-linux-\*](./platform-support/arm-linux.md)
         - [armeb-unknown-linux-gnueabi](platform-support/armeb-unknown-linux-gnueabi.md)
         - [armv5te-unknown-linux-gnueabi](platform-support/armv5te-unknown-linux-gnueabi.md)

From 1652f3f1569bf56f84a52e5462ab661151c2ccf1 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 3 Oct 2025 21:29:58 +0000
Subject: [PATCH 09/27] Expand with_api_handle_types

---
 library/proc_macro/src/bridge/client.rs | 115 ++++++++++--------------
 library/proc_macro/src/bridge/mod.rs    |  16 ----
 library/proc_macro/src/bridge/server.rs |  91 ++++++++-----------
 3 files changed, 85 insertions(+), 137 deletions(-)

diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index e75902eca6bb6..10302cf24f997 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -6,87 +6,66 @@ use std::sync::atomic::AtomicU32;
 
 use super::*;
 
-macro_rules! define_client_handles {
-    (
-        'owned: $($oty:ident,)*
-        'interned: $($ity:ident,)*
-    ) => {
-        #[repr(C)]
-        #[allow(non_snake_case)]
-        pub(super) struct HandleCounters {
-            $(pub(super) $oty: AtomicU32,)*
-            $(pub(super) $ity: AtomicU32,)*
-        }
+#[repr(C)]
+pub(super) struct HandleCounters {
+    pub(super) token_stream: AtomicU32,
+    pub(super) span: AtomicU32,
+}
 
-        static COUNTERS: HandleCounters = HandleCounters {
-            $($oty: AtomicU32::new(1),)*
-            $($ity: AtomicU32::new(1),)*
-        };
+static COUNTERS: HandleCounters =
+    HandleCounters { token_stream: AtomicU32::new(1), span: AtomicU32::new(1) };
 
-        $(
-            pub(crate) struct $oty {
-                handle: handle::Handle,
-            }
+pub(crate) struct TokenStream {
+    handle: handle::Handle,
+}
 
-            impl !Send for $oty {}
-            impl !Sync for $oty {}
+impl !Send for TokenStream {}
+impl !Sync for TokenStream {}
 
-            // Forward `Drop::drop` to the inherent `drop` method.
-            impl Drop for $oty {
-                fn drop(&mut self) {
-                    $oty {
-                        handle: self.handle,
-                    }.drop();
-                }
-            }
+// Forward `Drop::drop` to the inherent `drop` method.
+impl Drop for TokenStream {
+    fn drop(&mut self) {
+        TokenStream { handle: self.handle }.drop();
+    }
+}
 
-            impl<S> Encode<S> for $oty {
-                fn encode(self, w: &mut Writer, s: &mut S) {
-                    mem::ManuallyDrop::new(self).handle.encode(w, s);
-                }
-            }
+impl<S> Encode<S> for TokenStream {
+    fn encode(self, w: &mut Writer, s: &mut S) {
+        mem::ManuallyDrop::new(self).handle.encode(w, s);
+    }
+}
 
-            impl<S> Encode<S> for &$oty {
-                fn encode(self, w: &mut Writer, s: &mut S) {
-                    self.handle.encode(w, s);
-                }
-            }
+impl<S> Encode<S> for &TokenStream {
+    fn encode(self, w: &mut Writer, s: &mut S) {
+        self.handle.encode(w, s);
+    }
+}
 
-            impl<S> Decode<'_, '_, S> for $oty {
-                fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
-                    $oty {
-                        handle: handle::Handle::decode(r, s),
-                    }
-                }
-            }
-        )*
+impl<S> Decode<'_, '_, S> for TokenStream {
+    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+        TokenStream { handle: handle::Handle::decode(r, s) }
+    }
+}
 
-        $(
-            #[derive(Copy, Clone, PartialEq, Eq, Hash)]
-            pub(crate) struct $ity {
-                handle: handle::Handle,
-            }
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct Span {
+    handle: handle::Handle,
+}
 
-            impl !Send for $ity {}
-            impl !Sync for $ity {}
+impl !Send for Span {}
+impl !Sync for Span {}
 
-            impl<S> Encode<S> for $ity {
-                fn encode(self, w: &mut Writer, s: &mut S) {
-                    self.handle.encode(w, s);
-                }
-            }
+impl<S> Encode<S> for Span {
+    fn encode(self, w: &mut Writer, s: &mut S) {
+        self.handle.encode(w, s);
+    }
+}
 
-            impl<S> Decode<'_, '_, S> for $ity {
-                fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
-                    $ity {
-                        handle: handle::Handle::decode(r, s),
-                    }
-                }
-            }
-        )*
+impl<S> Decode<'_, '_, S> for Span {
+    fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
+        Span { handle: handle::Handle::decode(r, s) }
     }
 }
-with_api_handle_types!(define_client_handles);
 
 // FIXME(eddyb) generate these impls by pattern-matching on the
 // names of methods - also could use the presence of `fn drop`
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 15a81bd5f96f2..04a75ed797c8e 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -102,22 +102,6 @@ macro_rules! with_api {
     };
 }
 
-// Similar to `with_api`, but only lists the types requiring handles, and they
-// are divided into the two storage categories.
-macro_rules! with_api_handle_types {
-    ($m:ident) => {
-        $m! {
-            'owned:
-            // FreeFunctions is handled manually
-            TokenStream,
-
-            'interned:
-            Span,
-            // Symbol is handled manually
-        }
-    };
-}
-
 pub(crate) struct FreeFunctions;
 
 #[allow(unsafe_code)]
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index 27cc5e5d57e33..c9e42bd1dd15c 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -5,68 +5,53 @@ use std::marker::PhantomData;
 
 use super::*;
 
-macro_rules! define_server_handles {
-    (
-        'owned: $($oty:ident,)*
-        'interned: $($ity:ident,)*
-    ) => {
-        #[allow(non_snake_case)]
-        pub(super) struct HandleStore<S: Types> {
-            $($oty: handle::OwnedStore<S::$oty>,)*
-            $($ity: handle::InternedStore<S::$ity>,)*
-        }
+pub(super) struct HandleStore<S: Types> {
+    token_stream: handle::OwnedStore<S::TokenStream>,
+    span: handle::InternedStore<S::Span>,
+}
 
-        impl<S: Types> HandleStore<S> {
-            fn new(handle_counters: &'static client::HandleCounters) -> Self {
-                HandleStore {
-                    $($oty: handle::OwnedStore::new(&handle_counters.$oty),)*
-                    $($ity: handle::InternedStore::new(&handle_counters.$ity),)*
-                }
-            }
+impl<S: Types> HandleStore<S> {
+    fn new(handle_counters: &'static client::HandleCounters) -> Self {
+        HandleStore {
+            token_stream: handle::OwnedStore::new(&handle_counters.token_stream),
+            span: handle::InternedStore::new(&handle_counters.span),
         }
+    }
+}
 
-        $(
-            impl<S: Types> Encode<HandleStore<MarkedTypes<S>>> for Marked<S::$oty, client::$oty> {
-                fn encode(self, w: &mut Writer, s: &mut HandleStore<MarkedTypes<S>>) {
-                    s.$oty.alloc(self).encode(w, s);
-                }
-            }
+impl<S: Types> Encode<HandleStore<MarkedTypes<S>>> for Marked<S::TokenStream, client::TokenStream> {
+    fn encode(self, w: &mut Writer, s: &mut HandleStore<MarkedTypes<S>>) {
+        s.token_stream.alloc(self).encode(w, s);
+    }
+}
 
-            impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>>
-                for Marked<S::$oty, client::$oty>
-            {
-                fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {
-                    s.$oty.take(handle::Handle::decode(r, &mut ()))
-                }
-            }
+impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>>
+    for Marked<S::TokenStream, client::TokenStream>
+{
+    fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {
+        s.token_stream.take(handle::Handle::decode(r, &mut ()))
+    }
+}
 
-            impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>
-                for &'s Marked<S::$oty, client::$oty>
-            {
-                fn decode(r: &mut Reader<'_>, s: &'s mut HandleStore<MarkedTypes<S>>) -> Self {
-                    &s.$oty[handle::Handle::decode(r, &mut ())]
-                }
-            }
-        )*
+impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>
+    for &'s Marked<S::TokenStream, client::TokenStream>
+{
+    fn decode(r: &mut Reader<'_>, s: &'s mut HandleStore<MarkedTypes<S>>) -> Self {
+        &s.token_stream[handle::Handle::decode(r, &mut ())]
+    }
+}
 
-        $(
-            impl<S: Types> Encode<HandleStore<MarkedTypes<S>>> for Marked<S::$ity, client::$ity> {
-                fn encode(self, w: &mut Writer, s: &mut HandleStore<MarkedTypes<S>>) {
-                    s.$ity.alloc(self).encode(w, s);
-                }
-            }
+impl<S: Types> Encode<HandleStore<MarkedTypes<S>>> for Marked<S::Span, client::Span> {
+    fn encode(self, w: &mut Writer, s: &mut HandleStore<MarkedTypes<S>>) {
+        s.span.alloc(self).encode(w, s);
+    }
+}
 
-            impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>>
-                for Marked<S::$ity, client::$ity>
-            {
-                fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {
-                    s.$ity.copy(handle::Handle::decode(r, &mut ()))
-                }
-            }
-        )*
+impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>> for Marked<S::Span, client::Span> {
+    fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {
+        s.span.copy(handle::Handle::decode(r, &mut ()))
     }
 }
-with_api_handle_types!(define_server_handles);
 
 pub trait Types {
     type FreeFunctions: 'static;

From d3b5f72bc65b37cf8df01915c55e252dc5cd8c40 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 22 Jan 2026 18:10:03 +0000
Subject: [PATCH 10/27] Move all bridge methods into a single type

---
 .../rustc_expand/src/proc_macro_server.rs     | 70 +++++++-------
 library/proc_macro/src/bridge/client.rs       |  6 +-
 library/proc_macro/src/bridge/mod.rs          | 92 ++++++++++---------
 library/proc_macro/src/bridge/server.rs       | 33 +++----
 library/proc_macro/src/bridge/symbol.rs       |  2 +-
 library/proc_macro/src/lib.rs                 | 62 ++++++++-----
 .../src/server_impl/rust_analyzer_span.rs     | 70 +++++++-------
 .../src/server_impl/token_id.rs               | 70 +++++++-------
 8 files changed, 218 insertions(+), 187 deletions(-)

diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index 7688df2d3a55d..4f8ff5588581d 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -552,14 +552,20 @@ impl server::FreeFunctions for Rustc<'_, '_> {
         }
         diag.emit();
     }
-}
 
-impl server::TokenStream for Rustc<'_, '_> {
-    fn is_empty(&mut self, stream: &Self::TokenStream) -> bool {
+    fn tt_drop(&mut self, stream: Self::TokenStream) {
+        drop(stream);
+    }
+
+    fn tt_clone(&mut self, stream: &Self::TokenStream) -> Self::TokenStream {
+        stream.clone()
+    }
+
+    fn tt_is_empty(&mut self, stream: &Self::TokenStream) -> bool {
         stream.is_empty()
     }
 
-    fn from_str(&mut self, src: &str) -> Self::TokenStream {
+    fn tt_from_str(&mut self, src: &str) -> Self::TokenStream {
         unwrap_or_emit_fatal(source_str_to_stream(
             self.psess(),
             FileName::proc_macro_source_code(src),
@@ -568,11 +574,11 @@ impl server::TokenStream for Rustc<'_, '_> {
         ))
     }
 
-    fn to_string(&mut self, stream: &Self::TokenStream) -> String {
+    fn tt_to_string(&mut self, stream: &Self::TokenStream) -> String {
         pprust::tts_to_string(stream)
     }
 
-    fn expand_expr(&mut self, stream: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
+    fn tt_expand_expr(&mut self, stream: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
         // Parse the expression from our tokenstream.
         let expr: PResult<'_, _> = try {
             let mut p = Parser::new(self.psess(), stream.clone(), Some("proc_macro expand expr"));
@@ -633,14 +639,14 @@ impl server::TokenStream for Rustc<'_, '_> {
         }
     }
 
-    fn from_token_tree(
+    fn tt_from_token_tree(
         &mut self,
         tree: TokenTree<Self::TokenStream, Self::Span, Self::Symbol>,
     ) -> Self::TokenStream {
         Self::TokenStream::new((tree, &mut *self).to_internal().into_iter().collect::<Vec<_>>())
     }
 
-    fn concat_trees(
+    fn tt_concat_trees(
         &mut self,
         base: Option<Self::TokenStream>,
         trees: Vec<TokenTree<Self::TokenStream, Self::Span, Self::Symbol>>,
@@ -654,7 +660,7 @@ impl server::TokenStream for Rustc<'_, '_> {
         stream
     }
 
-    fn concat_streams(
+    fn tt_concat_streams(
         &mut self,
         base: Option<Self::TokenStream>,
         streams: Vec<Self::TokenStream>,
@@ -666,16 +672,14 @@ impl server::TokenStream for Rustc<'_, '_> {
         stream
     }
 
-    fn into_trees(
+    fn tt_into_trees(
         &mut self,
         stream: Self::TokenStream,
     ) -> Vec<TokenTree<Self::TokenStream, Self::Span, Self::Symbol>> {
         FromInternal::from_internal((stream, self))
     }
-}
 
-impl server::Span for Rustc<'_, '_> {
-    fn debug(&mut self, span: Self::Span) -> String {
+    fn span_debug(&mut self, span: Self::Span) -> String {
         if self.ecx.ecfg.span_debug {
             format!("{span:?}")
         } else {
@@ -683,7 +687,7 @@ impl server::Span for Rustc<'_, '_> {
         }
     }
 
-    fn file(&mut self, span: Self::Span) -> String {
+    fn span_file(&mut self, span: Self::Span) -> String {
         self.psess()
             .source_map()
             .lookup_char_pos(span.lo())
@@ -693,7 +697,7 @@ impl server::Span for Rustc<'_, '_> {
             .to_string()
     }
 
-    fn local_file(&mut self, span: Self::Span) -> Option<String> {
+    fn span_local_file(&mut self, span: Self::Span) -> Option<String> {
         self.psess()
             .source_map()
             .lookup_char_pos(span.lo())
@@ -708,15 +712,15 @@ impl server::Span for Rustc<'_, '_> {
             })
     }
 
-    fn parent(&mut self, span: Self::Span) -> Option<Self::Span> {
+    fn span_parent(&mut self, span: Self::Span) -> Option<Self::Span> {
         span.parent_callsite()
     }
 
-    fn source(&mut self, span: Self::Span) -> Self::Span {
+    fn span_source(&mut self, span: Self::Span) -> Self::Span {
         span.source_callsite()
     }
 
-    fn byte_range(&mut self, span: Self::Span) -> Range<usize> {
+    fn span_byte_range(&mut self, span: Self::Span) -> Range<usize> {
         let source_map = self.psess().source_map();
 
         let relative_start_pos = source_map.lookup_byte_offset(span.lo()).pos;
@@ -724,25 +728,25 @@ impl server::Span for Rustc<'_, '_> {
 
         Range { start: relative_start_pos.0 as usize, end: relative_end_pos.0 as usize }
     }
-    fn start(&mut self, span: Self::Span) -> Self::Span {
+    fn span_start(&mut self, span: Self::Span) -> Self::Span {
         span.shrink_to_lo()
     }
 
-    fn end(&mut self, span: Self::Span) -> Self::Span {
+    fn span_end(&mut self, span: Self::Span) -> Self::Span {
         span.shrink_to_hi()
     }
 
-    fn line(&mut self, span: Self::Span) -> usize {
+    fn span_line(&mut self, span: Self::Span) -> usize {
         let loc = self.psess().source_map().lookup_char_pos(span.lo());
         loc.line
     }
 
-    fn column(&mut self, span: Self::Span) -> usize {
+    fn span_column(&mut self, span: Self::Span) -> usize {
         let loc = self.psess().source_map().lookup_char_pos(span.lo());
         loc.col.to_usize() + 1
     }
 
-    fn join(&mut self, first: Self::Span, second: Self::Span) -> Option<Self::Span> {
+    fn span_join(&mut self, first: Self::Span, second: Self::Span) -> Option<Self::Span> {
         let self_loc = self.psess().source_map().lookup_char_pos(first.lo());
         let other_loc = self.psess().source_map().lookup_char_pos(second.lo());
 
@@ -753,7 +757,7 @@ impl server::Span for Rustc<'_, '_> {
         Some(first.to(second))
     }
 
-    fn subspan(
+    fn span_subspan(
         &mut self,
         span: Self::Span,
         start: Bound<usize>,
@@ -789,11 +793,11 @@ impl server::Span for Rustc<'_, '_> {
         Some(span.with_lo(new_lo).with_hi(new_hi))
     }
 
-    fn resolved_at(&mut self, span: Self::Span, at: Self::Span) -> Self::Span {
+    fn span_resolved_at(&mut self, span: Self::Span, at: Self::Span) -> Self::Span {
         span.with_ctxt(at.ctxt())
     }
 
-    fn source_text(&mut self, span: Self::Span) -> Option<String> {
+    fn span_source_text(&mut self, span: Self::Span) -> Option<String> {
         self.psess().source_map().span_to_snippet(span).ok()
     }
 
@@ -821,11 +825,11 @@ impl server::Span for Rustc<'_, '_> {
     /// span from the metadata of `my_proc_macro` (which we have access to,
     /// since we've loaded `my_proc_macro` from disk in order to execute it).
     /// In this way, we have obtained a span pointing into `my_proc_macro`
-    fn save_span(&mut self, span: Self::Span) -> usize {
+    fn span_save_span(&mut self, span: Self::Span) -> usize {
         self.psess().save_proc_macro_span(span)
     }
 
-    fn recover_proc_macro_span(&mut self, id: usize) -> Self::Span {
+    fn span_recover_proc_macro_span(&mut self, id: usize) -> Self::Span {
         let (resolver, krate, def_site) = (&*self.ecx.resolver, self.krate, self.def_site);
         *self.rebased_spans.entry(id).or_insert_with(|| {
             // FIXME: `SyntaxContext` for spans from proc macro crates is lost during encoding,
@@ -833,15 +837,19 @@ impl server::Span for Rustc<'_, '_> {
             resolver.get_proc_macro_quoted_span(krate, id).with_ctxt(def_site.ctxt())
         })
     }
-}
 
-impl server::Symbol for Rustc<'_, '_> {
-    fn normalize_and_validate_ident(&mut self, string: &str) -> Result<Self::Symbol, ()> {
+    fn symbol_normalize_and_validate_ident(&mut self, string: &str) -> Result<Self::Symbol, ()> {
         let sym = nfc_normalize(string);
         if rustc_lexer::is_ident(sym.as_str()) { Ok(sym) } else { Err(()) }
     }
 }
 
+impl server::TokenStream for Rustc<'_, '_> {}
+
+impl server::Span for Rustc<'_, '_> {}
+
+impl server::Symbol for Rustc<'_, '_> {}
+
 impl server::Server for Rustc<'_, '_> {
     fn globals(&mut self) -> ExpnGlobals<Self::Span> {
         ExpnGlobals {
diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index 10302cf24f997..d954177e7df55 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -25,7 +25,7 @@ impl !Sync for TokenStream {}
 // Forward `Drop::drop` to the inherent `drop` method.
 impl Drop for TokenStream {
     fn drop(&mut self) {
-        TokenStream { handle: self.handle }.drop();
+        FreeFunctions::tt_drop(TokenStream { handle: self.handle });
     }
 }
 
@@ -75,7 +75,7 @@ impl<S> Decode<'_, '_, S> for Span {
 
 impl Clone for TokenStream {
     fn clone(&self) -> Self {
-        self.clone()
+        FreeFunctions::tt_clone(self)
     }
 }
 
@@ -95,7 +95,7 @@ impl Span {
 
 impl fmt::Debug for Span {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&self.debug())
+        f.write_str(&FreeFunctions::span_debug(*self))
     }
 }
 
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 04a75ed797c8e..027f94c36ff27 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -54,50 +54,50 @@ macro_rules! with_api {
                 fn track_path(path: &str);
                 fn literal_from_str(s: &str) -> Result<Literal<$S::Span, $S::Symbol>, ()>;
                 fn emit_diagnostic(diagnostic: Diagnostic<$S::Span>);
-            },
-            TokenStream {
-                fn drop($self: $S::TokenStream);
-                fn clone($self: &$S::TokenStream) -> $S::TokenStream;
-                fn is_empty($self: &$S::TokenStream) -> bool;
-                fn expand_expr($self: &$S::TokenStream) -> Result<$S::TokenStream, ()>;
-                fn from_str(src: &str) -> $S::TokenStream;
-                fn to_string($self: &$S::TokenStream) -> String;
-                fn from_token_tree(
+
+                fn tt_drop(stream: $S::TokenStream);
+                fn tt_clone(stream: &$S::TokenStream) -> $S::TokenStream;
+                fn tt_is_empty(stream: &$S::TokenStream) -> bool;
+                fn tt_expand_expr(stream: &$S::TokenStream) -> Result<$S::TokenStream, ()>;
+                fn tt_from_str(src: &str) -> $S::TokenStream;
+                fn tt_to_string(stream: &$S::TokenStream) -> String;
+                fn tt_from_token_tree(
                     tree: TokenTree<$S::TokenStream, $S::Span, $S::Symbol>,
                 ) -> $S::TokenStream;
-                fn concat_trees(
+                fn tt_concat_trees(
                     base: Option<$S::TokenStream>,
                     trees: Vec<TokenTree<$S::TokenStream, $S::Span, $S::Symbol>>,
                 ) -> $S::TokenStream;
-                fn concat_streams(
+                fn tt_concat_streams(
                     base: Option<$S::TokenStream>,
                     streams: Vec<$S::TokenStream>,
                 ) -> $S::TokenStream;
-                fn into_trees(
-                    $self: $S::TokenStream
+                fn tt_into_trees(
+                    stream: $S::TokenStream
                 ) -> Vec<TokenTree<$S::TokenStream, $S::Span, $S::Symbol>>;
+
+                fn span_debug(span: $S::Span) -> String;
+                fn span_parent(span: $S::Span) -> Option<$S::Span>;
+                fn span_source(span: $S::Span) -> $S::Span;
+                fn span_byte_range(span: $S::Span) -> Range<usize>;
+                fn span_start(span: $S::Span) -> $S::Span;
+                fn span_end(span: $S::Span) -> $S::Span;
+                fn span_line(span: $S::Span) -> usize;
+                fn span_column(span: $S::Span) -> usize;
+                fn span_file(span: $S::Span) -> String;
+                fn span_local_file(span: $S::Span) -> Option<String>;
+                fn span_join(span: $S::Span, other: $S::Span) -> Option<$S::Span>;
+                fn span_subspan(span: $S::Span, start: Bound<usize>, end: Bound<usize>) -> Option<$S::Span>;
+                fn span_resolved_at(span: $S::Span, at: $S::Span) -> $S::Span;
+                fn span_source_text(span: $S::Span) -> Option<String>;
+                fn span_save_span(span: $S::Span) -> usize;
+                fn span_recover_proc_macro_span(id: usize) -> $S::Span;
+
+                fn symbol_normalize_and_validate_ident(string: &str) -> Result<$S::Symbol, ()>;
             },
-            Span {
-                fn debug($self: $S::Span) -> String;
-                fn parent($self: $S::Span) -> Option<$S::Span>;
-                fn source($self: $S::Span) -> $S::Span;
-                fn byte_range($self: $S::Span) -> Range<usize>;
-                fn start($self: $S::Span) -> $S::Span;
-                fn end($self: $S::Span) -> $S::Span;
-                fn line($self: $S::Span) -> usize;
-                fn column($self: $S::Span) -> usize;
-                fn file($self: $S::Span) -> String;
-                fn local_file($self: $S::Span) -> Option<String>;
-                fn join($self: $S::Span, other: $S::Span) -> Option<$S::Span>;
-                fn subspan($self: $S::Span, start: Bound<usize>, end: Bound<usize>) -> Option<$S::Span>;
-                fn resolved_at($self: $S::Span, at: $S::Span) -> $S::Span;
-                fn source_text($self: $S::Span) -> Option<String>;
-                fn save_span($self: $S::Span) -> usize;
-                fn recover_proc_macro_span(id: usize) -> $S::Span;
-            },
-            Symbol {
-                fn normalize_and_validate_ident(string: &str) -> Result<$S::Symbol, ()>;
-            },
+            TokenStream {},
+            Span {},
+            Symbol {},
         }
     };
 }
@@ -156,20 +156,22 @@ mod api_tags {
     use super::rpc::{Decode, Encode, Reader, Writer};
 
     macro_rules! declare_tags {
-        ($($name:ident {
-            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
-        }),* $(,)?) => {
-            $(
-                pub(super) enum $name {
-                    $($method),*
-                }
-                rpc_encode_decode!(enum $name { $($method),* });
-            )*
+        (
+            FreeFunctions {
+                $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
+            },
+            $($name:ident { $($x:tt)* }),* $(,)?
+        ) => {
+            pub(super) enum FreeFunctions {
+                $($method),*
+            }
+            rpc_encode_decode!(enum FreeFunctions { $($method),* });
+
 
             pub(super) enum Method {
-                $($name($name)),*
+                FreeFunctions(FreeFunctions),
             }
-            rpc_encode_decode!(enum Method { $($name(m)),* });
+            rpc_encode_decode!(enum Method { FreeFunctions(m) });
         }
     }
     with_api!(self, self, declare_tags);
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index c9e42bd1dd15c..16037ed46f063 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -60,24 +60,12 @@ pub trait Types {
     type Symbol: 'static;
 }
 
-/// Declare an associated fn of one of the traits below, adding necessary
-/// default bodies.
-macro_rules! associated_fn {
-    (fn drop(&mut self, $arg:ident: $arg_ty:ty)) =>
-        (fn drop(&mut self, $arg: $arg_ty) { mem::drop($arg) });
-
-    (fn clone(&mut self, $arg:ident: $arg_ty:ty) -> $ret_ty:ty) =>
-        (fn clone(&mut self, $arg: $arg_ty) -> $ret_ty { $arg.clone() });
-
-    ($($item:tt)*) => ($($item)*;)
-}
-
 macro_rules! declare_server_traits {
     ($($name:ident {
         $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
     }),* $(,)?) => {
         $(pub trait $name: Types {
-            $(associated_fn!(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)?);)*
+            $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)?;)*
         })*
 
         pub trait Server: Types $(+ $name)* {
@@ -130,18 +118,23 @@ struct Dispatcher<S: Types> {
 }
 
 macro_rules! define_dispatcher_impl {
-    ($($name:ident {
-        $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
-    }),* $(,)?) => {
+    (
+        FreeFunctions {
+            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
+        },
+        $($name:ident { $($x:tt)* }),* $(,)?
+    ) => {
         // FIXME(eddyb) `pub` only for `ExecutionStrategy` below.
         pub trait DispatcherTrait {
             // HACK(eddyb) these are here to allow `Self::$name` to work below.
+            type FreeFunctions;
             $(type $name;)*
 
             fn dispatch(&mut self, buf: Buffer) -> Buffer;
         }
 
         impl<S: Server> DispatcherTrait for Dispatcher<MarkedTypes<S>> {
+            type FreeFunctions = <MarkedTypes<S> as Types>::FreeFunctions;
             $(type $name = <MarkedTypes<S> as Types>::$name;)*
 
             fn dispatch(&mut self, mut buf: Buffer) -> Buffer {
@@ -149,11 +142,11 @@ macro_rules! define_dispatcher_impl {
 
                 let mut reader = &buf[..];
                 match api_tags::Method::decode(&mut reader, &mut ()) {
-                    $(api_tags::Method::$name(m) => match m {
-                        $(api_tags::$name::$method => {
+                    api_tags::Method::FreeFunctions(m) => match m {
+                        $(api_tags::FreeFunctions::$method => {
                             let mut call_method = || {
                                 $(let $arg = <$arg_ty>::decode(&mut reader, handle_store);)*
-                                $name::$method(server, $($arg),*)
+                                FreeFunctions::$method(server, $($arg),*)
                             };
                             // HACK(eddyb) don't use `panic::catch_unwind` in a panic.
                             // If client and server happen to use the same `std`,
@@ -169,7 +162,7 @@ macro_rules! define_dispatcher_impl {
                             buf.clear();
                             r.encode(&mut buf, handle_store);
                         })*
-                    }),*
+                    }
                 }
                 buf
             }
diff --git a/library/proc_macro/src/bridge/symbol.rs b/library/proc_macro/src/bridge/symbol.rs
index e070ec07681d3..6366ac2e6a939 100644
--- a/library/proc_macro/src/bridge/symbol.rs
+++ b/library/proc_macro/src/bridge/symbol.rs
@@ -46,7 +46,7 @@ impl Symbol {
         if string.is_ascii() {
             Err(())
         } else {
-            client::Symbol::normalize_and_validate_ident(string)
+            client::FreeFunctions::symbol_normalize_and_validate_ident(string)
         }
         .unwrap_or_else(|_| panic!("`{:?}` is not a valid identifier", string))
     }
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index a005f743ddfac..8d5491e918510 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -158,7 +158,7 @@ impl TokenStream {
     /// Checks if this `TokenStream` is empty.
     #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
     pub fn is_empty(&self) -> bool {
-        self.0.as_ref().map(|h| h.is_empty()).unwrap_or(true)
+        self.0.as_ref().map(|h| bridge::client::FreeFunctions::tt_is_empty(h)).unwrap_or(true)
     }
 
     /// Parses this `TokenStream` as an expression and attempts to expand any
@@ -174,7 +174,7 @@ impl TokenStream {
     #[unstable(feature = "proc_macro_expand", issue = "90765")]
     pub fn expand_expr(&self) -> Result<TokenStream, ExpandError> {
         let stream = self.0.as_ref().ok_or(ExpandError)?;
-        match bridge::client::TokenStream::expand_expr(stream) {
+        match bridge::client::FreeFunctions::tt_expand_expr(stream) {
             Ok(stream) => Ok(TokenStream(Some(stream))),
             Err(_) => Err(ExpandError),
         }
@@ -193,7 +193,7 @@ impl FromStr for TokenStream {
     type Err = LexError;
 
     fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        Ok(TokenStream(Some(bridge::client::TokenStream::from_str(src))))
+        Ok(TokenStream(Some(bridge::client::FreeFunctions::tt_from_str(src))))
     }
 }
 
@@ -212,7 +212,7 @@ impl FromStr for TokenStream {
 impl fmt::Display for TokenStream {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self.0 {
-            Some(ts) => write!(f, "{}", ts.to_string()),
+            Some(ts) => write!(f, "{}", bridge::client::FreeFunctions::tt_to_string(ts)),
             None => Ok(()),
         }
     }
@@ -252,7 +252,9 @@ fn tree_to_bridge_tree(
 #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
 impl From<TokenTree> for TokenStream {
     fn from(tree: TokenTree) -> TokenStream {
-        TokenStream(Some(bridge::client::TokenStream::from_token_tree(tree_to_bridge_tree(tree))))
+        TokenStream(Some(bridge::client::FreeFunctions::tt_from_token_tree(tree_to_bridge_tree(
+            tree,
+        ))))
     }
 }
 
@@ -281,7 +283,7 @@ impl ConcatTreesHelper {
         if self.trees.is_empty() {
             TokenStream(None)
         } else {
-            TokenStream(Some(bridge::client::TokenStream::concat_trees(None, self.trees)))
+            TokenStream(Some(bridge::client::FreeFunctions::tt_concat_trees(None, self.trees)))
         }
     }
 
@@ -289,7 +291,7 @@ impl ConcatTreesHelper {
         if self.trees.is_empty() {
             return;
         }
-        stream.0 = Some(bridge::client::TokenStream::concat_trees(stream.0.take(), self.trees))
+        stream.0 = Some(bridge::client::FreeFunctions::tt_concat_trees(stream.0.take(), self.trees))
     }
 }
 
@@ -314,7 +316,7 @@ impl ConcatStreamsHelper {
         if self.streams.len() <= 1 {
             TokenStream(self.streams.pop())
         } else {
-            TokenStream(Some(bridge::client::TokenStream::concat_streams(None, self.streams)))
+            TokenStream(Some(bridge::client::FreeFunctions::tt_concat_streams(None, self.streams)))
         }
     }
 
@@ -326,7 +328,7 @@ impl ConcatStreamsHelper {
         if base.is_none() && self.streams.len() == 1 {
             stream.0 = self.streams.pop();
         } else {
-            stream.0 = Some(bridge::client::TokenStream::concat_streams(base, self.streams));
+            stream.0 = Some(bridge::client::FreeFunctions::tt_concat_streams(base, self.streams));
         }
     }
 }
@@ -437,7 +439,12 @@ pub mod token_stream {
         type IntoIter = IntoIter;
 
         fn into_iter(self) -> IntoIter {
-            IntoIter(self.0.map(|v| v.into_trees()).unwrap_or_default().into_iter())
+            IntoIter(
+                self.0
+                    .map(|v| bridge::client::FreeFunctions::tt_into_trees(v))
+                    .unwrap_or_default()
+                    .into_iter(),
+            )
         }
     }
 }
@@ -509,7 +516,7 @@ impl Span {
     /// `self` was generated from, if any.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn parent(&self) -> Option<Span> {
-        self.0.parent().map(Span)
+        bridge::client::FreeFunctions::span_parent(self.0).map(Span)
     }
 
     /// The span for the origin source code that `self` was generated from. If
@@ -517,25 +524,25 @@ impl Span {
     /// value is the same as `*self`.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn source(&self) -> Span {
-        Span(self.0.source())
+        Span(bridge::client::FreeFunctions::span_source(self.0))
     }
 
     /// Returns the span's byte position range in the source file.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn byte_range(&self) -> Range<usize> {
-        self.0.byte_range()
+        bridge::client::FreeFunctions::span_byte_range(self.0)
     }
 
     /// Creates an empty span pointing to directly before this span.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn start(&self) -> Span {
-        Span(self.0.start())
+        Span(bridge::client::FreeFunctions::span_start(self.0))
     }
 
     /// Creates an empty span pointing to directly after this span.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn end(&self) -> Span {
-        Span(self.0.end())
+        Span(bridge::client::FreeFunctions::span_end(self.0))
     }
 
     /// The one-indexed line of the source file where the span starts.
@@ -543,7 +550,7 @@ impl Span {
     /// To obtain the line of the span's end, use `span.end().line()`.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn line(&self) -> usize {
-        self.0.line()
+        bridge::client::FreeFunctions::span_line(self.0)
     }
 
     /// The one-indexed column of the source file where the span starts.
@@ -551,7 +558,7 @@ impl Span {
     /// To obtain the column of the span's end, use `span.end().column()`.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn column(&self) -> usize {
-        self.0.column()
+        bridge::client::FreeFunctions::span_column(self.0)
     }
 
     /// The path to the source file in which this span occurs, for display purposes.
@@ -560,7 +567,7 @@ impl Span {
     /// It might be remapped (e.g. `"/src/lib.rs"`) or an artificial path (e.g. `"<command line>"`).
     #[stable(feature = "proc_macro_span_file", since = "1.88.0")]
     pub fn file(&self) -> String {
-        self.0.file()
+        bridge::client::FreeFunctions::span_file(self.0)
     }
 
     /// The path to the source file in which this span occurs on the local file system.
@@ -570,7 +577,7 @@ impl Span {
     /// This path should not be embedded in the output of the macro; prefer `file()` instead.
     #[stable(feature = "proc_macro_span_file", since = "1.88.0")]
     pub fn local_file(&self) -> Option<PathBuf> {
-        self.0.local_file().map(PathBuf::from)
+        bridge::client::FreeFunctions::span_local_file(self.0).map(PathBuf::from)
     }
 
     /// Creates a new span encompassing `self` and `other`.
@@ -578,14 +585,14 @@ impl Span {
     /// Returns `None` if `self` and `other` are from different files.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn join(&self, other: Span) -> Option<Span> {
-        self.0.join(other.0).map(Span)
+        bridge::client::FreeFunctions::span_join(self.0, other.0).map(Span)
     }
 
     /// Creates a new span with the same line/column information as `self` but
     /// that resolves symbols as though it were at `other`.
     #[stable(feature = "proc_macro_span_resolved_at", since = "1.45.0")]
     pub fn resolved_at(&self, other: Span) -> Span {
-        Span(self.0.resolved_at(other.0))
+        Span(bridge::client::FreeFunctions::span_resolved_at(self.0, other.0))
     }
 
     /// Creates a new span with the same name resolution behavior as `self` but
@@ -610,21 +617,21 @@ impl Span {
     /// be used for diagnostics only.
     #[stable(feature = "proc_macro_source_text", since = "1.66.0")]
     pub fn source_text(&self) -> Option<String> {
-        self.0.source_text()
+        bridge::client::FreeFunctions::span_source_text(self.0)
     }
 
     // Used by the implementation of `Span::quote`
     #[doc(hidden)]
     #[unstable(feature = "proc_macro_internals", issue = "27812")]
     pub fn save_span(&self) -> usize {
-        self.0.save_span()
+        bridge::client::FreeFunctions::span_save_span(self.0)
     }
 
     // Used by the implementation of `Span::quote`
     #[doc(hidden)]
     #[unstable(feature = "proc_macro_internals", issue = "27812")]
     pub fn recover_proc_macro_span(id: usize) -> Span {
-        Span(bridge::client::Span::recover_proc_macro_span(id))
+        Span(bridge::client::FreeFunctions::span_recover_proc_macro_span(id))
     }
 
     diagnostic_method!(error, Level::Error);
@@ -1389,7 +1396,12 @@ impl Literal {
     // was 'c' or whether it was '\u{63}'.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
-        self.0.span.subspan(range.start_bound().cloned(), range.end_bound().cloned()).map(Span)
+        bridge::client::FreeFunctions::span_subspan(
+            self.0.span,
+            range.start_bound().cloned(),
+            range.end_bound().cloned(),
+        )
+        .map(Span)
     }
 
     fn with_symbol_and_suffix<R>(&self, f: impl FnOnce(&str, &str) -> R) -> R {
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
index 32725afc55272..11bef8fbb85be 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
@@ -58,13 +58,19 @@ impl server::FreeFunctions for RaSpanServer<'_> {
     fn emit_diagnostic(&mut self, _: Diagnostic<Self::Span>) {
         // FIXME handle diagnostic
     }
-}
 
-impl server::TokenStream for RaSpanServer<'_> {
-    fn is_empty(&mut self, stream: &Self::TokenStream) -> bool {
+    fn tt_drop(&mut self, stream: Self::TokenStream) {
+        drop(stream);
+    }
+
+    fn tt_clone(&mut self, stream: &Self::TokenStream) -> Self::TokenStream {
+        stream.clone()
+    }
+
+    fn tt_is_empty(&mut self, stream: &Self::TokenStream) -> bool {
         stream.is_empty()
     }
-    fn from_str(&mut self, src: &str) -> Self::TokenStream {
+    fn tt_from_str(&mut self, src: &str) -> Self::TokenStream {
         Self::TokenStream::from_str(src, self.call_site).unwrap_or_else(|e| {
             Self::TokenStream::from_str(
                 &format!("compile_error!(\"failed to parse str to token stream: {e}\")"),
@@ -73,15 +79,15 @@ impl server::TokenStream for RaSpanServer<'_> {
             .unwrap()
         })
     }
-    fn to_string(&mut self, stream: &Self::TokenStream) -> String {
+    fn tt_to_string(&mut self, stream: &Self::TokenStream) -> String {
         stream.to_string()
     }
 
-    fn from_token_tree(&mut self, tree: TokenTree<Self::Span>) -> Self::TokenStream {
+    fn tt_from_token_tree(&mut self, tree: TokenTree<Self::Span>) -> Self::TokenStream {
         Self::TokenStream::new(vec![tree])
     }
 
-    fn expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
+    fn tt_expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
         // FIXME: requires db, more importantly this requires name resolution so we would need to
         // eagerly expand this proc-macro, but we can't know that this proc-macro is eager until we
         // expand it ...
@@ -90,7 +96,7 @@ impl server::TokenStream for RaSpanServer<'_> {
         Ok(self_.clone())
     }
 
-    fn concat_trees(
+    fn tt_concat_trees(
         &mut self,
         base: Option<Self::TokenStream>,
         trees: Vec<TokenTree<Self::Span>>,
@@ -106,7 +112,7 @@ impl server::TokenStream for RaSpanServer<'_> {
         }
     }
 
-    fn concat_streams(
+    fn tt_concat_streams(
         &mut self,
         base: Option<Self::TokenStream>,
         streams: Vec<Self::TokenStream>,
@@ -118,28 +124,26 @@ impl server::TokenStream for RaSpanServer<'_> {
         stream
     }
 
-    fn into_trees(&mut self, stream: Self::TokenStream) -> Vec<TokenTree<Self::Span>> {
+    fn tt_into_trees(&mut self, stream: Self::TokenStream) -> Vec<TokenTree<Self::Span>> {
         (*stream.0).clone()
     }
-}
 
-impl server::Span for RaSpanServer<'_> {
-    fn debug(&mut self, span: Self::Span) -> String {
+    fn span_debug(&mut self, span: Self::Span) -> String {
         format!("{:?}", span)
     }
-    fn file(&mut self, span: Self::Span) -> String {
+    fn span_file(&mut self, span: Self::Span) -> String {
         self.callback.as_mut().map(|cb| cb.file(span.anchor.file_id.file_id())).unwrap_or_default()
     }
-    fn local_file(&mut self, span: Self::Span) -> Option<String> {
+    fn span_local_file(&mut self, span: Self::Span) -> Option<String> {
         self.callback.as_mut().and_then(|cb| cb.local_file(span.anchor.file_id.file_id()))
     }
-    fn save_span(&mut self, _span: Self::Span) -> usize {
+    fn span_save_span(&mut self, _span: Self::Span) -> usize {
         // FIXME, quote is incompatible with third-party tools
         // This is called by the quote proc-macro which is expanded when the proc-macro is compiled
         // As such, r-a will never observe this
         0
     }
-    fn recover_proc_macro_span(&mut self, _id: usize) -> Self::Span {
+    fn span_recover_proc_macro_span(&mut self, _id: usize) -> Self::Span {
         // FIXME, quote is incompatible with third-party tools
         // This is called by the expansion of quote!, r-a will observe this, but we don't have
         // access to the spans that were encoded
@@ -149,23 +153,23 @@ impl server::Span for RaSpanServer<'_> {
     ///
     /// See PR:
     /// https://github.com/rust-lang/rust/pull/55780
-    fn source_text(&mut self, span: Self::Span) -> Option<String> {
+    fn span_source_text(&mut self, span: Self::Span) -> Option<String> {
         self.callback.as_mut()?.source_text(span)
     }
 
-    fn parent(&mut self, _span: Self::Span) -> Option<Self::Span> {
+    fn span_parent(&mut self, _span: Self::Span) -> Option<Self::Span> {
         // FIXME requires db, looks up the parent call site
         None
     }
-    fn source(&mut self, span: Self::Span) -> Self::Span {
+    fn span_source(&mut self, span: Self::Span) -> Self::Span {
         // FIXME requires db, returns the top level call site
         span
     }
-    fn byte_range(&mut self, span: Self::Span) -> Range<usize> {
+    fn span_byte_range(&mut self, span: Self::Span) -> Range<usize> {
         // FIXME requires db to resolve the ast id, THIS IS NOT INCREMENTAL
         Range { start: span.range.start().into(), end: span.range.end().into() }
     }
-    fn join(&mut self, first: Self::Span, second: Self::Span) -> Option<Self::Span> {
+    fn span_join(&mut self, first: Self::Span, second: Self::Span) -> Option<Self::Span> {
         // We can't modify the span range for fixup spans, those are meaningful to fixup, so just
         // prefer the non-fixup span.
         if first.anchor.ast_id == FIXUP_ERASED_FILE_AST_ID_MARKER {
@@ -193,7 +197,7 @@ impl server::Span for RaSpanServer<'_> {
             ctx: second.ctx,
         })
     }
-    fn subspan(
+    fn span_subspan(
         &mut self,
         span: Self::Span,
         start: Bound<usize>,
@@ -237,11 +241,11 @@ impl server::Span for RaSpanServer<'_> {
         })
     }
 
-    fn resolved_at(&mut self, span: Self::Span, at: Self::Span) -> Self::Span {
+    fn span_resolved_at(&mut self, span: Self::Span, at: Self::Span) -> Self::Span {
         Span { ctx: at.ctx, ..span }
     }
 
-    fn end(&mut self, span: Self::Span) -> Self::Span {
+    fn span_end(&mut self, span: Self::Span) -> Self::Span {
         // We can't modify the span range for fixup spans, those are meaningful to fixup.
         if span.anchor.ast_id == FIXUP_ERASED_FILE_AST_ID_MARKER {
             return span;
@@ -249,7 +253,7 @@ impl server::Span for RaSpanServer<'_> {
         Span { range: TextRange::empty(span.range.end()), ..span }
     }
 
-    fn start(&mut self, span: Self::Span) -> Self::Span {
+    fn span_start(&mut self, span: Self::Span) -> Self::Span {
         // We can't modify the span range for fixup spans, those are meaningful to fixup.
         if span.anchor.ast_id == FIXUP_ERASED_FILE_AST_ID_MARKER {
             return span;
@@ -257,24 +261,28 @@ impl server::Span for RaSpanServer<'_> {
         Span { range: TextRange::empty(span.range.start()), ..span }
     }
 
-    fn line(&mut self, _span: Self::Span) -> usize {
+    fn span_line(&mut self, _span: Self::Span) -> usize {
         // FIXME requires db to resolve line index, THIS IS NOT INCREMENTAL
         1
     }
 
-    fn column(&mut self, _span: Self::Span) -> usize {
+    fn span_column(&mut self, _span: Self::Span) -> usize {
         // FIXME requires db to resolve line index, THIS IS NOT INCREMENTAL
         1
     }
-}
 
-impl server::Symbol for RaSpanServer<'_> {
-    fn normalize_and_validate_ident(&mut self, string: &str) -> Result<Self::Symbol, ()> {
+    fn symbol_normalize_and_validate_ident(&mut self, string: &str) -> Result<Self::Symbol, ()> {
         // FIXME: nfc-normalize and validate idents
         Ok(<Self as server::Server>::intern_symbol(string))
     }
 }
 
+impl server::TokenStream for RaSpanServer<'_> {}
+
+impl server::Span for RaSpanServer<'_> {}
+
+impl server::Symbol for RaSpanServer<'_> {}
+
 impl server::Server for RaSpanServer<'_> {
     fn globals(&mut self) -> ExpnGlobals<Self::Span> {
         ExpnGlobals {
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
index a968ea4cd225e..be843d5c878a8 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
@@ -61,13 +61,19 @@ impl server::FreeFunctions for SpanIdServer<'_> {
     }
 
     fn emit_diagnostic(&mut self, _: Diagnostic<Self::Span>) {}
-}
 
-impl server::TokenStream for SpanIdServer<'_> {
-    fn is_empty(&mut self, stream: &Self::TokenStream) -> bool {
+    fn tt_drop(&mut self, stream: Self::TokenStream) {
+        drop(stream);
+    }
+
+    fn tt_clone(&mut self, stream: &Self::TokenStream) -> Self::TokenStream {
+        stream.clone()
+    }
+
+    fn tt_is_empty(&mut self, stream: &Self::TokenStream) -> bool {
         stream.is_empty()
     }
-    fn from_str(&mut self, src: &str) -> Self::TokenStream {
+    fn tt_from_str(&mut self, src: &str) -> Self::TokenStream {
         Self::TokenStream::from_str(src, self.call_site).unwrap_or_else(|e| {
             Self::TokenStream::from_str(
                 &format!("compile_error!(\"failed to parse str to token stream: {e}\")"),
@@ -76,18 +82,18 @@ impl server::TokenStream for SpanIdServer<'_> {
             .unwrap()
         })
     }
-    fn to_string(&mut self, stream: &Self::TokenStream) -> String {
+    fn tt_to_string(&mut self, stream: &Self::TokenStream) -> String {
         stream.to_string()
     }
-    fn from_token_tree(&mut self, tree: TokenTree<Self::Span>) -> Self::TokenStream {
+    fn tt_from_token_tree(&mut self, tree: TokenTree<Self::Span>) -> Self::TokenStream {
         Self::TokenStream::new(vec![tree])
     }
 
-    fn expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
+    fn tt_expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
         Ok(self_.clone())
     }
 
-    fn concat_trees(
+    fn tt_concat_trees(
         &mut self,
         base: Option<Self::TokenStream>,
         trees: Vec<TokenTree<Self::Span>>,
@@ -103,7 +109,7 @@ impl server::TokenStream for SpanIdServer<'_> {
         }
     }
 
-    fn concat_streams(
+    fn tt_concat_streams(
         &mut self,
         base: Option<Self::TokenStream>,
         streams: Vec<Self::TokenStream>,
@@ -115,49 +121,47 @@ impl server::TokenStream for SpanIdServer<'_> {
         stream
     }
 
-    fn into_trees(&mut self, stream: Self::TokenStream) -> Vec<TokenTree<Self::Span>> {
+    fn tt_into_trees(&mut self, stream: Self::TokenStream) -> Vec<TokenTree<Self::Span>> {
         (*stream.0).clone()
     }
-}
 
-impl server::Span for SpanIdServer<'_> {
-    fn debug(&mut self, span: Self::Span) -> String {
+    fn span_debug(&mut self, span: Self::Span) -> String {
         format!("{:?}", span.0)
     }
-    fn file(&mut self, _span: Self::Span) -> String {
+    fn span_file(&mut self, _span: Self::Span) -> String {
         String::new()
     }
-    fn local_file(&mut self, _span: Self::Span) -> Option<String> {
+    fn span_local_file(&mut self, _span: Self::Span) -> Option<String> {
         None
     }
-    fn save_span(&mut self, _span: Self::Span) -> usize {
+    fn span_save_span(&mut self, _span: Self::Span) -> usize {
         0
     }
-    fn recover_proc_macro_span(&mut self, _id: usize) -> Self::Span {
+    fn span_recover_proc_macro_span(&mut self, _id: usize) -> Self::Span {
         self.call_site
     }
     /// Recent feature, not yet in the proc_macro
     ///
     /// See PR:
     /// https://github.com/rust-lang/rust/pull/55780
-    fn source_text(&mut self, _span: Self::Span) -> Option<String> {
+    fn span_source_text(&mut self, _span: Self::Span) -> Option<String> {
         None
     }
 
-    fn parent(&mut self, _span: Self::Span) -> Option<Self::Span> {
+    fn span_parent(&mut self, _span: Self::Span) -> Option<Self::Span> {
         None
     }
-    fn source(&mut self, span: Self::Span) -> Self::Span {
+    fn span_source(&mut self, span: Self::Span) -> Self::Span {
         span
     }
-    fn byte_range(&mut self, _span: Self::Span) -> Range<usize> {
+    fn span_byte_range(&mut self, _span: Self::Span) -> Range<usize> {
         Range { start: 0, end: 0 }
     }
-    fn join(&mut self, first: Self::Span, _second: Self::Span) -> Option<Self::Span> {
+    fn span_join(&mut self, first: Self::Span, _second: Self::Span) -> Option<Self::Span> {
         // Just return the first span again, because some macros will unwrap the result.
         Some(first)
     }
-    fn subspan(
+    fn span_subspan(
         &mut self,
         span: Self::Span,
         _start: Bound<usize>,
@@ -166,34 +170,38 @@ impl server::Span for SpanIdServer<'_> {
         // Just return the span again, because some macros will unwrap the result.
         Some(span)
     }
-    fn resolved_at(&mut self, _span: Self::Span, _at: Self::Span) -> Self::Span {
+    fn span_resolved_at(&mut self, _span: Self::Span, _at: Self::Span) -> Self::Span {
         self.call_site
     }
 
-    fn end(&mut self, _self_: Self::Span) -> Self::Span {
+    fn span_end(&mut self, _self_: Self::Span) -> Self::Span {
         self.call_site
     }
 
-    fn start(&mut self, _self_: Self::Span) -> Self::Span {
+    fn span_start(&mut self, _self_: Self::Span) -> Self::Span {
         self.call_site
     }
 
-    fn line(&mut self, _span: Self::Span) -> usize {
+    fn span_line(&mut self, _span: Self::Span) -> usize {
         1
     }
 
-    fn column(&mut self, _span: Self::Span) -> usize {
+    fn span_column(&mut self, _span: Self::Span) -> usize {
         1
     }
-}
 
-impl server::Symbol for SpanIdServer<'_> {
-    fn normalize_and_validate_ident(&mut self, string: &str) -> Result<Self::Symbol, ()> {
+    fn symbol_normalize_and_validate_ident(&mut self, string: &str) -> Result<Self::Symbol, ()> {
         // FIXME: nfc-normalize and validate idents
         Ok(<Self as server::Server>::intern_symbol(string))
     }
 }
 
+impl server::TokenStream for SpanIdServer<'_> {}
+
+impl server::Span for SpanIdServer<'_> {}
+
+impl server::Symbol for SpanIdServer<'_> {}
+
 impl server::Server for SpanIdServer<'_> {
     fn globals(&mut self) -> ExpnGlobals<Self::Span> {
         ExpnGlobals {

From 31c696d0623ca7d35ceb7b4f8a94d24b7bc166b0 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 22 Jan 2026 18:28:51 +0000
Subject: [PATCH 11/27] Various simplifications after moving all bridge methods
 to a single type

---
 .../rustc_expand/src/proc_macro_server.rs     |  6 --
 library/proc_macro/src/bridge/client.rs       | 15 ++--
 library/proc_macro/src/bridge/mod.rs          | 29 +++-----
 library/proc_macro/src/bridge/server.rs       | 73 ++++++++++---------
 .../src/server_impl/rust_analyzer_span.rs     |  6 --
 .../src/server_impl/token_id.rs               |  6 --
 6 files changed, 60 insertions(+), 75 deletions(-)

diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index 4f8ff5588581d..1bf2edafd7fdb 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -844,12 +844,6 @@ impl server::FreeFunctions for Rustc<'_, '_> {
     }
 }
 
-impl server::TokenStream for Rustc<'_, '_> {}
-
-impl server::Span for Rustc<'_, '_> {}
-
-impl server::Symbol for Rustc<'_, '_> {}
-
 impl server::Server for Rustc<'_, '_> {
     fn globals(&mut self) -> ExpnGlobals<Self::Span> {
         ExpnGlobals {
diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index d954177e7df55..ffbf6767833f9 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -103,16 +103,19 @@ pub(crate) use super::FreeFunctions;
 pub(crate) use super::symbol::Symbol;
 
 macro_rules! define_client_side {
-    ($($name:ident {
-        $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
-    }),* $(,)?) => {
-        $(impl $name {
+    (
+        FreeFunctions {
+            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
+        },
+        $($name:ident),* $(,)?
+    ) => {
+        impl FreeFunctions {
             $(pub(crate) fn $method($($arg: $arg_ty),*) $(-> $ret_ty)? {
                 Bridge::with(|bridge| {
                     let mut buf = bridge.cached_buffer.take();
 
                     buf.clear();
-                    api_tags::Method::$name(api_tags::$name::$method).encode(&mut buf, &mut ());
+                    api_tags::Method::$method.encode(&mut buf, &mut ());
                     $($arg.encode(&mut buf, &mut ());)*
 
                     buf = bridge.dispatch.call(buf);
@@ -124,7 +127,7 @@ macro_rules! define_client_side {
                     r.unwrap_or_else(|e| panic::resume_unwind(e.into()))
                 })
             })*
-        })*
+        }
     }
 }
 with_api!(self, self, define_client_side);
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 027f94c36ff27..ae0f5974de520 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -21,14 +21,15 @@ use crate::{Delimiter, Level, Spacing};
 /// `with_api!(MySelf, my_self, my_macro)` expands to:
 /// ```rust,ignore (pseudo-code)
 /// my_macro! {
-///     // ...
-///     Literal {
+///     FreeFunctions {
 ///         // ...
-///         fn character(ch: char) -> MySelf::Literal;
+///         fn lit_character(ch: char) -> MySelf::Literal;
 ///         // ...
-///         fn span(my_self: &MySelf::Literal) -> MySelf::Span;
-///         fn set_span(my_self: &mut MySelf::Literal, span: MySelf::Span);
+///         fn lit_span(my_self: &MySelf::Literal) -> MySelf::Span;
+///         fn lit_set_span(my_self: &mut MySelf::Literal, span: MySelf::Span);
 ///     },
+///     Literal,
+///     Span,
 ///     // ...
 /// }
 /// ```
@@ -95,9 +96,9 @@ macro_rules! with_api {
 
                 fn symbol_normalize_and_validate_ident(string: &str) -> Result<$S::Symbol, ()>;
             },
-            TokenStream {},
-            Span {},
-            Symbol {},
+            TokenStream,
+            Span,
+            Symbol,
         }
     };
 }
@@ -160,18 +161,12 @@ mod api_tags {
             FreeFunctions {
                 $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
             },
-            $($name:ident { $($x:tt)* }),* $(,)?
+            $($name:ident),* $(,)?
         ) => {
-            pub(super) enum FreeFunctions {
-                $($method),*
-            }
-            rpc_encode_decode!(enum FreeFunctions { $($method),* });
-
-
             pub(super) enum Method {
-                FreeFunctions(FreeFunctions),
+                $($method),*
             }
-            rpc_encode_decode!(enum Method { FreeFunctions(m) });
+            rpc_encode_decode!(enum Method { $($method),* });
         }
     }
     with_api!(self, self, declare_tags);
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index 16037ed46f063..7701ba6899f63 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -61,14 +61,17 @@ pub trait Types {
 }
 
 macro_rules! declare_server_traits {
-    ($($name:ident {
-        $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
-    }),* $(,)?) => {
-        $(pub trait $name: Types {
+    (
+        FreeFunctions {
+            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
+        },
+        $($name:ident),* $(,)?
+    ) => {
+        pub trait FreeFunctions: Types {
             $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)?;)*
-        })*
+        }
 
-        pub trait Server: Types $(+ $name)* {
+        pub trait Server: Types + FreeFunctions {
             fn globals(&mut self) -> ExpnGlobals<Self::Span>;
 
             /// Intern a symbol received from RPC
@@ -96,18 +99,22 @@ impl<S: Server> Server for MarkedTypes<S> {
 }
 
 macro_rules! define_mark_types_impls {
-    ($($name:ident {
-        $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
-    }),* $(,)?) => {
+    (
+        FreeFunctions {
+            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
+        },
+        $($name:ident),* $(,)?
+    ) => {
         impl<S: Types> Types for MarkedTypes<S> {
+            type FreeFunctions = Marked<S::FreeFunctions, client::FreeFunctions>;
             $(type $name = Marked<S::$name, client::$name>;)*
         }
 
-        $(impl<S: $name> $name for MarkedTypes<S> {
+        impl<S: FreeFunctions> FreeFunctions for MarkedTypes<S> {
             $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)? {
-                <_>::mark($name::$method(&mut self.0, $($arg.unmark()),*))
+                <_>::mark(FreeFunctions::$method(&mut self.0, $($arg.unmark()),*))
             })*
-        })*
+        }
     }
 }
 with_api!(Self, self_, define_mark_types_impls);
@@ -122,7 +129,7 @@ macro_rules! define_dispatcher_impl {
         FreeFunctions {
             $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         },
-        $($name:ident { $($x:tt)* }),* $(,)?
+        $($name:ident),* $(,)?
     ) => {
         // FIXME(eddyb) `pub` only for `ExecutionStrategy` below.
         pub trait DispatcherTrait {
@@ -142,27 +149,25 @@ macro_rules! define_dispatcher_impl {
 
                 let mut reader = &buf[..];
                 match api_tags::Method::decode(&mut reader, &mut ()) {
-                    api_tags::Method::FreeFunctions(m) => match m {
-                        $(api_tags::FreeFunctions::$method => {
-                            let mut call_method = || {
-                                $(let $arg = <$arg_ty>::decode(&mut reader, handle_store);)*
-                                FreeFunctions::$method(server, $($arg),*)
-                            };
-                            // HACK(eddyb) don't use `panic::catch_unwind` in a panic.
-                            // If client and server happen to use the same `std`,
-                            // `catch_unwind` asserts that the panic counter was 0,
-                            // even when the closure passed to it didn't panic.
-                            let r = if thread::panicking() {
-                                Ok(call_method())
-                            } else {
-                                panic::catch_unwind(panic::AssertUnwindSafe(call_method))
-                                    .map_err(PanicMessage::from)
-                            };
-
-                            buf.clear();
-                            r.encode(&mut buf, handle_store);
-                        })*
-                    }
+                    $(api_tags::Method::$method => {
+                        let mut call_method = || {
+                            $(let $arg = <$arg_ty>::decode(&mut reader, handle_store);)*
+                            FreeFunctions::$method(server, $($arg),*)
+                        };
+                        // HACK(eddyb) don't use `panic::catch_unwind` in a panic.
+                        // If client and server happen to use the same `std`,
+                        // `catch_unwind` asserts that the panic counter was 0,
+                        // even when the closure passed to it didn't panic.
+                        let r = if thread::panicking() {
+                            Ok(call_method())
+                        } else {
+                            panic::catch_unwind(panic::AssertUnwindSafe(call_method))
+                                .map_err(PanicMessage::from)
+                        };
+
+                        buf.clear();
+                        r.encode(&mut buf, handle_store);
+                    })*
                 }
                 buf
             }
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
index 11bef8fbb85be..de81ad58239f0 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
@@ -277,12 +277,6 @@ impl server::FreeFunctions for RaSpanServer<'_> {
     }
 }
 
-impl server::TokenStream for RaSpanServer<'_> {}
-
-impl server::Span for RaSpanServer<'_> {}
-
-impl server::Symbol for RaSpanServer<'_> {}
-
 impl server::Server for RaSpanServer<'_> {
     fn globals(&mut self) -> ExpnGlobals<Self::Span> {
         ExpnGlobals {
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
index be843d5c878a8..55b4c37ec7bd4 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
@@ -196,12 +196,6 @@ impl server::FreeFunctions for SpanIdServer<'_> {
     }
 }
 
-impl server::TokenStream for SpanIdServer<'_> {}
-
-impl server::Span for SpanIdServer<'_> {}
-
-impl server::Symbol for SpanIdServer<'_> {}
-
 impl server::Server for SpanIdServer<'_> {
     fn globals(&mut self) -> ExpnGlobals<Self::Span> {
         ExpnGlobals {

From 5c2052aa2ebe4b8dc24047d9402bfad2b90ebfda Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 22 Jan 2026 19:00:17 +0000
Subject: [PATCH 12/27] Merge FreeFunctions trait into Server trait

And rename FreeFunctions struct to Methods.
---
 .../rustc_expand/src/proc_macro_server.rs     | 39 +++++-------
 library/proc_macro/src/bridge/client.rs       | 12 ++--
 library/proc_macro/src/bridge/mod.rs          |  8 +--
 library/proc_macro/src/bridge/server.rs       | 46 ++++++--------
 library/proc_macro/src/bridge/symbol.rs       |  2 +-
 library/proc_macro/src/diagnostic.rs          |  2 +-
 library/proc_macro/src/lib.rs                 | 62 +++++++++----------
 .../src/server_impl/rust_analyzer_span.rs     | 39 +++++-------
 .../src/server_impl/token_id.rs               | 39 +++++-------
 9 files changed, 112 insertions(+), 137 deletions(-)

diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index 1bf2edafd7fdb..4719829d6d3ab 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -431,8 +431,6 @@ impl ToInternal<rustc_errors::Level> for Level {
     }
 }
 
-pub(crate) struct FreeFunctions;
-
 pub(crate) struct Rustc<'a, 'b> {
     ecx: &'a mut ExtCtxt<'b>,
     def_site: Span,
@@ -461,13 +459,28 @@ impl<'a, 'b> Rustc<'a, 'b> {
 }
 
 impl server::Types for Rustc<'_, '_> {
-    type FreeFunctions = FreeFunctions;
     type TokenStream = TokenStream;
     type Span = Span;
     type Symbol = Symbol;
 }
 
-impl server::FreeFunctions for Rustc<'_, '_> {
+impl server::Server for Rustc<'_, '_> {
+    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
+        ExpnGlobals {
+            def_site: self.def_site,
+            call_site: self.call_site,
+            mixed_site: self.mixed_site,
+        }
+    }
+
+    fn intern_symbol(string: &str) -> Self::Symbol {
+        Symbol::intern(string)
+    }
+
+    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
+        f(symbol.as_str())
+    }
+
     fn injected_env_var(&mut self, var: &str) -> Option<String> {
         self.ecx.sess.opts.logical_env.get(var).cloned()
     }
@@ -843,21 +856,3 @@ impl server::FreeFunctions for Rustc<'_, '_> {
         if rustc_lexer::is_ident(sym.as_str()) { Ok(sym) } else { Err(()) }
     }
 }
-
-impl server::Server for Rustc<'_, '_> {
-    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
-        ExpnGlobals {
-            def_site: self.def_site,
-            call_site: self.call_site,
-            mixed_site: self.mixed_site,
-        }
-    }
-
-    fn intern_symbol(string: &str) -> Self::Symbol {
-        Symbol::intern(string)
-    }
-
-    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
-        f(symbol.as_str())
-    }
-}
diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index ffbf6767833f9..058a9420f6e0f 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -25,7 +25,7 @@ impl !Sync for TokenStream {}
 // Forward `Drop::drop` to the inherent `drop` method.
 impl Drop for TokenStream {
     fn drop(&mut self) {
-        FreeFunctions::tt_drop(TokenStream { handle: self.handle });
+        Methods::tt_drop(TokenStream { handle: self.handle });
     }
 }
 
@@ -75,7 +75,7 @@ impl<S> Decode<'_, '_, S> for Span {
 
 impl Clone for TokenStream {
     fn clone(&self) -> Self {
-        FreeFunctions::tt_clone(self)
+        Methods::tt_clone(self)
     }
 }
 
@@ -95,21 +95,21 @@ impl Span {
 
 impl fmt::Debug for Span {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&FreeFunctions::span_debug(*self))
+        f.write_str(&Methods::span_debug(*self))
     }
 }
 
-pub(crate) use super::FreeFunctions;
+pub(crate) use super::Methods;
 pub(crate) use super::symbol::Symbol;
 
 macro_rules! define_client_side {
     (
-        FreeFunctions {
+        Methods {
             $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         },
         $($name:ident),* $(,)?
     ) => {
-        impl FreeFunctions {
+        impl Methods {
             $(pub(crate) fn $method($($arg: $arg_ty),*) $(-> $ret_ty)? {
                 Bridge::with(|bridge| {
                     let mut buf = bridge.cached_buffer.take();
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index ae0f5974de520..429335456316a 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -21,7 +21,7 @@ use crate::{Delimiter, Level, Spacing};
 /// `with_api!(MySelf, my_self, my_macro)` expands to:
 /// ```rust,ignore (pseudo-code)
 /// my_macro! {
-///     FreeFunctions {
+///     Methods {
 ///         // ...
 ///         fn lit_character(ch: char) -> MySelf::Literal;
 ///         // ...
@@ -49,7 +49,7 @@ use crate::{Delimiter, Level, Spacing};
 macro_rules! with_api {
     ($S:ident, $self:ident, $m:ident) => {
         $m! {
-            FreeFunctions {
+            Methods {
                 fn injected_env_var(var: &str) -> Option<String>;
                 fn track_env_var(var: &str, value: Option<&str>);
                 fn track_path(path: &str);
@@ -103,7 +103,7 @@ macro_rules! with_api {
     };
 }
 
-pub(crate) struct FreeFunctions;
+pub(crate) struct Methods;
 
 #[allow(unsafe_code)]
 mod arena;
@@ -158,7 +158,7 @@ mod api_tags {
 
     macro_rules! declare_tags {
         (
-            FreeFunctions {
+            Methods {
                 $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
             },
             $($name:ident),* $(,)?
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index 7701ba6899f63..501c105111091 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -54,7 +54,6 @@ impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>> for Marked<S::Span, c
 }
 
 pub trait Types {
-    type FreeFunctions: 'static;
     type TokenStream: 'static + Clone;
     type Span: 'static + Copy + Eq + Hash;
     type Symbol: 'static;
@@ -62,16 +61,12 @@ pub trait Types {
 
 macro_rules! declare_server_traits {
     (
-        FreeFunctions {
+        Methods {
             $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         },
         $($name:ident),* $(,)?
     ) => {
-        pub trait FreeFunctions: Types {
-            $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)?;)*
-        }
-
-        pub trait Server: Types + FreeFunctions {
+        pub trait Server: Types {
             fn globals(&mut self) -> ExpnGlobals<Self::Span>;
 
             /// Intern a symbol received from RPC
@@ -79,6 +74,8 @@ macro_rules! declare_server_traits {
 
             /// Recover the string value of a symbol, and invoke a callback with it.
             fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str));
+
+            $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)?;)*
         }
     }
 }
@@ -86,33 +83,30 @@ with_api!(Self, self_, declare_server_traits);
 
 pub(super) struct MarkedTypes<S: Types>(S);
 
-impl<S: Server> Server for MarkedTypes<S> {
-    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
-        <_>::mark(Server::globals(&mut self.0))
-    }
-    fn intern_symbol(ident: &str) -> Self::Symbol {
-        <_>::mark(S::intern_symbol(ident))
-    }
-    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
-        S::with_symbol_string(symbol.unmark(), f)
-    }
-}
-
 macro_rules! define_mark_types_impls {
     (
-        FreeFunctions {
+        Methods {
             $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         },
         $($name:ident),* $(,)?
     ) => {
         impl<S: Types> Types for MarkedTypes<S> {
-            type FreeFunctions = Marked<S::FreeFunctions, client::FreeFunctions>;
             $(type $name = Marked<S::$name, client::$name>;)*
         }
 
-        impl<S: FreeFunctions> FreeFunctions for MarkedTypes<S> {
+        impl<S: Server> Server for MarkedTypes<S> {
+            fn globals(&mut self) -> ExpnGlobals<Self::Span> {
+                <_>::mark(Server::globals(&mut self.0))
+            }
+            fn intern_symbol(ident: &str) -> Self::Symbol {
+                <_>::mark(S::intern_symbol(ident))
+            }
+            fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
+                S::with_symbol_string(symbol.unmark(), f)
+            }
+
             $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)? {
-                <_>::mark(FreeFunctions::$method(&mut self.0, $($arg.unmark()),*))
+                <_>::mark(S::$method(&mut self.0, $($arg.unmark()),*))
             })*
         }
     }
@@ -126,7 +120,7 @@ struct Dispatcher<S: Types> {
 
 macro_rules! define_dispatcher_impl {
     (
-        FreeFunctions {
+        Methods {
             $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
         },
         $($name:ident),* $(,)?
@@ -134,14 +128,12 @@ macro_rules! define_dispatcher_impl {
         // FIXME(eddyb) `pub` only for `ExecutionStrategy` below.
         pub trait DispatcherTrait {
             // HACK(eddyb) these are here to allow `Self::$name` to work below.
-            type FreeFunctions;
             $(type $name;)*
 
             fn dispatch(&mut self, buf: Buffer) -> Buffer;
         }
 
         impl<S: Server> DispatcherTrait for Dispatcher<MarkedTypes<S>> {
-            type FreeFunctions = <MarkedTypes<S> as Types>::FreeFunctions;
             $(type $name = <MarkedTypes<S> as Types>::$name;)*
 
             fn dispatch(&mut self, mut buf: Buffer) -> Buffer {
@@ -152,7 +144,7 @@ macro_rules! define_dispatcher_impl {
                     $(api_tags::Method::$method => {
                         let mut call_method = || {
                             $(let $arg = <$arg_ty>::decode(&mut reader, handle_store);)*
-                            FreeFunctions::$method(server, $($arg),*)
+                            server.$method($($arg),*)
                         };
                         // HACK(eddyb) don't use `panic::catch_unwind` in a panic.
                         // If client and server happen to use the same `std`,
diff --git a/library/proc_macro/src/bridge/symbol.rs b/library/proc_macro/src/bridge/symbol.rs
index 6366ac2e6a939..995527653095d 100644
--- a/library/proc_macro/src/bridge/symbol.rs
+++ b/library/proc_macro/src/bridge/symbol.rs
@@ -46,7 +46,7 @@ impl Symbol {
         if string.is_ascii() {
             Err(())
         } else {
-            client::FreeFunctions::symbol_normalize_and_validate_ident(string)
+            client::Methods::symbol_normalize_and_validate_ident(string)
         }
         .unwrap_or_else(|_| panic!("`{:?}` is not a valid identifier", string))
     }
diff --git a/library/proc_macro/src/diagnostic.rs b/library/proc_macro/src/diagnostic.rs
index 5a209f7c7aa18..39a8ecb2ee52e 100644
--- a/library/proc_macro/src/diagnostic.rs
+++ b/library/proc_macro/src/diagnostic.rs
@@ -170,6 +170,6 @@ impl Diagnostic {
             }
         }
 
-        crate::bridge::client::FreeFunctions::emit_diagnostic(to_internal(self));
+        crate::bridge::client::Methods::emit_diagnostic(to_internal(self));
     }
 }
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index 8d5491e918510..cc2de8d470c9d 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -158,7 +158,7 @@ impl TokenStream {
     /// Checks if this `TokenStream` is empty.
     #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
     pub fn is_empty(&self) -> bool {
-        self.0.as_ref().map(|h| bridge::client::FreeFunctions::tt_is_empty(h)).unwrap_or(true)
+        self.0.as_ref().map(|h| bridge::client::Methods::tt_is_empty(h)).unwrap_or(true)
     }
 
     /// Parses this `TokenStream` as an expression and attempts to expand any
@@ -174,7 +174,7 @@ impl TokenStream {
     #[unstable(feature = "proc_macro_expand", issue = "90765")]
     pub fn expand_expr(&self) -> Result<TokenStream, ExpandError> {
         let stream = self.0.as_ref().ok_or(ExpandError)?;
-        match bridge::client::FreeFunctions::tt_expand_expr(stream) {
+        match bridge::client::Methods::tt_expand_expr(stream) {
             Ok(stream) => Ok(TokenStream(Some(stream))),
             Err(_) => Err(ExpandError),
         }
@@ -193,7 +193,7 @@ impl FromStr for TokenStream {
     type Err = LexError;
 
     fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        Ok(TokenStream(Some(bridge::client::FreeFunctions::tt_from_str(src))))
+        Ok(TokenStream(Some(bridge::client::Methods::tt_from_str(src))))
     }
 }
 
@@ -212,7 +212,7 @@ impl FromStr for TokenStream {
 impl fmt::Display for TokenStream {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self.0 {
-            Some(ts) => write!(f, "{}", bridge::client::FreeFunctions::tt_to_string(ts)),
+            Some(ts) => write!(f, "{}", bridge::client::Methods::tt_to_string(ts)),
             None => Ok(()),
         }
     }
@@ -252,9 +252,7 @@ fn tree_to_bridge_tree(
 #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
 impl From<TokenTree> for TokenStream {
     fn from(tree: TokenTree) -> TokenStream {
-        TokenStream(Some(bridge::client::FreeFunctions::tt_from_token_tree(tree_to_bridge_tree(
-            tree,
-        ))))
+        TokenStream(Some(bridge::client::Methods::tt_from_token_tree(tree_to_bridge_tree(tree))))
     }
 }
 
@@ -283,7 +281,7 @@ impl ConcatTreesHelper {
         if self.trees.is_empty() {
             TokenStream(None)
         } else {
-            TokenStream(Some(bridge::client::FreeFunctions::tt_concat_trees(None, self.trees)))
+            TokenStream(Some(bridge::client::Methods::tt_concat_trees(None, self.trees)))
         }
     }
 
@@ -291,7 +289,7 @@ impl ConcatTreesHelper {
         if self.trees.is_empty() {
             return;
         }
-        stream.0 = Some(bridge::client::FreeFunctions::tt_concat_trees(stream.0.take(), self.trees))
+        stream.0 = Some(bridge::client::Methods::tt_concat_trees(stream.0.take(), self.trees))
     }
 }
 
@@ -316,7 +314,7 @@ impl ConcatStreamsHelper {
         if self.streams.len() <= 1 {
             TokenStream(self.streams.pop())
         } else {
-            TokenStream(Some(bridge::client::FreeFunctions::tt_concat_streams(None, self.streams)))
+            TokenStream(Some(bridge::client::Methods::tt_concat_streams(None, self.streams)))
         }
     }
 
@@ -328,7 +326,7 @@ impl ConcatStreamsHelper {
         if base.is_none() && self.streams.len() == 1 {
             stream.0 = self.streams.pop();
         } else {
-            stream.0 = Some(bridge::client::FreeFunctions::tt_concat_streams(base, self.streams));
+            stream.0 = Some(bridge::client::Methods::tt_concat_streams(base, self.streams));
         }
     }
 }
@@ -441,7 +439,7 @@ pub mod token_stream {
         fn into_iter(self) -> IntoIter {
             IntoIter(
                 self.0
-                    .map(|v| bridge::client::FreeFunctions::tt_into_trees(v))
+                    .map(|v| bridge::client::Methods::tt_into_trees(v))
                     .unwrap_or_default()
                     .into_iter(),
             )
@@ -516,7 +514,7 @@ impl Span {
     /// `self` was generated from, if any.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn parent(&self) -> Option<Span> {
-        bridge::client::FreeFunctions::span_parent(self.0).map(Span)
+        bridge::client::Methods::span_parent(self.0).map(Span)
     }
 
     /// The span for the origin source code that `self` was generated from. If
@@ -524,25 +522,25 @@ impl Span {
     /// value is the same as `*self`.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn source(&self) -> Span {
-        Span(bridge::client::FreeFunctions::span_source(self.0))
+        Span(bridge::client::Methods::span_source(self.0))
     }
 
     /// Returns the span's byte position range in the source file.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn byte_range(&self) -> Range<usize> {
-        bridge::client::FreeFunctions::span_byte_range(self.0)
+        bridge::client::Methods::span_byte_range(self.0)
     }
 
     /// Creates an empty span pointing to directly before this span.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn start(&self) -> Span {
-        Span(bridge::client::FreeFunctions::span_start(self.0))
+        Span(bridge::client::Methods::span_start(self.0))
     }
 
     /// Creates an empty span pointing to directly after this span.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn end(&self) -> Span {
-        Span(bridge::client::FreeFunctions::span_end(self.0))
+        Span(bridge::client::Methods::span_end(self.0))
     }
 
     /// The one-indexed line of the source file where the span starts.
@@ -550,7 +548,7 @@ impl Span {
     /// To obtain the line of the span's end, use `span.end().line()`.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn line(&self) -> usize {
-        bridge::client::FreeFunctions::span_line(self.0)
+        bridge::client::Methods::span_line(self.0)
     }
 
     /// The one-indexed column of the source file where the span starts.
@@ -558,7 +556,7 @@ impl Span {
     /// To obtain the column of the span's end, use `span.end().column()`.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn column(&self) -> usize {
-        bridge::client::FreeFunctions::span_column(self.0)
+        bridge::client::Methods::span_column(self.0)
     }
 
     /// The path to the source file in which this span occurs, for display purposes.
@@ -567,7 +565,7 @@ impl Span {
     /// It might be remapped (e.g. `"/src/lib.rs"`) or an artificial path (e.g. `"<command line>"`).
     #[stable(feature = "proc_macro_span_file", since = "1.88.0")]
     pub fn file(&self) -> String {
-        bridge::client::FreeFunctions::span_file(self.0)
+        bridge::client::Methods::span_file(self.0)
     }
 
     /// The path to the source file in which this span occurs on the local file system.
@@ -577,7 +575,7 @@ impl Span {
     /// This path should not be embedded in the output of the macro; prefer `file()` instead.
     #[stable(feature = "proc_macro_span_file", since = "1.88.0")]
     pub fn local_file(&self) -> Option<PathBuf> {
-        bridge::client::FreeFunctions::span_local_file(self.0).map(PathBuf::from)
+        bridge::client::Methods::span_local_file(self.0).map(PathBuf::from)
     }
 
     /// Creates a new span encompassing `self` and `other`.
@@ -585,14 +583,14 @@ impl Span {
     /// Returns `None` if `self` and `other` are from different files.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn join(&self, other: Span) -> Option<Span> {
-        bridge::client::FreeFunctions::span_join(self.0, other.0).map(Span)
+        bridge::client::Methods::span_join(self.0, other.0).map(Span)
     }
 
     /// Creates a new span with the same line/column information as `self` but
     /// that resolves symbols as though it were at `other`.
     #[stable(feature = "proc_macro_span_resolved_at", since = "1.45.0")]
     pub fn resolved_at(&self, other: Span) -> Span {
-        Span(bridge::client::FreeFunctions::span_resolved_at(self.0, other.0))
+        Span(bridge::client::Methods::span_resolved_at(self.0, other.0))
     }
 
     /// Creates a new span with the same name resolution behavior as `self` but
@@ -617,21 +615,21 @@ impl Span {
     /// be used for diagnostics only.
     #[stable(feature = "proc_macro_source_text", since = "1.66.0")]
     pub fn source_text(&self) -> Option<String> {
-        bridge::client::FreeFunctions::span_source_text(self.0)
+        bridge::client::Methods::span_source_text(self.0)
     }
 
     // Used by the implementation of `Span::quote`
     #[doc(hidden)]
     #[unstable(feature = "proc_macro_internals", issue = "27812")]
     pub fn save_span(&self) -> usize {
-        bridge::client::FreeFunctions::span_save_span(self.0)
+        bridge::client::Methods::span_save_span(self.0)
     }
 
     // Used by the implementation of `Span::quote`
     #[doc(hidden)]
     #[unstable(feature = "proc_macro_internals", issue = "27812")]
     pub fn recover_proc_macro_span(id: usize) -> Span {
-        Span(bridge::client::FreeFunctions::span_recover_proc_macro_span(id))
+        Span(bridge::client::Methods::span_recover_proc_macro_span(id))
     }
 
     diagnostic_method!(error, Level::Error);
@@ -1396,7 +1394,7 @@ impl Literal {
     // was 'c' or whether it was '\u{63}'.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
-        bridge::client::FreeFunctions::span_subspan(
+        bridge::client::Methods::span_subspan(
             self.0.span,
             range.start_bound().cloned(),
             range.end_bound().cloned(),
@@ -1571,7 +1569,7 @@ impl FromStr for Literal {
     type Err = LexError;
 
     fn from_str(src: &str) -> Result<Self, LexError> {
-        match bridge::client::FreeFunctions::literal_from_str(src) {
+        match bridge::client::Methods::literal_from_str(src) {
             Ok(literal) => Ok(Literal(literal)),
             Err(()) => Err(LexError),
         }
@@ -1626,9 +1624,9 @@ pub mod tracked {
     #[unstable(feature = "proc_macro_tracked_env", issue = "99515")]
     pub fn env_var<K: AsRef<OsStr> + AsRef<str>>(key: K) -> Result<String, VarError> {
         let key: &str = key.as_ref();
-        let value = crate::bridge::client::FreeFunctions::injected_env_var(key)
-            .map_or_else(|| env::var(key), Ok);
-        crate::bridge::client::FreeFunctions::track_env_var(key, value.as_deref().ok());
+        let value =
+            crate::bridge::client::Methods::injected_env_var(key).map_or_else(|| env::var(key), Ok);
+        crate::bridge::client::Methods::track_env_var(key, value.as_deref().ok());
         value
     }
 
@@ -1638,6 +1636,6 @@ pub mod tracked {
     #[unstable(feature = "proc_macro_tracked_path", issue = "99515")]
     pub fn path<P: AsRef<Path>>(path: P) {
         let path: &str = path.as_ref().to_str().unwrap();
-        crate::bridge::client::FreeFunctions::track_path(path);
+        crate::bridge::client::Methods::track_path(path);
     }
 }
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
index de81ad58239f0..609eee0bd4666 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
@@ -19,8 +19,6 @@ use crate::{
     server_impl::literal_from_str,
 };
 
-pub struct FreeFunctions;
-
 pub struct RaSpanServer<'a> {
     // FIXME: Report this back to the caller to track as dependencies
     pub tracked_env_vars: HashMap<Box<str>, Option<Box<str>>>,
@@ -33,13 +31,28 @@ pub struct RaSpanServer<'a> {
 }
 
 impl server::Types for RaSpanServer<'_> {
-    type FreeFunctions = FreeFunctions;
     type TokenStream = crate::token_stream::TokenStream<Span>;
     type Span = Span;
     type Symbol = Symbol;
 }
 
-impl server::FreeFunctions for RaSpanServer<'_> {
+impl server::Server for RaSpanServer<'_> {
+    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
+        ExpnGlobals {
+            def_site: self.def_site,
+            call_site: self.call_site,
+            mixed_site: self.mixed_site,
+        }
+    }
+
+    fn intern_symbol(ident: &str) -> Self::Symbol {
+        Symbol::intern(ident)
+    }
+
+    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
+        f(symbol.as_str())
+    }
+
     fn injected_env_var(&mut self, _: &str) -> Option<std::string::String> {
         None
     }
@@ -276,21 +289,3 @@ impl server::FreeFunctions for RaSpanServer<'_> {
         Ok(<Self as server::Server>::intern_symbol(string))
     }
 }
-
-impl server::Server for RaSpanServer<'_> {
-    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
-        ExpnGlobals {
-            def_site: self.def_site,
-            call_site: self.call_site,
-            mixed_site: self.mixed_site,
-        }
-    }
-
-    fn intern_symbol(ident: &str) -> Self::Symbol {
-        Symbol::intern(ident)
-    }
-
-    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
-        f(symbol.as_str())
-    }
-}
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
index 55b4c37ec7bd4..d6b1cf4b743f3 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
@@ -25,8 +25,6 @@ impl std::fmt::Debug for SpanId {
 
 type Span = SpanId;
 
-pub struct FreeFunctions;
-
 pub struct SpanIdServer<'a> {
     // FIXME: Report this back to the caller to track as dependencies
     pub tracked_env_vars: HashMap<Box<str>, Option<Box<str>>>,
@@ -39,13 +37,28 @@ pub struct SpanIdServer<'a> {
 }
 
 impl server::Types for SpanIdServer<'_> {
-    type FreeFunctions = FreeFunctions;
     type TokenStream = crate::token_stream::TokenStream<Span>;
     type Span = Span;
     type Symbol = Symbol;
 }
 
-impl server::FreeFunctions for SpanIdServer<'_> {
+impl server::Server for SpanIdServer<'_> {
+    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
+        ExpnGlobals {
+            def_site: self.def_site,
+            call_site: self.call_site,
+            mixed_site: self.mixed_site,
+        }
+    }
+
+    fn intern_symbol(ident: &str) -> Self::Symbol {
+        Symbol::intern(ident)
+    }
+
+    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
+        f(symbol.as_str())
+    }
+
     fn injected_env_var(&mut self, _: &str) -> Option<std::string::String> {
         None
     }
@@ -195,21 +208,3 @@ impl server::FreeFunctions for SpanIdServer<'_> {
         Ok(<Self as server::Server>::intern_symbol(string))
     }
 }
-
-impl server::Server for SpanIdServer<'_> {
-    fn globals(&mut self) -> ExpnGlobals<Self::Span> {
-        ExpnGlobals {
-            def_site: self.def_site,
-            call_site: self.call_site,
-            mixed_site: self.mixed_site,
-        }
-    }
-
-    fn intern_symbol(ident: &str) -> Self::Symbol {
-        Symbol::intern(ident)
-    }
-
-    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
-        f(symbol.as_str())
-    }
-}

From 44fcd0429cd917b7927ac7b1467ee004e88cb7d4 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 3 Oct 2025 21:49:48 +0000
Subject: [PATCH 13/27] Get rid of MarkedTypes

---
 library/proc_macro/src/bridge/server.rs | 94 +++++++++----------------
 library/proc_macro/src/bridge/symbol.rs | 12 ++--
 2 files changed, 38 insertions(+), 68 deletions(-)

diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index 501c105111091..b79de99844533 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -6,8 +6,8 @@ use std::marker::PhantomData;
 use super::*;
 
 pub(super) struct HandleStore<S: Types> {
-    token_stream: handle::OwnedStore<S::TokenStream>,
-    span: handle::InternedStore<S::Span>,
+    token_stream: handle::OwnedStore<Marked<S::TokenStream, client::TokenStream>>,
+    span: handle::InternedStore<Marked<S::Span, client::Span>>,
 }
 
 impl<S: Types> HandleStore<S> {
@@ -19,36 +19,34 @@ impl<S: Types> HandleStore<S> {
     }
 }
 
-impl<S: Types> Encode<HandleStore<MarkedTypes<S>>> for Marked<S::TokenStream, client::TokenStream> {
-    fn encode(self, w: &mut Writer, s: &mut HandleStore<MarkedTypes<S>>) {
+impl<S: Types> Encode<HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
+    fn encode(self, w: &mut Writer, s: &mut HandleStore<S>) {
         s.token_stream.alloc(self).encode(w, s);
     }
 }
 
-impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>>
-    for Marked<S::TokenStream, client::TokenStream>
-{
-    fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {
+impl<S: Types> Decode<'_, '_, HandleStore<S>> for Marked<S::TokenStream, client::TokenStream> {
+    fn decode(r: &mut Reader<'_>, s: &mut HandleStore<S>) -> Self {
         s.token_stream.take(handle::Handle::decode(r, &mut ()))
     }
 }
 
-impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>
+impl<'s, S: Types> Decode<'_, 's, HandleStore<S>>
     for &'s Marked<S::TokenStream, client::TokenStream>
 {
-    fn decode(r: &mut Reader<'_>, s: &'s mut HandleStore<MarkedTypes<S>>) -> Self {
+    fn decode(r: &mut Reader<'_>, s: &'s mut HandleStore<S>) -> Self {
         &s.token_stream[handle::Handle::decode(r, &mut ())]
     }
 }
 
-impl<S: Types> Encode<HandleStore<MarkedTypes<S>>> for Marked<S::Span, client::Span> {
-    fn encode(self, w: &mut Writer, s: &mut HandleStore<MarkedTypes<S>>) {
+impl<S: Types> Encode<HandleStore<S>> for Marked<S::Span, client::Span> {
+    fn encode(self, w: &mut Writer, s: &mut HandleStore<S>) {
         s.span.alloc(self).encode(w, s);
     }
 }
 
-impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>> for Marked<S::Span, client::Span> {
-    fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {
+impl<S: Types> Decode<'_, '_, HandleStore<S>> for Marked<S::Span, client::Span> {
+    fn decode(r: &mut Reader<'_>, s: &mut HandleStore<S>) -> Self {
         s.span.copy(handle::Handle::decode(r, &mut ()))
     }
 }
@@ -81,38 +79,6 @@ macro_rules! declare_server_traits {
 }
 with_api!(Self, self_, declare_server_traits);
 
-pub(super) struct MarkedTypes<S: Types>(S);
-
-macro_rules! define_mark_types_impls {
-    (
-        Methods {
-            $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)*;)*
-        },
-        $($name:ident),* $(,)?
-    ) => {
-        impl<S: Types> Types for MarkedTypes<S> {
-            $(type $name = Marked<S::$name, client::$name>;)*
-        }
-
-        impl<S: Server> Server for MarkedTypes<S> {
-            fn globals(&mut self) -> ExpnGlobals<Self::Span> {
-                <_>::mark(Server::globals(&mut self.0))
-            }
-            fn intern_symbol(ident: &str) -> Self::Symbol {
-                <_>::mark(S::intern_symbol(ident))
-            }
-            fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
-                S::with_symbol_string(symbol.unmark(), f)
-            }
-
-            $(fn $method(&mut self, $($arg: $arg_ty),*) $(-> $ret_ty)? {
-                <_>::mark(S::$method(&mut self.0, $($arg.unmark()),*))
-            })*
-        }
-    }
-}
-with_api!(Self, self_, define_mark_types_impls);
-
 struct Dispatcher<S: Types> {
     handle_store: HandleStore<S>,
     server: S,
@@ -133,8 +99,8 @@ macro_rules! define_dispatcher_impl {
             fn dispatch(&mut self, buf: Buffer) -> Buffer;
         }
 
-        impl<S: Server> DispatcherTrait for Dispatcher<MarkedTypes<S>> {
-            $(type $name = <MarkedTypes<S> as Types>::$name;)*
+        impl<S: Server> DispatcherTrait for Dispatcher<S> {
+            $(type $name = Marked<S::$name, client::$name>;)*
 
             fn dispatch(&mut self, mut buf: Buffer) -> Buffer {
                 let Dispatcher { handle_store, server } = self;
@@ -143,8 +109,12 @@ macro_rules! define_dispatcher_impl {
                 match api_tags::Method::decode(&mut reader, &mut ()) {
                     $(api_tags::Method::$method => {
                         let mut call_method = || {
-                            $(let $arg = <$arg_ty>::decode(&mut reader, handle_store);)*
-                            server.$method($($arg),*)
+                            $(let $arg = <$arg_ty>::decode(&mut reader, handle_store).unmark();)*
+                            let r = server.$method($($arg),*);
+                            $(
+                                let r: $ret_ty = Mark::mark(r);
+                            )*
+                            r
                         };
                         // HACK(eddyb) don't use `panic::catch_unwind` in a panic.
                         // If client and server happen to use the same `std`,
@@ -318,8 +288,8 @@ pub trait MessagePipe<T>: Sized {
 
 fn run_server<
     S: Server,
-    I: Encode<HandleStore<MarkedTypes<S>>>,
-    O: for<'a, 's> Decode<'a, 's, HandleStore<MarkedTypes<S>>>,
+    I: Encode<HandleStore<S>>,
+    O: for<'a, 's> Decode<'a, 's, HandleStore<S>>,
 >(
     strategy: &impl ExecutionStrategy,
     handle_counters: &'static client::HandleCounters,
@@ -328,13 +298,13 @@ fn run_server<
     run_client: extern "C" fn(BridgeConfig<'_>) -> Buffer,
     force_show_panics: bool,
 ) -> Result<O, PanicMessage> {
-    let mut dispatcher =
-        Dispatcher { handle_store: HandleStore::new(handle_counters), server: MarkedTypes(server) };
+    let mut dispatcher = Dispatcher { handle_store: HandleStore::new(handle_counters), server };
 
     let globals = dispatcher.server.globals();
 
     let mut buf = Buffer::new();
-    (globals, input).encode(&mut buf, &mut dispatcher.handle_store);
+    (<ExpnGlobals<Marked<S::Span, client::Span>> as Mark>::mark(globals), input)
+        .encode(&mut buf, &mut dispatcher.handle_store);
 
     buf = strategy.run_bridge_and_client(&mut dispatcher, buf, run_client, force_show_panics);
 
@@ -358,11 +328,13 @@ impl client::Client<crate::TokenStream, crate::TokenStream> {
             strategy,
             handle_counters,
             server,
-            <MarkedTypes<S> as Types>::TokenStream::mark(input),
+            <Marked<S::TokenStream, client::TokenStream>>::mark(input),
             run,
             force_show_panics,
         )
-        .map(|s| <Option<<MarkedTypes<S> as Types>::TokenStream>>::unmark(s).unwrap_or_default())
+        .map(|s| {
+            <Option<Marked<S::TokenStream, client::TokenStream>>>::unmark(s).unwrap_or_default()
+        })
     }
 }
 
@@ -385,12 +357,14 @@ impl client::Client<(crate::TokenStream, crate::TokenStream), crate::TokenStream
             handle_counters,
             server,
             (
-                <MarkedTypes<S> as Types>::TokenStream::mark(input),
-                <MarkedTypes<S> as Types>::TokenStream::mark(input2),
+                <Marked<S::TokenStream, client::TokenStream>>::mark(input),
+                <Marked<S::TokenStream, client::TokenStream>>::mark(input2),
             ),
             run,
             force_show_panics,
         )
-        .map(|s| <Option<<MarkedTypes<S> as Types>::TokenStream>>::unmark(s).unwrap_or_default())
+        .map(|s| {
+            <Option<Marked<S::TokenStream, client::TokenStream>>>::unmark(s).unwrap_or_default()
+        })
     }
 }
diff --git a/library/proc_macro/src/bridge/symbol.rs b/library/proc_macro/src/bridge/symbol.rs
index 995527653095d..edba142bad721 100644
--- a/library/proc_macro/src/bridge/symbol.rs
+++ b/library/proc_macro/src/bridge/symbol.rs
@@ -99,18 +99,14 @@ impl<S> Encode<S> for Symbol {
     }
 }
 
-impl<S: server::Server> Decode<'_, '_, server::HandleStore<server::MarkedTypes<S>>>
-    for Marked<S::Symbol, Symbol>
-{
-    fn decode(r: &mut Reader<'_>, s: &mut server::HandleStore<server::MarkedTypes<S>>) -> Self {
+impl<S: server::Server> Decode<'_, '_, server::HandleStore<S>> for Marked<S::Symbol, Symbol> {
+    fn decode(r: &mut Reader<'_>, s: &mut server::HandleStore<S>) -> Self {
         Mark::mark(S::intern_symbol(<&str>::decode(r, s)))
     }
 }
 
-impl<S: server::Server> Encode<server::HandleStore<server::MarkedTypes<S>>>
-    for Marked<S::Symbol, Symbol>
-{
-    fn encode(self, w: &mut Writer, s: &mut server::HandleStore<server::MarkedTypes<S>>) {
+impl<S: server::Server> Encode<server::HandleStore<S>> for Marked<S::Symbol, Symbol> {
+    fn encode(self, w: &mut Writer, s: &mut server::HandleStore<S>) {
         S::with_symbol_string(&self.unmark(), |sym| sym.encode(w, s))
     }
 }

From 76f9a9062ba1f43a30dd4965f40b89a5cbf3b59a Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 22 Jan 2026 19:57:13 +0000
Subject: [PATCH 14/27] Use rustc_proc_macro in rust-analyzer-proc-macro-srv

This fixes stage1 builds when the proc-macro bridge api changed.
The rustc_proc_macro crate is identical to the proc_macro that would end
up in the sysroot of the rustc compiler rustc_proc_macro is linked into.
---
 .../crates/proc-macro-srv/src/bridge.rs       |  2 +-
 .../crates/proc-macro-srv/src/dylib.rs        |  2 +-
 .../proc-macro-srv/src/dylib/proc_macros.rs   |  2 +-
 .../crates/proc-macro-srv/src/lib.rs          |  8 ++--
 .../src/server_impl/rust_analyzer_span.rs     |  2 +-
 .../src/server_impl/token_id.rs               |  2 +-
 .../crates/proc-macro-srv/src/token_stream.rs | 42 +++++++++----------
 7 files changed, 31 insertions(+), 29 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/bridge.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/bridge.rs
index fc063a07b5f8a..fc62f9413a34e 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/bridge.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/bridge.rs
@@ -1,6 +1,6 @@
 //! `proc_macro::bridge` newtypes.
 
-use proc_macro::bridge as pm_bridge;
+use rustc_proc_macro::bridge as pm_bridge;
 
 pub use pm_bridge::{DelimSpan, Diagnostic, ExpnGlobals, LitKind};
 
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib.rs
index 02bdcc50d3871..8680e9180e3ab 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib.rs
@@ -3,7 +3,7 @@
 mod proc_macros;
 mod version;
 
-use proc_macro::bridge;
+use rustc_proc_macro::bridge;
 use std::{fmt, fs, io, time::SystemTime};
 use temp_dir::TempDir;
 
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib/proc_macros.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib/proc_macros.rs
index c763301135ee8..76c5097101c70 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib/proc_macros.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/dylib/proc_macros.rs
@@ -1,6 +1,6 @@
 //! Proc macro ABI
 use crate::{ProcMacroClientHandle, ProcMacroKind, ProcMacroSrvSpan, token_stream::TokenStream};
-use proc_macro::bridge;
+use rustc_proc_macro::bridge;
 
 #[repr(transparent)]
 pub(crate) struct ProcMacros([bridge::client::ProcMacro]);
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
index f2d1dfbba4ccb..920d58b4e981e 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/lib.rs
@@ -22,9 +22,9 @@
 )]
 #![deny(deprecated_safe, clippy::undocumented_unsafe_blocks)]
 
-extern crate proc_macro;
 #[cfg(feature = "in-rust-tree")]
 extern crate rustc_driver as _;
+extern crate rustc_proc_macro;
 
 #[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_lexer as rustc_lexer;
@@ -52,7 +52,7 @@ use temp_dir::TempDir;
 
 pub use crate::server_impl::token_id::SpanId;
 
-pub use proc_macro::Delimiter;
+pub use rustc_proc_macro::Delimiter;
 pub use span;
 
 pub use crate::bridge::*;
@@ -181,7 +181,9 @@ impl ProcMacroSrv<'_> {
 }
 
 pub trait ProcMacroSrvSpan: Copy + Send + Sync {
-    type Server<'a>: proc_macro::bridge::server::Server<TokenStream = crate::token_stream::TokenStream<Self>>;
+    type Server<'a>: rustc_proc_macro::bridge::server::Server<
+            TokenStream = crate::token_stream::TokenStream<Self>,
+        >;
     fn make_server<'a>(
         call_site: Self,
         def_site: Self,
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
index 609eee0bd4666..4f50c04b27996 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
@@ -10,7 +10,7 @@ use std::{
 };
 
 use intern::Symbol;
-use proc_macro::bridge::server;
+use rustc_proc_macro::bridge::server;
 use span::{FIXUP_ERASED_FILE_AST_ID_MARKER, Span, TextRange, TextSize};
 
 use crate::{
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
index d6b1cf4b743f3..cd5ba59095610 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
@@ -6,7 +6,7 @@ use std::{
 };
 
 use intern::Symbol;
-use proc_macro::bridge::server;
+use rustc_proc_macro::bridge::server;
 
 use crate::{
     ProcMacroClientHandle,
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/token_stream.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/token_stream.rs
index 36827d2561f9c..2358f6963c79e 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/token_stream.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/token_stream.rs
@@ -4,8 +4,8 @@ use core::fmt;
 use std::{mem, sync::Arc};
 
 use intern::Symbol;
-use proc_macro::Delimiter;
 use rustc_lexer::{DocStyle, LiteralKind};
+use rustc_proc_macro::Delimiter;
 
 use crate::bridge::{DelimSpan, Group, Ident, LitKind, Literal, Punct, TokenTree};
 
@@ -52,7 +52,7 @@ impl<S> TokenStream<S> {
         S: SpanLike + Copy,
     {
         let mut groups = Vec::new();
-        groups.push((proc_macro::Delimiter::None, 0..0, vec![]));
+        groups.push((rustc_proc_macro::Delimiter::None, 0..0, vec![]));
         let mut offset = 0;
         let mut tokens = rustc_lexer::tokenize(s, rustc_lexer::FrontmatterAllowed::No).peekable();
         while let Some(token) = tokens.next() {
@@ -102,7 +102,7 @@ impl<S> TokenStream<S> {
             };
             match token.kind {
                 rustc_lexer::TokenKind::OpenParen => {
-                    groups.push((proc_macro::Delimiter::Parenthesis, range, vec![]))
+                    groups.push((rustc_proc_macro::Delimiter::Parenthesis, range, vec![]))
                 }
                 rustc_lexer::TokenKind::CloseParen if *open_delim != Delimiter::Parenthesis => {
                     return if *open_delim == Delimiter::None {
@@ -130,7 +130,7 @@ impl<S> TokenStream<S> {
                     );
                 }
                 rustc_lexer::TokenKind::OpenBrace => {
-                    groups.push((proc_macro::Delimiter::Brace, range, vec![]))
+                    groups.push((rustc_proc_macro::Delimiter::Brace, range, vec![]))
                 }
                 rustc_lexer::TokenKind::CloseBrace if *open_delim != Delimiter::Brace => {
                     return if *open_delim == Delimiter::None {
@@ -158,7 +158,7 @@ impl<S> TokenStream<S> {
                     );
                 }
                 rustc_lexer::TokenKind::OpenBracket => {
-                    groups.push((proc_macro::Delimiter::Bracket, range, vec![]))
+                    groups.push((rustc_proc_macro::Delimiter::Bracket, range, vec![]))
                 }
                 rustc_lexer::TokenKind::CloseBracket if *open_delim != Delimiter::Bracket => {
                     return if *open_delim == Delimiter::None {
@@ -460,10 +460,10 @@ fn display_token_tree<S>(
                 f,
                 "{}",
                 match delimiter {
-                    proc_macro::Delimiter::Parenthesis => "(",
-                    proc_macro::Delimiter::Brace => "{",
-                    proc_macro::Delimiter::Bracket => "[",
-                    proc_macro::Delimiter::None => "",
+                    rustc_proc_macro::Delimiter::Parenthesis => "(",
+                    rustc_proc_macro::Delimiter::Brace => "{",
+                    rustc_proc_macro::Delimiter::Bracket => "[",
+                    rustc_proc_macro::Delimiter::None => "",
                 }
             )?;
             if let Some(stream) = stream {
@@ -473,10 +473,10 @@ fn display_token_tree<S>(
                 f,
                 "{}",
                 match delimiter {
-                    proc_macro::Delimiter::Parenthesis => ")",
-                    proc_macro::Delimiter::Brace => "}",
-                    proc_macro::Delimiter::Bracket => "]",
-                    proc_macro::Delimiter::None => "",
+                    rustc_proc_macro::Delimiter::Parenthesis => ")",
+                    rustc_proc_macro::Delimiter::Brace => "}",
+                    rustc_proc_macro::Delimiter::Bracket => "]",
+                    rustc_proc_macro::Delimiter::None => "",
                 }
             )?;
         }
@@ -587,16 +587,16 @@ fn debug_token_tree<S: fmt::Debug>(
                 f,
                 "GROUP {}{} {:#?} {:#?} {:#?}",
                 match delimiter {
-                    proc_macro::Delimiter::Parenthesis => "(",
-                    proc_macro::Delimiter::Brace => "{",
-                    proc_macro::Delimiter::Bracket => "[",
-                    proc_macro::Delimiter::None => "$",
+                    rustc_proc_macro::Delimiter::Parenthesis => "(",
+                    rustc_proc_macro::Delimiter::Brace => "{",
+                    rustc_proc_macro::Delimiter::Bracket => "[",
+                    rustc_proc_macro::Delimiter::None => "$",
                 },
                 match delimiter {
-                    proc_macro::Delimiter::Parenthesis => ")",
-                    proc_macro::Delimiter::Brace => "}",
-                    proc_macro::Delimiter::Bracket => "]",
-                    proc_macro::Delimiter::None => "$",
+                    rustc_proc_macro::Delimiter::Parenthesis => ")",
+                    rustc_proc_macro::Delimiter::Brace => "}",
+                    rustc_proc_macro::Delimiter::Bracket => "]",
+                    rustc_proc_macro::Delimiter::None => "$",
                 },
                 span.open,
                 span.close,

From 0a2bb4b45b5b5344895de12759081b81271dd3b3 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Thu, 22 Jan 2026 20:48:04 +0000
Subject: [PATCH 15/27] Ensure armv7a-none-eabi.md mentions all four targets

---
 .../rustc/src/platform-support/armv7a-none-eabi.md   | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
index 6e08bbb26e466..555f69e81a02f 100644
--- a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
@@ -1,12 +1,14 @@
-# `armv7a-none-eabi` and `thumbv7a-none-eabihf`
+# `armv7a-none-eabi*` and `thumbv7a-none-eabi*`
 
-* **Tier: 2** (`armv7a-none-eabi`)
-* **Tier: 3** (`thumbv7a-none-eabi`)
+* **Tier: 2** (`armv7a-none-eabi` and `armv7a-none-eabihf`)
+* **Tier: 3** (`thumbv7a-none-eabi` and `thumbv7a-none-eabihf`)
 * **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv7-A architecture family, supporting dual
-ARM/Thumb mode. The `armv7a-none-eabi` target uses Arm mode by default and
-the `thumbv7a-none-eabihf` target uses Thumb mode by default.
+ARM/Thumb mode. The `armv7a-none-eabi*` targets use Arm mode by default and the
+`thumbv7a-none-eabi` targets use Thumb mode by default. The `-eabi` targets use
+a soft-float ABI and do not require an FPU, while the `-eabihf` targets use a
+hard-float ABI and do require an FPU.
 
 Note, this is for processors running in AArch32 mode. For the AArch64 mode
 added in Armv8-A, see [`aarch64-unknown-none`](aarch64-unknown-none.md) instead.

From 19d1be5de6d57d56c95c5ee77e493ee894bfbe69 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Thu, 22 Jan 2026 20:48:11 +0000
Subject: [PATCH 16/27] Ensure armv7r-none-eabi.md mentions all four targets

---
 .../src/platform-support/armv7r-none-eabi.md  | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
index 16755ff8c520c..20fd55c6abd68 100644
--- a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
@@ -1,12 +1,14 @@
-# `armv7r-none-eabi` and `armv7r-none-eabihf`
+# `armv7r-none-eabi*` and `thumbv7r-none-eabi*`
 
-* **Tier: 2** (`armv7r-none-eabi`)
-* **Tier: 3** (`thumbv7r-none-eabi`)
+* **Tier: 2** (`armv7r-none-eabi` and `armv7r-none-eabihf`)
+* **Tier: 3** (`thumbv7r-none-eabi` and `thumbv7r-none-eabihf`)
 * **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv7-R architecture family, supporting dual
-ARM/Thumb mode. The `armv7r-none-eabi` target uses Arm mode by default and
-the `thumbv7r-none-eabihf` target uses Thumb mode by default.
+ARM/Thumb mode. The `armv7r-none-eabi*` targets use Arm mode by default and the
+`thumbv7r-none-eabi*` targets use Thumb mode by default. The `-eabi` targets use
+a soft-float ABI and do not require an FPU, while the `-eabihf` targets use a
+hard-float ABI and do require an FPU.
 
 Processors in this family include the [Arm Cortex-R4, 5, 7, and 8][cortex-r].
 
@@ -27,11 +29,11 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Requirements
 
-When using the hardfloat targets, the minimum floating-point features assumed
-are those of the `vfpv3-d16`, which includes single- and double-precision, with
-16 double-precision registers. This floating-point unit appears in Cortex-R4F
-and Cortex-R5F processors. See [VFP in the Cortex-R processors][vfp]
-for more details on the possible FPU variants.
+When using the hardfloat (`-eabibf`) targets, the minimum floating-point
+features assumed are those of the `vfpv3-d16`, which includes single- and
+double-precision, with 16 double-precision registers. This floating-point unit
+appears in Cortex-R4F and Cortex-R5F processors. See [VFP in the Cortex-R
+processors][vfp] for more details on the possible FPU variants.
 
 If your processor supports a different set of floating-point features than the
 default expectations of `vfpv3-d16`, then these should also be enabled or

From fa526c47ccdc2bcc184d49bc7548a57434b0e7b9 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Thu, 22 Jan 2026 20:50:09 +0000
Subject: [PATCH 17/27] Update armv8r-none-eabi.md - note both targets are
 hardfloat

---
 src/doc/rustc/src/platform-support/armv8r-none-eabihf.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
index ad4764122446e..85abac3d7eb89 100644
--- a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
+++ b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
@@ -5,8 +5,9 @@
 * **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv8-R architecture family, supporting dual
-ARM/Thumb mode. The `armv8r-none-eabi` target uses Arm mode by default and
-the `thumbv8r-none-eabihf` target uses Thumb mode by default.
+ARM/Thumb mode. The `armv8r-none-eabihf` target uses Arm mode by default and
+the `thumbv8r-none-eabihf` target uses Thumb mode by default. Both targets
+use a hard-float ABI and require an FPU.
 
 Processors in this family include the Arm [Cortex-R52][cortex-r52]
 and [Cortex-R52+][cortex-r52-plus].

From c609cce8cf6c6a5a1b6e081a671c7ba9f1165fdd Mon Sep 17 00:00:00 2001
From: Andreas Liljeqvist <bonega@gmail.com>
Date: Thu, 22 Jan 2026 22:18:00 +0100
Subject: [PATCH 18/27] Merge is_ascii codegen tests using revisions

Combine the x86_64 and loongarch64 is_ascii tests into a single file
using compiletest revisions. Both now test assembly output:

- X86_64: Verifies no broken kshiftrd/kshiftrq instructions (AVX-512 fix)
- LA64: Verifies vmskltz.b instruction is used (auto-vectorization)
---
 tests/assembly-llvm/slice-is-ascii-avx512.rs | 18 -----------
 tests/assembly-llvm/slice-is-ascii.rs        | 32 ++++++++++++++++++++
 tests/codegen-llvm/slice-is-ascii.rs         | 19 ------------
 3 files changed, 32 insertions(+), 37 deletions(-)
 delete mode 100644 tests/assembly-llvm/slice-is-ascii-avx512.rs
 create mode 100644 tests/assembly-llvm/slice-is-ascii.rs
 delete mode 100644 tests/codegen-llvm/slice-is-ascii.rs

diff --git a/tests/assembly-llvm/slice-is-ascii-avx512.rs b/tests/assembly-llvm/slice-is-ascii-avx512.rs
deleted file mode 100644
index d3a441fec96cb..0000000000000
--- a/tests/assembly-llvm/slice-is-ascii-avx512.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ only-x86_64
-//@ compile-flags: -C opt-level=3 -C target-cpu=znver4
-//@ compile-flags: -C llvm-args=-x86-asm-syntax=intel
-//@ assembly-output: emit-asm
-#![crate_type = "lib"]
-
-// Verify is_ascii uses pmovmskb/vpmovmskb instead of kshiftrd with AVX-512.
-// The fix uses explicit SSE2 intrinsics to avoid LLVM's broken auto-vectorization.
-//
-// See: https://github.com/rust-lang/rust/issues/129293
-
-// CHECK-LABEL: test_is_ascii
-#[no_mangle]
-pub fn test_is_ascii(s: &[u8]) -> bool {
-    // CHECK-NOT: kshiftrd
-    // CHECK-NOT: kshiftrq
-    s.is_ascii()
-}
diff --git a/tests/assembly-llvm/slice-is-ascii.rs b/tests/assembly-llvm/slice-is-ascii.rs
new file mode 100644
index 0000000000000..d01b321bf460a
--- /dev/null
+++ b/tests/assembly-llvm/slice-is-ascii.rs
@@ -0,0 +1,32 @@
+//@ revisions: X86_64 LA64
+//@ assembly-output: emit-asm
+//@ compile-flags: -C opt-level=3
+//
+//@ [X86_64] only-x86_64
+//@ [X86_64] compile-flags: -C target-cpu=znver4
+//@ [X86_64] compile-flags: -C llvm-args=-x86-asm-syntax=intel
+//
+//@ [LA64] only-loongarch64
+
+#![crate_type = "lib"]
+
+/// Verify `is_ascii` generates efficient code on different architectures:
+///
+/// - x86_64: Must NOT use `kshiftrd`/`kshiftrq` (broken AVX-512 auto-vectorization).
+///   The fix uses explicit SSE2 intrinsics (`pmovmskb`/`vpmovmskb`).
+///   See: https://github.com/llvm/llvm-project/issues/176906
+///
+/// - loongarch64: Should use `vmskltz.b` instruction for the fast-path.
+///   This architecture still relies on LLVM auto-vectorization.
+
+// X86_64-LABEL: test_is_ascii
+// X86_64-NOT: kshiftrd
+// X86_64-NOT: kshiftrq
+
+// LA64-LABEL: test_is_ascii
+// LA64: vmskltz.b
+
+#[no_mangle]
+pub fn test_is_ascii(s: &[u8]) -> bool {
+    s.is_ascii()
+}
diff --git a/tests/codegen-llvm/slice-is-ascii.rs b/tests/codegen-llvm/slice-is-ascii.rs
deleted file mode 100644
index 1f41b69e43966..0000000000000
--- a/tests/codegen-llvm/slice-is-ascii.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ only-loongarch64
-//@ compile-flags: -C opt-level=3
-#![crate_type = "lib"]
-
-/// Check that the fast-path of `is_ascii` uses a `vmskltz.b` instruction.
-/// Platforms lacking an equivalent instruction use other techniques for
-/// optimizing `is_ascii`.
-///
-/// Note: x86_64 uses explicit SSE2 intrinsics instead of relying on
-/// auto-vectorization. See `slice-is-ascii-avx512.rs`.
-// CHECK-LABEL: @is_ascii_autovectorized
-#[no_mangle]
-pub fn is_ascii_autovectorized(s: &[u8]) -> bool {
-    // CHECK: load <32 x i8>
-    // CHECK-NEXT: icmp slt <32 x i8>
-    // CHECK-NEXT: bitcast <32 x i1>
-    // CHECK-NEXT: icmp eq i32
-    s.is_ascii()
-}

From 890c0fd4e8a3cbd49b761db2432114b147ae3487 Mon Sep 17 00:00:00 2001
From: Andreas Liljeqvist <bonega@gmail.com>
Date: Thu, 22 Jan 2026 22:41:57 +0100
Subject: [PATCH 19/27] Make is_ascii_sse2 a safe function

Remove the `#[target_feature(enable = "sse2")]` attribute and make the
function safe to call. The SSE2 requirement is already enforced by the
`#[cfg(target_feature = "sse2")]` predicate.

Individual unsafe blocks are used for intrinsic calls with appropriate
SAFETY comments.

Also adds FIXME reference to llvm#176906 for tracking when this
workaround can be removed.
---
 library/core/src/slice/ascii.rs | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/library/core/src/slice/ascii.rs b/library/core/src/slice/ascii.rs
index 25b8a10af3555..459c826f40646 100644
--- a/library/core/src/slice/ascii.rs
+++ b/library/core/src/slice/ascii.rs
@@ -467,11 +467,9 @@ const CHUNK_SIZE: usize = 32;
 /// SSE2 implementation using `_mm_movemask_epi8` (compiles to `pmovmskb`) to
 /// avoid LLVM's broken AVX-512 auto-vectorization of counting loops.
 ///
-/// # Safety
-/// Requires SSE2 support (guaranteed on x86_64).
+/// FIXME(llvm#176906): Remove this workaround once LLVM generates efficient code.
 #[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
-#[target_feature(enable = "sse2")]
-unsafe fn is_ascii_sse2(bytes: &[u8]) -> bool {
+fn is_ascii_sse2(bytes: &[u8]) -> bool {
     use crate::arch::x86_64::{__m128i, _mm_loadu_si128, _mm_movemask_epi8, _mm_or_si128};
 
     let mut i = 0;
@@ -487,12 +485,14 @@ unsafe fn is_ascii_sse2(bytes: &[u8]) -> bool {
         // SAFETY: Same as above - ptr.add(16) is within the valid 32-byte range.
         let chunk2 = unsafe { _mm_loadu_si128(ptr.add(16) as *const __m128i) };
 
-        // OR them together - if any byte has the high bit set, the result will too
-        let combined = _mm_or_si128(chunk1, chunk2);
+        // OR them together - if any byte has the high bit set, the result will too.
+        // SAFETY: SSE2 is guaranteed by the cfg predicate.
+        let combined = unsafe { _mm_or_si128(chunk1, chunk2) };
 
         // Create a mask from the MSBs of each byte.
         // If any byte is >= 128, its MSB is 1, so the mask will be non-zero.
-        let mask = _mm_movemask_epi8(combined);
+        // SAFETY: SSE2 is guaranteed by the cfg predicate.
+        let mask = unsafe { _mm_movemask_epi8(combined) };
 
         if mask != 0 {
             return false;
@@ -541,8 +541,7 @@ const fn is_ascii(bytes: &[u8]) -> bool {
                 return remainder.iter().all(|b| b.is_ascii());
             }
 
-            // SAFETY: SSE2 is guaranteed available on x86_64
-            unsafe { is_ascii_sse2(bytes) }
+            is_ascii_sse2(bytes)
         }
     )
 }

From ff9c5cfd2813aebdfa97057d892b81807d4f2ad8 Mon Sep 17 00:00:00 2001
From: paradoxicalguy <abhinavsrivastav25098@gmail.com>
Date: Thu, 22 Jan 2026 22:37:29 +0000
Subject: [PATCH 20/27] Enable reproducible binary builds with debuginfo on
 Linux

---
 tests/run-make/reproducible-build/rmake.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/run-make/reproducible-build/rmake.rs b/tests/run-make/reproducible-build/rmake.rs
index 93fc30de07d7e..b4796c806a615 100644
--- a/tests/run-make/reproducible-build/rmake.rs
+++ b/tests/run-make/reproducible-build/rmake.rs
@@ -205,7 +205,7 @@ fn diff_dir_test(crate_type: CrateType, remap_type: RemapType) {
                 // See https://github.com/rust-lang/rust/issues/89911
                 // FIXME(#129117): Windows rlib + `-Cdebuginfo=2` + `-Z remap-cwd-prefix=.` seems
                 // to be unreproducible.
-                if !matches!(crate_type, CrateType::Bin) && !is_windows() {
+                if !is_windows() {
                     compiler1.arg("-Cdebuginfo=2");
                     compiler2.arg("-Cdebuginfo=2");
                 }

From 081c4c6abbdefdaab43d42875305db2fdcb359e9 Mon Sep 17 00:00:00 2001
From: bendn <bend.n@outlook.com>
Date: Thu, 22 Jan 2026 21:08:11 +0700
Subject: [PATCH 21/27] reenable tests

---
 library/coretests/tests/bool.rs | 12 ++++++++++--
 library/coretests/tests/lib.rs  |  1 +
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/library/coretests/tests/bool.rs b/library/coretests/tests/bool.rs
index eb5f0f50663e1..3f4588f525783 100644
--- a/library/coretests/tests/bool.rs
+++ b/library/coretests/tests/bool.rs
@@ -89,7 +89,6 @@ fn test_bool_to_option() {
     assert_eq!(false.then(|| 0), None);
     assert_eq!(true.then(|| 0), Some(0));
 
-    /* FIXME(#110395)
     const fn zero() -> i32 {
         0
     }
@@ -103,7 +102,6 @@ fn test_bool_to_option() {
     assert_eq!(B, Some(0));
     assert_eq!(C, None);
     assert_eq!(D, Some(0));
-    */
 }
 
 #[test]
@@ -112,4 +110,14 @@ fn test_bool_to_result() {
     assert_eq!(true.ok_or(0), Ok(()));
     assert_eq!(false.ok_or_else(|| 0), Err(0));
     assert_eq!(true.ok_or_else(|| 0), Ok(()));
+
+    const A: Result<(), i32> = false.ok_or(0);
+    const B: Result<(), i32> = true.ok_or(0);
+    const C: Result<(), i32> = false.ok_or_else(zero);
+    const D: Result<(), i32> = true.ok_or_else(zero);
+
+    assert_eq!(A, Err(0));
+    assert_eq!(B, Ok(()));
+    assert_eq!(C, Err(0));
+    assert_eq!(D, Ok(()));
 }
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 8c91567fc94a0..8cca714b73933 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -17,6 +17,7 @@
 #![feature(clamp_magnitude)]
 #![feature(clone_to_uninit)]
 #![feature(const_array)]
+#![feature(const_bool)]
 #![feature(const_cell_traits)]
 #![feature(const_clone)]
 #![feature(const_cmp)]

From 1e8ffd9ce58ae197e77d819e2be40f6ce0aceef7 Mon Sep 17 00:00:00 2001
From: abhinav srivastav <136164196+paradoxicalguy@users.noreply.github.com>
Date: Fri, 23 Jan 2026 13:10:21 +0530
Subject: [PATCH 22/27] Removed comment on reproducibility issue #89911

Removed comment about reproducibility failures with crate type `bin` and `-Cdebuginfo=2` on non windows machines
issue #89911
---
 tests/run-make/reproducible-build/rmake.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/tests/run-make/reproducible-build/rmake.rs b/tests/run-make/reproducible-build/rmake.rs
index b4796c806a615..993c2c8092a6b 100644
--- a/tests/run-make/reproducible-build/rmake.rs
+++ b/tests/run-make/reproducible-build/rmake.rs
@@ -199,10 +199,6 @@ fn diff_dir_test(crate_type: CrateType, remap_type: RemapType) {
                     .arg(format!("--remap-path-prefix={}=/b", base_dir.join("test").display()));
             }
             RemapType::Cwd { is_empty } => {
-                // FIXME(Oneirical): Building with crate type set to `bin` AND having -Cdebuginfo=2
-                // (or `-g`, the shorthand form) enabled will cause reproducibility failures
-                // for multiple platforms.
-                // See https://github.com/rust-lang/rust/issues/89911
                 // FIXME(#129117): Windows rlib + `-Cdebuginfo=2` + `-Z remap-cwd-prefix=.` seems
                 // to be unreproducible.
                 if !is_windows() {

From 207dcbbe7c693dec30eae387f28ad88d88fe7265 Mon Sep 17 00:00:00 2001
From: bendn <bend.n@outlook.com>
Date: Thu, 22 Jan 2026 19:29:55 +0700
Subject: [PATCH 23/27] constify boolean methods

---
 library/core/src/bool.rs        | 17 +++++++++++++----
 library/coretests/tests/bool.rs |  8 ++++----
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/library/core/src/bool.rs b/library/core/src/bool.rs
index 99268d6182f6c..9b9d2f02550bd 100644
--- a/library/core/src/bool.rs
+++ b/library/core/src/bool.rs
@@ -1,5 +1,7 @@
 //! impl bool {}
 
+use crate::marker::Destruct;
+
 impl bool {
     /// Returns `Some(t)` if the `bool` is [`true`](../std/keyword.true.html),
     /// or `None` otherwise.
@@ -29,8 +31,9 @@ impl bool {
     /// assert_eq!(a, 2);
     /// ```
     #[stable(feature = "bool_to_option", since = "1.62.0")]
+    #[rustc_const_unstable(feature = "const_bool", issue = "151531")]
     #[inline]
-    pub fn then_some<T>(self, t: T) -> Option<T> {
+    pub const fn then_some<T: [const] Destruct>(self, t: T) -> Option<T> {
         if self { Some(t) } else { None }
     }
 
@@ -57,8 +60,9 @@ impl bool {
     #[doc(alias = "then_with")]
     #[stable(feature = "lazy_bool_to_option", since = "1.50.0")]
     #[rustc_diagnostic_item = "bool_then"]
+    #[rustc_const_unstable(feature = "const_bool", issue = "151531")]
     #[inline]
-    pub fn then<T, F: FnOnce() -> T>(self, f: F) -> Option<T> {
+    pub const fn then<T, F: [const] FnOnce() -> T + [const] Destruct>(self, f: F) -> Option<T> {
         if self { Some(f()) } else { None }
     }
 
@@ -94,8 +98,9 @@ impl bool {
     /// assert_eq!(a, 2);
     /// ```
     #[unstable(feature = "bool_to_result", issue = "142748")]
+    #[rustc_const_unstable(feature = "const_bool", issue = "151531")]
     #[inline]
-    pub fn ok_or<E>(self, err: E) -> Result<(), E> {
+    pub const fn ok_or<E: [const] Destruct>(self, err: E) -> Result<(), E> {
         if self { Ok(()) } else { Err(err) }
     }
 
@@ -124,8 +129,12 @@ impl bool {
     /// assert_eq!(a, 1);
     /// ```
     #[unstable(feature = "bool_to_result", issue = "142748")]
+    #[rustc_const_unstable(feature = "const_bool", issue = "151531")]
     #[inline]
-    pub fn ok_or_else<E, F: FnOnce() -> E>(self, f: F) -> Result<(), E> {
+    pub const fn ok_or_else<E, F: [const] FnOnce() -> E + [const] Destruct>(
+        self,
+        f: F,
+    ) -> Result<(), E> {
         if self { Ok(()) } else { Err(f()) }
     }
 }
diff --git a/library/coretests/tests/bool.rs b/library/coretests/tests/bool.rs
index 3f4588f525783..802e43045b6e6 100644
--- a/library/coretests/tests/bool.rs
+++ b/library/coretests/tests/bool.rs
@@ -82,6 +82,10 @@ pub fn test_bool_not() {
     }
 }
 
+const fn zero() -> i32 {
+    0
+}
+
 #[test]
 fn test_bool_to_option() {
     assert_eq!(false.then_some(0), None);
@@ -89,10 +93,6 @@ fn test_bool_to_option() {
     assert_eq!(false.then(|| 0), None);
     assert_eq!(true.then(|| 0), Some(0));
 
-    const fn zero() -> i32 {
-        0
-    }
-
     const A: Option<i32> = false.then_some(0);
     const B: Option<i32> = true.then_some(0);
     const C: Option<i32> = false.then(zero);

From 78afe876f428daa694bf90aeb6461a0a59d568ef Mon Sep 17 00:00:00 2001
From: ThanhNguyxn <thanhnguyentuan2007@gmail.com>
Date: Fri, 23 Jan 2026 10:37:55 +0700
Subject: [PATCH 24/27] Add 'Skip to main content' link for keyboard navigation
 in rustdoc

Implements WCAG 2.4.1 (Level A) - Bypass Blocks accessibility feature.

Changes:
- Add skip-main-content link in page.html with tabindex=-1 on main-content
- Add CSS styling per reviewer feedback (outline border, themed colors)
- Add GOML test for skip navigation functionality

Fixes #151420
---
 src/librustdoc/html/static/css/rustdoc.css | 19 +++++++++++++++++++
 src/librustdoc/html/templates/page.html    |  3 ++-
 tests/rustdoc-gui/skip-navigation.goml     | 19 +++++++++++++++++++
 3 files changed, 40 insertions(+), 1 deletion(-)
 create mode 100644 tests/rustdoc-gui/skip-navigation.goml

diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index 486ca9b22539c..6c34d31cc918c 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -210,6 +210,24 @@ body {
 	color: var(--main-color);
 }
 
+/* Skip navigation link for keyboard users (WCAG 2.4.1) */
+.skip-main-content {
+	position: absolute;
+	left: 0;
+	top: -100%;
+	z-index: 1000;
+	padding: 0.5rem 1rem;
+	background-color: var(--main-background-color);
+	color: var(--main-color);
+	text-decoration: none;
+	font-weight: 500;
+	border-bottom-right-radius: 4px;
+	outline: 2px solid var(--search-input-focused-border-color);
+}
+.skip-main-content:focus {
+	top: 0;
+}
+
 h1 {
 	font-size: 1.5rem; /* 24px */
 }
@@ -1114,6 +1132,7 @@ pre, .rustdoc.src .example-wrap, .example-wrap .src-line-numbers {
 
 #main-content {
 	position: relative;
+	outline: none;
 }
 
 .docblock table {
diff --git a/src/librustdoc/html/templates/page.html b/src/librustdoc/html/templates/page.html
index 1f8ec9f30c53c..427e7b4071a1e 100644
--- a/src/librustdoc/html/templates/page.html
+++ b/src/librustdoc/html/templates/page.html
@@ -66,6 +66,7 @@
     {{ layout.external_html.in_header|safe }}
 </head> {# #}
 <body class="rustdoc {{+page.css_class}}"> {# #}
+    <a class="skip-main-content" href="#main-content">Skip to main content</a> {# #}
     <!--[if lte IE 11]> {# #}
     <div class="warning"> {# #}
         This old browser is unsupported and will most likely display funky things. {# #}
@@ -109,7 +110,7 @@ <h2>Files</h2> {# #}
     <div class="sidebar-resizer" title="Drag to resize sidebar"></div> {# #}
     <main>
         {% if page.css_class != "src" %}<div class="width-limiter">{% endif %}
-            <section id="main-content" class="content">{{ content|safe }}</section>
+            <section id="main-content" class="content" tabindex="-1">{{ content|safe }}</section>
         {% if page.css_class != "src" %}</div>{% endif %}
     </main>
     {{ layout.external_html.after_content|safe }}
diff --git a/tests/rustdoc-gui/skip-navigation.goml b/tests/rustdoc-gui/skip-navigation.goml
new file mode 100644
index 0000000000000..50cb2d38b3e0c
--- /dev/null
+++ b/tests/rustdoc-gui/skip-navigation.goml
@@ -0,0 +1,19 @@
+// This test ensures that the "Skip to main content" link works correctly
+// for keyboard navigation (WCAG 2.4.1 compliance).
+go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
+
+// The skip link should be hidden initially (positioned off-screen above viewport)
+store-position: (".skip-main-content", {"y": y_before})
+store-size: (".skip-main-content", {"height": height_before})
+assert: |y_before| + |height_before| < 0
+
+// The skip link should be the first focusable element when pressing Tab
+press-key: "Tab"
+wait-for: ".skip-main-content:focus"
+
+// When focused, the link should be visible (top: 0px)
+assert-css: (".skip-main-content:focus", {"top": "0px"})
+
+// Pressing Enter on the skip link should move focus to main content
+press-key: "Enter"
+wait-for: "#main-content:focus"

From e47138f43643733d4fdefa5b77e3bc745558a7dc Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 23 Jan 2026 11:19:21 +0000
Subject: [PATCH 25/27] Fix review comments

---
 .../rustc_expand/src/proc_macro_server.rs     | 20 +++---
 library/proc_macro/src/bridge/client.rs       |  4 +-
 library/proc_macro/src/bridge/mod.rs          | 20 +++---
 library/proc_macro/src/lib.rs                 | 70 +++++++++----------
 .../src/server_impl/rust_analyzer_span.rs     | 20 +++---
 .../src/server_impl/token_id.rs               | 20 +++---
 6 files changed, 76 insertions(+), 78 deletions(-)

diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index 4719829d6d3ab..a51aa90355bcd 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -566,19 +566,19 @@ impl server::Server for Rustc<'_, '_> {
         diag.emit();
     }
 
-    fn tt_drop(&mut self, stream: Self::TokenStream) {
+    fn ts_drop(&mut self, stream: Self::TokenStream) {
         drop(stream);
     }
 
-    fn tt_clone(&mut self, stream: &Self::TokenStream) -> Self::TokenStream {
+    fn ts_clone(&mut self, stream: &Self::TokenStream) -> Self::TokenStream {
         stream.clone()
     }
 
-    fn tt_is_empty(&mut self, stream: &Self::TokenStream) -> bool {
+    fn ts_is_empty(&mut self, stream: &Self::TokenStream) -> bool {
         stream.is_empty()
     }
 
-    fn tt_from_str(&mut self, src: &str) -> Self::TokenStream {
+    fn ts_from_str(&mut self, src: &str) -> Self::TokenStream {
         unwrap_or_emit_fatal(source_str_to_stream(
             self.psess(),
             FileName::proc_macro_source_code(src),
@@ -587,11 +587,11 @@ impl server::Server for Rustc<'_, '_> {
         ))
     }
 
-    fn tt_to_string(&mut self, stream: &Self::TokenStream) -> String {
+    fn ts_to_string(&mut self, stream: &Self::TokenStream) -> String {
         pprust::tts_to_string(stream)
     }
 
-    fn tt_expand_expr(&mut self, stream: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
+    fn ts_expand_expr(&mut self, stream: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
         // Parse the expression from our tokenstream.
         let expr: PResult<'_, _> = try {
             let mut p = Parser::new(self.psess(), stream.clone(), Some("proc_macro expand expr"));
@@ -652,14 +652,14 @@ impl server::Server for Rustc<'_, '_> {
         }
     }
 
-    fn tt_from_token_tree(
+    fn ts_from_token_tree(
         &mut self,
         tree: TokenTree<Self::TokenStream, Self::Span, Self::Symbol>,
     ) -> Self::TokenStream {
         Self::TokenStream::new((tree, &mut *self).to_internal().into_iter().collect::<Vec<_>>())
     }
 
-    fn tt_concat_trees(
+    fn ts_concat_trees(
         &mut self,
         base: Option<Self::TokenStream>,
         trees: Vec<TokenTree<Self::TokenStream, Self::Span, Self::Symbol>>,
@@ -673,7 +673,7 @@ impl server::Server for Rustc<'_, '_> {
         stream
     }
 
-    fn tt_concat_streams(
+    fn ts_concat_streams(
         &mut self,
         base: Option<Self::TokenStream>,
         streams: Vec<Self::TokenStream>,
@@ -685,7 +685,7 @@ impl server::Server for Rustc<'_, '_> {
         stream
     }
 
-    fn tt_into_trees(
+    fn ts_into_trees(
         &mut self,
         stream: Self::TokenStream,
     ) -> Vec<TokenTree<Self::TokenStream, Self::Span, Self::Symbol>> {
diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index 058a9420f6e0f..0d87a727ae40b 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -25,7 +25,7 @@ impl !Sync for TokenStream {}
 // Forward `Drop::drop` to the inherent `drop` method.
 impl Drop for TokenStream {
     fn drop(&mut self) {
-        Methods::tt_drop(TokenStream { handle: self.handle });
+        Methods::ts_drop(TokenStream { handle: self.handle });
     }
 }
 
@@ -75,7 +75,7 @@ impl<S> Decode<'_, '_, S> for Span {
 
 impl Clone for TokenStream {
     fn clone(&self) -> Self {
-        Methods::tt_clone(self)
+        Methods::ts_clone(self)
     }
 }
 
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 429335456316a..6f7c8726f9253 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -56,24 +56,24 @@ macro_rules! with_api {
                 fn literal_from_str(s: &str) -> Result<Literal<$S::Span, $S::Symbol>, ()>;
                 fn emit_diagnostic(diagnostic: Diagnostic<$S::Span>);
 
-                fn tt_drop(stream: $S::TokenStream);
-                fn tt_clone(stream: &$S::TokenStream) -> $S::TokenStream;
-                fn tt_is_empty(stream: &$S::TokenStream) -> bool;
-                fn tt_expand_expr(stream: &$S::TokenStream) -> Result<$S::TokenStream, ()>;
-                fn tt_from_str(src: &str) -> $S::TokenStream;
-                fn tt_to_string(stream: &$S::TokenStream) -> String;
-                fn tt_from_token_tree(
+                fn ts_drop(stream: $S::TokenStream);
+                fn ts_clone(stream: &$S::TokenStream) -> $S::TokenStream;
+                fn ts_is_empty(stream: &$S::TokenStream) -> bool;
+                fn ts_expand_expr(stream: &$S::TokenStream) -> Result<$S::TokenStream, ()>;
+                fn ts_from_str(src: &str) -> $S::TokenStream;
+                fn ts_to_string(stream: &$S::TokenStream) -> String;
+                fn ts_from_token_tree(
                     tree: TokenTree<$S::TokenStream, $S::Span, $S::Symbol>,
                 ) -> $S::TokenStream;
-                fn tt_concat_trees(
+                fn ts_concat_trees(
                     base: Option<$S::TokenStream>,
                     trees: Vec<TokenTree<$S::TokenStream, $S::Span, $S::Symbol>>,
                 ) -> $S::TokenStream;
-                fn tt_concat_streams(
+                fn ts_concat_streams(
                     base: Option<$S::TokenStream>,
                     streams: Vec<$S::TokenStream>,
                 ) -> $S::TokenStream;
-                fn tt_into_trees(
+                fn ts_into_trees(
                     stream: $S::TokenStream
                 ) -> Vec<TokenTree<$S::TokenStream, $S::Span, $S::Symbol>>;
 
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index cc2de8d470c9d..95a7ea7d7b3b7 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -58,6 +58,7 @@ use rustc_literal_escaper::{MixedUnit, unescape_byte_str, unescape_c_str, unesca
 #[unstable(feature = "proc_macro_totokens", issue = "130977")]
 pub use to_tokens::ToTokens;
 
+use crate::bridge::client::Methods as BridgeMethods;
 use crate::escape::{EscapeOptions, escape_bytes};
 
 /// Errors returned when trying to retrieve a literal unescaped value.
@@ -158,7 +159,7 @@ impl TokenStream {
     /// Checks if this `TokenStream` is empty.
     #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
     pub fn is_empty(&self) -> bool {
-        self.0.as_ref().map(|h| bridge::client::Methods::tt_is_empty(h)).unwrap_or(true)
+        self.0.as_ref().map(|h| BridgeMethods::ts_is_empty(h)).unwrap_or(true)
     }
 
     /// Parses this `TokenStream` as an expression and attempts to expand any
@@ -174,7 +175,7 @@ impl TokenStream {
     #[unstable(feature = "proc_macro_expand", issue = "90765")]
     pub fn expand_expr(&self) -> Result<TokenStream, ExpandError> {
         let stream = self.0.as_ref().ok_or(ExpandError)?;
-        match bridge::client::Methods::tt_expand_expr(stream) {
+        match BridgeMethods::ts_expand_expr(stream) {
             Ok(stream) => Ok(TokenStream(Some(stream))),
             Err(_) => Err(ExpandError),
         }
@@ -193,7 +194,7 @@ impl FromStr for TokenStream {
     type Err = LexError;
 
     fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        Ok(TokenStream(Some(bridge::client::Methods::tt_from_str(src))))
+        Ok(TokenStream(Some(BridgeMethods::ts_from_str(src))))
     }
 }
 
@@ -212,7 +213,7 @@ impl FromStr for TokenStream {
 impl fmt::Display for TokenStream {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self.0 {
-            Some(ts) => write!(f, "{}", bridge::client::Methods::tt_to_string(ts)),
+            Some(ts) => write!(f, "{}", BridgeMethods::ts_to_string(ts)),
             None => Ok(()),
         }
     }
@@ -252,7 +253,7 @@ fn tree_to_bridge_tree(
 #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
 impl From<TokenTree> for TokenStream {
     fn from(tree: TokenTree) -> TokenStream {
-        TokenStream(Some(bridge::client::Methods::tt_from_token_tree(tree_to_bridge_tree(tree))))
+        TokenStream(Some(BridgeMethods::ts_from_token_tree(tree_to_bridge_tree(tree))))
     }
 }
 
@@ -281,7 +282,7 @@ impl ConcatTreesHelper {
         if self.trees.is_empty() {
             TokenStream(None)
         } else {
-            TokenStream(Some(bridge::client::Methods::tt_concat_trees(None, self.trees)))
+            TokenStream(Some(BridgeMethods::ts_concat_trees(None, self.trees)))
         }
     }
 
@@ -289,7 +290,7 @@ impl ConcatTreesHelper {
         if self.trees.is_empty() {
             return;
         }
-        stream.0 = Some(bridge::client::Methods::tt_concat_trees(stream.0.take(), self.trees))
+        stream.0 = Some(BridgeMethods::ts_concat_trees(stream.0.take(), self.trees))
     }
 }
 
@@ -314,7 +315,7 @@ impl ConcatStreamsHelper {
         if self.streams.len() <= 1 {
             TokenStream(self.streams.pop())
         } else {
-            TokenStream(Some(bridge::client::Methods::tt_concat_streams(None, self.streams)))
+            TokenStream(Some(BridgeMethods::ts_concat_streams(None, self.streams)))
         }
     }
 
@@ -326,7 +327,7 @@ impl ConcatStreamsHelper {
         if base.is_none() && self.streams.len() == 1 {
             stream.0 = self.streams.pop();
         } else {
-            stream.0 = Some(bridge::client::Methods::tt_concat_streams(base, self.streams));
+            stream.0 = Some(BridgeMethods::ts_concat_streams(base, self.streams));
         }
     }
 }
@@ -377,7 +378,7 @@ impl Extend<TokenStream> for TokenStream {
 macro_rules! extend_items {
     ($($item:ident)*) => {
         $(
-            #[stable(feature = "token_stream_extend_tt_items", since = "1.92.0")]
+            #[stable(feature = "token_stream_extend_ts_items", since = "1.92.0")]
             impl Extend<$item> for TokenStream {
                 fn extend<T: IntoIterator<Item = $item>>(&mut self, iter: T) {
                     self.extend(iter.into_iter().map(TokenTree::$item));
@@ -392,7 +393,7 @@ extend_items!(Group Literal Punct Ident);
 /// Public implementation details for the `TokenStream` type, such as iterators.
 #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
 pub mod token_stream {
-    use crate::{Group, Ident, Literal, Punct, TokenStream, TokenTree, bridge};
+    use crate::{BridgeMethods, Group, Ident, Literal, Punct, TokenStream, TokenTree, bridge};
 
     /// An iterator over `TokenStream`'s `TokenTree`s.
     /// The iteration is "shallow", e.g., the iterator doesn't recurse into delimited groups,
@@ -438,10 +439,7 @@ pub mod token_stream {
 
         fn into_iter(self) -> IntoIter {
             IntoIter(
-                self.0
-                    .map(|v| bridge::client::Methods::tt_into_trees(v))
-                    .unwrap_or_default()
-                    .into_iter(),
+                self.0.map(|v| BridgeMethods::ts_into_trees(v)).unwrap_or_default().into_iter(),
             )
         }
     }
@@ -514,7 +512,7 @@ impl Span {
     /// `self` was generated from, if any.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn parent(&self) -> Option<Span> {
-        bridge::client::Methods::span_parent(self.0).map(Span)
+        BridgeMethods::span_parent(self.0).map(Span)
     }
 
     /// The span for the origin source code that `self` was generated from. If
@@ -522,25 +520,25 @@ impl Span {
     /// value is the same as `*self`.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn source(&self) -> Span {
-        Span(bridge::client::Methods::span_source(self.0))
+        Span(BridgeMethods::span_source(self.0))
     }
 
     /// Returns the span's byte position range in the source file.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn byte_range(&self) -> Range<usize> {
-        bridge::client::Methods::span_byte_range(self.0)
+        BridgeMethods::span_byte_range(self.0)
     }
 
     /// Creates an empty span pointing to directly before this span.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn start(&self) -> Span {
-        Span(bridge::client::Methods::span_start(self.0))
+        Span(BridgeMethods::span_start(self.0))
     }
 
     /// Creates an empty span pointing to directly after this span.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn end(&self) -> Span {
-        Span(bridge::client::Methods::span_end(self.0))
+        Span(BridgeMethods::span_end(self.0))
     }
 
     /// The one-indexed line of the source file where the span starts.
@@ -548,7 +546,7 @@ impl Span {
     /// To obtain the line of the span's end, use `span.end().line()`.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn line(&self) -> usize {
-        bridge::client::Methods::span_line(self.0)
+        BridgeMethods::span_line(self.0)
     }
 
     /// The one-indexed column of the source file where the span starts.
@@ -556,7 +554,7 @@ impl Span {
     /// To obtain the column of the span's end, use `span.end().column()`.
     #[stable(feature = "proc_macro_span_location", since = "1.88.0")]
     pub fn column(&self) -> usize {
-        bridge::client::Methods::span_column(self.0)
+        BridgeMethods::span_column(self.0)
     }
 
     /// The path to the source file in which this span occurs, for display purposes.
@@ -565,7 +563,7 @@ impl Span {
     /// It might be remapped (e.g. `"/src/lib.rs"`) or an artificial path (e.g. `"<command line>"`).
     #[stable(feature = "proc_macro_span_file", since = "1.88.0")]
     pub fn file(&self) -> String {
-        bridge::client::Methods::span_file(self.0)
+        BridgeMethods::span_file(self.0)
     }
 
     /// The path to the source file in which this span occurs on the local file system.
@@ -575,7 +573,7 @@ impl Span {
     /// This path should not be embedded in the output of the macro; prefer `file()` instead.
     #[stable(feature = "proc_macro_span_file", since = "1.88.0")]
     pub fn local_file(&self) -> Option<PathBuf> {
-        bridge::client::Methods::span_local_file(self.0).map(PathBuf::from)
+        BridgeMethods::span_local_file(self.0).map(PathBuf::from)
     }
 
     /// Creates a new span encompassing `self` and `other`.
@@ -583,14 +581,14 @@ impl Span {
     /// Returns `None` if `self` and `other` are from different files.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn join(&self, other: Span) -> Option<Span> {
-        bridge::client::Methods::span_join(self.0, other.0).map(Span)
+        BridgeMethods::span_join(self.0, other.0).map(Span)
     }
 
     /// Creates a new span with the same line/column information as `self` but
     /// that resolves symbols as though it were at `other`.
     #[stable(feature = "proc_macro_span_resolved_at", since = "1.45.0")]
     pub fn resolved_at(&self, other: Span) -> Span {
-        Span(bridge::client::Methods::span_resolved_at(self.0, other.0))
+        Span(BridgeMethods::span_resolved_at(self.0, other.0))
     }
 
     /// Creates a new span with the same name resolution behavior as `self` but
@@ -615,21 +613,21 @@ impl Span {
     /// be used for diagnostics only.
     #[stable(feature = "proc_macro_source_text", since = "1.66.0")]
     pub fn source_text(&self) -> Option<String> {
-        bridge::client::Methods::span_source_text(self.0)
+        BridgeMethods::span_source_text(self.0)
     }
 
     // Used by the implementation of `Span::quote`
     #[doc(hidden)]
     #[unstable(feature = "proc_macro_internals", issue = "27812")]
     pub fn save_span(&self) -> usize {
-        bridge::client::Methods::span_save_span(self.0)
+        BridgeMethods::span_save_span(self.0)
     }
 
     // Used by the implementation of `Span::quote`
     #[doc(hidden)]
     #[unstable(feature = "proc_macro_internals", issue = "27812")]
     pub fn recover_proc_macro_span(id: usize) -> Span {
-        Span(bridge::client::Methods::span_recover_proc_macro_span(id))
+        Span(BridgeMethods::span_recover_proc_macro_span(id))
     }
 
     diagnostic_method!(error, Level::Error);
@@ -1394,7 +1392,7 @@ impl Literal {
     // was 'c' or whether it was '\u{63}'.
     #[unstable(feature = "proc_macro_span", issue = "54725")]
     pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
-        bridge::client::Methods::span_subspan(
+        BridgeMethods::span_subspan(
             self.0.span,
             range.start_bound().cloned(),
             range.end_bound().cloned(),
@@ -1569,7 +1567,7 @@ impl FromStr for Literal {
     type Err = LexError;
 
     fn from_str(src: &str) -> Result<Self, LexError> {
-        match bridge::client::Methods::literal_from_str(src) {
+        match BridgeMethods::literal_from_str(src) {
             Ok(literal) => Ok(Literal(literal)),
             Err(()) => Err(LexError),
         }
@@ -1611,11 +1609,12 @@ impl fmt::Debug for Literal {
 )]
 /// Functionality for adding environment state to the build dependency info.
 pub mod tracked {
-
     use std::env::{self, VarError};
     use std::ffi::OsStr;
     use std::path::Path;
 
+    use crate::BridgeMethods;
+
     /// Retrieve an environment variable and add it to build dependency info.
     /// The build system executing the compiler will know that the variable was accessed during
     /// compilation, and will be able to rerun the build when the value of that variable changes.
@@ -1624,9 +1623,8 @@ pub mod tracked {
     #[unstable(feature = "proc_macro_tracked_env", issue = "99515")]
     pub fn env_var<K: AsRef<OsStr> + AsRef<str>>(key: K) -> Result<String, VarError> {
         let key: &str = key.as_ref();
-        let value =
-            crate::bridge::client::Methods::injected_env_var(key).map_or_else(|| env::var(key), Ok);
-        crate::bridge::client::Methods::track_env_var(key, value.as_deref().ok());
+        let value = BridgeMethods::injected_env_var(key).map_or_else(|| env::var(key), Ok);
+        BridgeMethods::track_env_var(key, value.as_deref().ok());
         value
     }
 
@@ -1636,6 +1634,6 @@ pub mod tracked {
     #[unstable(feature = "proc_macro_tracked_path", issue = "99515")]
     pub fn path<P: AsRef<Path>>(path: P) {
         let path: &str = path.as_ref().to_str().unwrap();
-        crate::bridge::client::Methods::track_path(path);
+        BridgeMethods::track_path(path);
     }
 }
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
index 4f50c04b27996..ec30630c10bbe 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/rust_analyzer_span.rs
@@ -72,18 +72,18 @@ impl server::Server for RaSpanServer<'_> {
         // FIXME handle diagnostic
     }
 
-    fn tt_drop(&mut self, stream: Self::TokenStream) {
+    fn ts_drop(&mut self, stream: Self::TokenStream) {
         drop(stream);
     }
 
-    fn tt_clone(&mut self, stream: &Self::TokenStream) -> Self::TokenStream {
+    fn ts_clone(&mut self, stream: &Self::TokenStream) -> Self::TokenStream {
         stream.clone()
     }
 
-    fn tt_is_empty(&mut self, stream: &Self::TokenStream) -> bool {
+    fn ts_is_empty(&mut self, stream: &Self::TokenStream) -> bool {
         stream.is_empty()
     }
-    fn tt_from_str(&mut self, src: &str) -> Self::TokenStream {
+    fn ts_from_str(&mut self, src: &str) -> Self::TokenStream {
         Self::TokenStream::from_str(src, self.call_site).unwrap_or_else(|e| {
             Self::TokenStream::from_str(
                 &format!("compile_error!(\"failed to parse str to token stream: {e}\")"),
@@ -92,15 +92,15 @@ impl server::Server for RaSpanServer<'_> {
             .unwrap()
         })
     }
-    fn tt_to_string(&mut self, stream: &Self::TokenStream) -> String {
+    fn ts_to_string(&mut self, stream: &Self::TokenStream) -> String {
         stream.to_string()
     }
 
-    fn tt_from_token_tree(&mut self, tree: TokenTree<Self::Span>) -> Self::TokenStream {
+    fn ts_from_token_tree(&mut self, tree: TokenTree<Self::Span>) -> Self::TokenStream {
         Self::TokenStream::new(vec![tree])
     }
 
-    fn tt_expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
+    fn ts_expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
         // FIXME: requires db, more importantly this requires name resolution so we would need to
         // eagerly expand this proc-macro, but we can't know that this proc-macro is eager until we
         // expand it ...
@@ -109,7 +109,7 @@ impl server::Server for RaSpanServer<'_> {
         Ok(self_.clone())
     }
 
-    fn tt_concat_trees(
+    fn ts_concat_trees(
         &mut self,
         base: Option<Self::TokenStream>,
         trees: Vec<TokenTree<Self::Span>>,
@@ -125,7 +125,7 @@ impl server::Server for RaSpanServer<'_> {
         }
     }
 
-    fn tt_concat_streams(
+    fn ts_concat_streams(
         &mut self,
         base: Option<Self::TokenStream>,
         streams: Vec<Self::TokenStream>,
@@ -137,7 +137,7 @@ impl server::Server for RaSpanServer<'_> {
         stream
     }
 
-    fn tt_into_trees(&mut self, stream: Self::TokenStream) -> Vec<TokenTree<Self::Span>> {
+    fn ts_into_trees(&mut self, stream: Self::TokenStream) -> Vec<TokenTree<Self::Span>> {
         (*stream.0).clone()
     }
 
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
index cd5ba59095610..3bf07290c8c05 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl/token_id.rs
@@ -75,18 +75,18 @@ impl server::Server for SpanIdServer<'_> {
 
     fn emit_diagnostic(&mut self, _: Diagnostic<Self::Span>) {}
 
-    fn tt_drop(&mut self, stream: Self::TokenStream) {
+    fn ts_drop(&mut self, stream: Self::TokenStream) {
         drop(stream);
     }
 
-    fn tt_clone(&mut self, stream: &Self::TokenStream) -> Self::TokenStream {
+    fn ts_clone(&mut self, stream: &Self::TokenStream) -> Self::TokenStream {
         stream.clone()
     }
 
-    fn tt_is_empty(&mut self, stream: &Self::TokenStream) -> bool {
+    fn ts_is_empty(&mut self, stream: &Self::TokenStream) -> bool {
         stream.is_empty()
     }
-    fn tt_from_str(&mut self, src: &str) -> Self::TokenStream {
+    fn ts_from_str(&mut self, src: &str) -> Self::TokenStream {
         Self::TokenStream::from_str(src, self.call_site).unwrap_or_else(|e| {
             Self::TokenStream::from_str(
                 &format!("compile_error!(\"failed to parse str to token stream: {e}\")"),
@@ -95,18 +95,18 @@ impl server::Server for SpanIdServer<'_> {
             .unwrap()
         })
     }
-    fn tt_to_string(&mut self, stream: &Self::TokenStream) -> String {
+    fn ts_to_string(&mut self, stream: &Self::TokenStream) -> String {
         stream.to_string()
     }
-    fn tt_from_token_tree(&mut self, tree: TokenTree<Self::Span>) -> Self::TokenStream {
+    fn ts_from_token_tree(&mut self, tree: TokenTree<Self::Span>) -> Self::TokenStream {
         Self::TokenStream::new(vec![tree])
     }
 
-    fn tt_expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
+    fn ts_expand_expr(&mut self, self_: &Self::TokenStream) -> Result<Self::TokenStream, ()> {
         Ok(self_.clone())
     }
 
-    fn tt_concat_trees(
+    fn ts_concat_trees(
         &mut self,
         base: Option<Self::TokenStream>,
         trees: Vec<TokenTree<Self::Span>>,
@@ -122,7 +122,7 @@ impl server::Server for SpanIdServer<'_> {
         }
     }
 
-    fn tt_concat_streams(
+    fn ts_concat_streams(
         &mut self,
         base: Option<Self::TokenStream>,
         streams: Vec<Self::TokenStream>,
@@ -134,7 +134,7 @@ impl server::Server for SpanIdServer<'_> {
         stream
     }
 
-    fn tt_into_trees(&mut self, stream: Self::TokenStream) -> Vec<TokenTree<Self::Span>> {
+    fn ts_into_trees(&mut self, stream: Self::TokenStream) -> Vec<TokenTree<Self::Span>> {
         (*stream.0).clone()
     }
 

From e38b55d0b732065711d78d79c241344ae2f903ad Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Fri, 23 Jan 2026 11:10:53 -0800
Subject: [PATCH 26/27] Don't use default build-script fingerprinting in `test`

This changes the `test` build script so that it does not use the default
fingerprinting mechanism in cargo which causes a full scan of the
package every time it runs. This build script does not depend on any of
the files in the package.

This is the recommended approach for writing build scripts.
---
 library/test/build.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/test/build.rs b/library/test/build.rs
index a2bc8936b5195..8e31adbf2ca74 100644
--- a/library/test/build.rs
+++ b/library/test/build.rs
@@ -1,4 +1,5 @@
 fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
     println!("cargo:rustc-check-cfg=cfg(enable_unstable_features)");
 
     let rustc = std::env::var("RUSTC").unwrap_or_else(|_| "rustc".into());

From 8995ff5ba80ddc3147cbab3620b8773738f11a49 Mon Sep 17 00:00:00 2001
From: Nicholas Bishop <nbishop@nbishop.net>
Date: Thu, 22 Jan 2026 21:53:05 -0500
Subject: [PATCH 27/27] Fix compilation of std/src/sys/pal/uefi/tests.rs

Dropped the `align` test since the `POOL_ALIGNMENT` and `align_size`
items it uses do not exist.

The other changes are straightforward fixes for places where the test
code drifted from the current API, since the tests are not yet built in
CI for the UEFI target.
---
 library/std/src/sys/pal/uefi/tests.rs | 53 +++++++++------------------
 1 file changed, 17 insertions(+), 36 deletions(-)

diff --git a/library/std/src/sys/pal/uefi/tests.rs b/library/std/src/sys/pal/uefi/tests.rs
index df3344e2df346..9f16ef07a4bde 100644
--- a/library/std/src/sys/pal/uefi/tests.rs
+++ b/library/std/src/sys/pal/uefi/tests.rs
@@ -1,14 +1,14 @@
 //! These tests are not run automatically right now. Please run these tests manually by copying them
 //! to a separate project when modifying any related code.
 
-use super::alloc::*;
 use super::time::system_time_internal::{from_uefi, to_uefi};
 use crate::io::{IoSlice, IoSliceMut};
+use crate::ops::{Deref, DerefMut};
 use crate::time::Duration;
 
 const SECS_IN_MINUTE: u64 = 60;
 
-const MAX_UEFI_TIME: Duration = from_uefi(r_efi::efi::Time {
+const MAX_UEFI_TIME: Duration = from_uefi(&r_efi::efi::Time {
     year: 9999,
     month: 12,
     day: 31,
@@ -20,27 +20,8 @@ const MAX_UEFI_TIME: Duration = from_uefi(r_efi::efi::Time {
     daylight: 0,
     pad1: 0,
     pad2: 0,
-});
-
-#[test]
-fn align() {
-    // UEFI ABI specifies that allocation alignment minimum is always 8. So this can be
-    // statically verified.
-    assert_eq!(POOL_ALIGNMENT, 8);
-
-    // Loop over allocation-request sizes from 0-256 and alignments from 1-128, and verify
-    // that in case of overalignment there is at least space for one additional pointer to
-    // store in the allocation.
-    for i in 0..256 {
-        for j in &[1, 2, 4, 8, 16, 32, 64, 128] {
-            if *j <= 8 {
-                assert_eq!(align_size(i, *j), i);
-            } else {
-                assert!(align_size(i, *j) > i + size_of::<*mut ()>());
-            }
-        }
-    }
-}
+})
+.unwrap();
 
 // UEFI Time cannot implement Eq due to uninitilaized pad1 and pad2
 fn uefi_time_cmp(t1: r_efi::efi::Time, t2: r_efi::efi::Time) -> bool {
@@ -70,9 +51,9 @@ fn systemtime_start() {
         daylight: 0,
         pad2: 0,
     };
-    assert_eq!(from_uefi(&t), Duration::new(0, 0));
-    assert!(uefi_time_cmp(t, to_uefi(&from_uefi(&t), -1440, 0).unwrap()));
-    assert!(to_uefi(&from_uefi(&t), 0, 0).is_err());
+    assert_eq!(from_uefi(&t).unwrap(), Duration::new(0, 0));
+    assert!(uefi_time_cmp(t, to_uefi(&from_uefi(&t).unwrap(), -1440, 0).unwrap()));
+    assert!(to_uefi(&from_uefi(&t).unwrap(), 0, 0).is_err());
 }
 
 #[test]
@@ -90,9 +71,9 @@ fn systemtime_utc_start() {
         daylight: 0,
         pad2: 0,
     };
-    assert_eq!(from_uefi(&t), Duration::new(1440 * SECS_IN_MINUTE, 0));
-    assert!(uefi_time_cmp(t, to_uefi(&from_uefi(&t), 0, 0).unwrap()));
-    assert!(to_uefi(&from_uefi(&t), -1440, 0).is_ok());
+    assert_eq!(from_uefi(&t).unwrap(), Duration::new(1440 * SECS_IN_MINUTE, 0));
+    assert!(uefi_time_cmp(t, to_uefi(&from_uefi(&t).unwrap(), 0, 0).unwrap()));
+    assert!(to_uefi(&from_uefi(&t).unwrap(), -1440, 0).is_ok());
 }
 
 #[test]
@@ -110,8 +91,8 @@ fn systemtime_end() {
         daylight: 0,
         pad2: 0,
     };
-    assert!(to_uefi(&from_uefi(&t), 1440, 0).is_ok());
-    assert!(to_uefi(&from_uefi(&t), 1439, 0).is_err());
+    assert!(to_uefi(&from_uefi(&t).unwrap(), 1440, 0).is_ok());
+    assert!(to_uefi(&from_uefi(&t).unwrap(), 1439, 0).is_err());
 }
 
 #[test]
@@ -139,17 +120,17 @@ fn min_time() {
 
 #[test]
 fn max_time() {
-    let inp = MAX_UEFI_TIME.0;
+    let inp = MAX_UEFI_TIME;
     let new_tz = to_uefi(&inp, -1440, 0).err().unwrap();
     assert_eq!(new_tz, 1440);
     assert!(to_uefi(&inp, new_tz, 0).is_ok());
 
-    let inp = MAX_UEFI_TIME.0 - Duration::from_secs(1440 * SECS_IN_MINUTE);
+    let inp = MAX_UEFI_TIME - Duration::from_secs(1440 * SECS_IN_MINUTE);
     let new_tz = to_uefi(&inp, -1440, 0).err().unwrap();
     assert_eq!(new_tz, 0);
     assert!(to_uefi(&inp, new_tz, 0).is_ok());
 
-    let inp = MAX_UEFI_TIME.0 - Duration::from_secs(1440 * SECS_IN_MINUTE + 10);
+    let inp = MAX_UEFI_TIME - Duration::from_secs(1440 * SECS_IN_MINUTE + 10);
     let new_tz = to_uefi(&inp, -1440, 0).err().unwrap();
     assert_eq!(new_tz, 0);
     assert!(to_uefi(&inp, new_tz, 0).is_ok());
@@ -266,8 +247,8 @@ fn io_slice_mut_basic() {
     let mut data_clone = [0, 1, 2, 3, 4];
     let mut io_slice_mut = IoSliceMut::new(&mut data_clone);
 
-    assert_eq!(data, io_slice_mut.as_slice());
-    assert_eq!(data, io_slice_mut.as_mut_slice());
+    assert_eq!(data, io_slice_mut.deref());
+    assert_eq!(data, io_slice_mut.deref_mut());
 
     io_slice_mut.advance(2);
     assert_eq!(&data[2..], io_slice_mut.into_slice());