reorganize proc_macro crate

cyrgani · cyrgani · commit 91fa94811ce6 · 2025-10-03T21:00:24.000+02:00
diff --git a/library/proc_macro/src/backend/client.rs b/library/proc_macro/src/backend/client.rs
@@ -25,7 +25,7 @@ macro_rules! define_client_handles {
 
         $(
             pub(crate) struct $oty {
-                handle: handle::Handle,
+                handle: Handle,
             }
 
             impl !Send for $oty {}
@@ -61,7 +61,7 @@ macro_rules! define_client_handles {
             impl<S> DecodeMut<'_, '_, S> for $oty {
                 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
                     $oty {
-                        handle: handle::Handle::decode(r, s),
+                        handle: Handle::decode(r, s),
                     }
                 }
             }
@@ -70,7 +70,7 @@ macro_rules! define_client_handles {
         $(
             #[derive(Copy, Clone, PartialEq, Eq, Hash)]
             pub(crate) struct $ity {
-                handle: handle::Handle,
+                handle: Handle,
             }
 
             impl !Send for $ity {}
@@ -85,7 +85,7 @@ macro_rules! define_client_handles {
             impl<S> DecodeMut<'_, '_, S> for $ity {
                 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
                     $ity {
-                        handle: handle::Handle::decode(r, s),
+                        handle: Handle::decode(r, s),
                     }
                 }
             }
@@ -161,7 +161,7 @@ struct Bridge<'a> {
     cached_buffer: Buffer,
 
     /// Server-side function that the client uses to make requests.
-    dispatch: closure::Closure<'a, Buffer, Buffer>,
+    dispatch: Closure<'a, Buffer, Buffer>,
 
     /// Provided globals for this macro expansion.
     globals: ExpnGlobals<Span>,
@@ -327,7 +327,7 @@ impl Client<crate::TokenStream, crate::TokenStream> {
     pub const fn expand1(f: impl Fn(crate::TokenStream) -> crate::TokenStream + Copy) -> Self {
         Client {
             handle_counters: &COUNTERS,
-            run: super::selfless_reify::reify_to_extern_c_fn_hrt_bridge(move |bridge| {
+            run: reify_to_extern_c_fn_hrt_bridge(move |bridge| {
                 run_client(bridge, |input| f(crate::TokenStream(Some(input))).0)
             }),
             _marker: PhantomData,
@@ -341,7 +341,7 @@ impl Client<(crate::TokenStream, crate::TokenStream), crate::TokenStream> {
     ) -> Self {
         Client {
             handle_counters: &COUNTERS,
-            run: super::selfless_reify::reify_to_extern_c_fn_hrt_bridge(move |bridge| {
+            run: reify_to_extern_c_fn_hrt_bridge(move |bridge| {
                 run_client(bridge, |(input, input2)| {
                     f(crate::TokenStream(Some(input)), crate::TokenStream(Some(input2))).0
                 })
diff --git a/library/proc_macro/src/backend/mod.rs b/library/proc_macro/src/backend/mod.rs
@@ -119,31 +119,24 @@ macro_rules! with_api_handle_types {
     };
 }
 
-#[allow(unsafe_code)]
-mod arena;
-#[allow(unsafe_code)]
-mod buffer;
 #[deny(unsafe_code)]
 pub mod client;
-#[allow(unsafe_code)]
-mod closure;
-#[forbid(unsafe_code)]
-mod fxhash;
-#[forbid(unsafe_code)]
-mod handle;
 #[macro_use]
 #[forbid(unsafe_code)]
 mod rpc;
-#[allow(unsafe_code)]
-mod selfless_reify;
 #[forbid(unsafe_code)]
 pub mod server;
+mod support;
 #[allow(unsafe_code)]
 mod symbol;
-
-use buffer::Buffer;
 pub use rpc::PanicMessage;
 use rpc::{Decode, DecodeMut, Encode, Reader, Writer};
+pub(crate) use support::arena::Arena;
+pub(crate) use support::buffer::Buffer;
+pub(crate) use support::closure::Closure;
+pub(crate) use support::fxhash::FxHashMap;
+pub(crate) use support::handle::{Handle, InternedStore, OwnedStore};
+pub(crate) use support::selfless_reify::reify_to_extern_c_fn_hrt_bridge;
 
 /// Configuration for establishing an active connection between a server and a
 /// client.  The server creates the bridge config (`run_server` in `server.rs`),
@@ -156,7 +149,7 @@ pub struct BridgeConfig<'a> {
     input: Buffer,
 
     /// Server-side function that the client uses to make requests.
-    dispatch: closure::Closure<'a, Buffer, Buffer>,
+    dispatch: Closure<'a, Buffer, Buffer>,
 
     /// If 'true', always invoke the default panic hook
     force_show_panics: bool,
diff --git a/library/proc_macro/src/backend/rpc.rs b/library/proc_macro/src/backend/rpc.rs
@@ -5,7 +5,7 @@ use std::io::Write;
 use std::num::NonZero;
 use std::str;
 
-pub(super) type Writer = super::buffer::Buffer;
+pub(super) type Writer = super::Buffer;
 
 pub(super) trait Encode<S>: Sized {
     fn encode(self, w: &mut Writer, s: &mut S);
diff --git a/library/proc_macro/src/backend/server.rs b/library/proc_macro/src/backend/server.rs
@@ -12,15 +12,15 @@ macro_rules! define_server_handles {
     ) => {
         #[allow(non_snake_case)]
         pub(super) struct HandleStore<S: Types> {
-            $($oty: handle::OwnedStore<S::$oty>,)*
-            $($ity: handle::InternedStore<S::$ity>,)*
+            $($oty: OwnedStore<S::$oty>,)*
+            $($ity: InternedStore<S::$ity>,)*
         }
 
         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),)*
+                    $($oty: OwnedStore::new(&handle_counters.$oty),)*
+                    $($ity: InternedStore::new(&handle_counters.$ity),)*
                 }
             }
         }
@@ -36,15 +36,15 @@ macro_rules! define_server_handles {
                 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 ()))
+                    s.$oty.take(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 HandleStore<MarkedTypes<S>>) -> Self {
-                    &s.$oty[handle::Handle::decode(r, &mut ())]
+                    &s.$oty[Handle::decode(r, &mut ())]
                 }
             }
 
@@ -55,7 +55,7 @@ macro_rules! define_server_handles {
                     r: &mut Reader<'_>,
                     s: &'s mut HandleStore<MarkedTypes<S>>
                 ) -> Self {
-                    &mut s.$oty[handle::Handle::decode(r, &mut ())]
+                    &mut s.$oty[Handle::decode(r, &mut ())]
                 }
             }
         )*
@@ -71,7 +71,7 @@ macro_rules! define_server_handles {
                 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 ()))
+                    s.$ity.copy(Handle::decode(r, &mut ()))
                 }
             }
         )*
diff --git a/library/proc_macro/src/backend/support/arena.rs b/library/proc_macro/src/backend/support/arena.rs
diff --git a/library/proc_macro/src/backend/support/buffer.rs b/library/proc_macro/src/backend/support/buffer.rs
@@ -41,17 +41,17 @@ impl DerefMut for Buffer {
 
 impl Buffer {
     #[inline]
-    pub(super) fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self::default()
     }
 
     #[inline]
-    pub(super) fn clear(&mut self) {
+    pub(crate) fn clear(&mut self) {
         self.len = 0;
     }
 
     #[inline]
-    pub(super) fn take(&mut self) -> Self {
+    pub(crate) fn take(&mut self) -> Self {
         mem::take(self)
     }
 
@@ -60,7 +60,7 @@ impl Buffer {
     // (avoiding a memmove call). With extend_from_slice, LLVM at least
     // currently is not able to make that optimization.
     #[inline]
-    pub(super) fn extend_from_array<const N: usize>(&mut self, xs: &[u8; N]) {
+    pub(crate) fn extend_from_array<const N: usize>(&mut self, xs: &[u8; N]) {
         if xs.len() > (self.capacity - self.len) {
             let b = self.take();
             *self = (b.reserve)(b, xs.len());
@@ -72,7 +72,7 @@ impl Buffer {
     }
 
     #[inline]
-    pub(super) fn extend_from_slice(&mut self, xs: &[u8]) {
+    pub(crate) fn extend_from_slice(&mut self, xs: &[u8]) {
         if xs.len() > (self.capacity - self.len) {
             let b = self.take();
             *self = (b.reserve)(b, xs.len());
@@ -84,7 +84,7 @@ impl Buffer {
     }
 
     #[inline]
-    pub(super) fn push(&mut self, v: u8) {
+    pub(crate) fn push(&mut self, v: u8) {
         // The code here is taken from Vec::push, and we know that reserve()
         // will panic if we're exceeding isize::MAX bytes and so there's no need
         // to check for overflow.
diff --git a/library/proc_macro/src/backend/support/closure.rs b/library/proc_macro/src/backend/support/closure.rs
@@ -3,7 +3,7 @@
 use std::marker::PhantomData;
 
 #[repr(C)]
-pub(super) struct Closure<'a, A, R> {
+pub(crate) struct Closure<'a, A, R> {
     call: unsafe extern "C" fn(*mut Env, A) -> R,
     env: *mut Env,
     // Prevent Send and Sync impls.
@@ -24,7 +24,7 @@ impl<'a, A, R, F: FnMut(A) -> R> From<&'a mut F> for Closure<'a, A, R> {
 }
 
 impl<'a, A, R> Closure<'a, A, R> {
-    pub(super) fn call(&mut self, arg: A) -> R {
+    pub(crate) fn call(&mut self, arg: A) -> R {
         unsafe { (self.call)(self.env, arg) }
     }
 }
diff --git a/library/proc_macro/src/backend/support/fxhash.rs b/library/proc_macro/src/backend/support/fxhash.rs
@@ -9,7 +9,7 @@ use std::hash::{BuildHasherDefault, Hasher};
 use std::ops::BitXor;
 
 /// Type alias for a hashmap using the `fx` hash algorithm.
-pub(super) type FxHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;
+pub(crate) type FxHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;
 
 /// A speedy hash algorithm for use within rustc. The hashmap in alloc by
 /// default uses SipHash which isn't quite as speedy as we want. In the compiler
@@ -23,7 +23,7 @@ pub(super) type FxHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;
 /// similar or slightly worse than FNV, but the speed of the hash function
 /// itself is much higher because it works on up to 8 bytes at a time.
 #[derive(Default)]
-pub(super) struct FxHasher {
+pub(crate) struct FxHasher {
     hash: usize,
 }
 
diff --git a/library/proc_macro/src/backend/support/handle.rs b/library/proc_macro/src/backend/support/handle.rs
@@ -8,17 +8,17 @@ use std::sync::atomic::{AtomicU32, Ordering};
 
 use super::fxhash::FxHashMap;
 
-pub(super) type Handle = NonZero<u32>;
+pub(crate) type Handle = NonZero<u32>;
 
 /// A store that associates values of type `T` with numeric handles. A value can
 /// be looked up using its handle.
-pub(super) struct OwnedStore<T: 'static> {
+pub(crate) struct OwnedStore<T: 'static> {
     counter: &'static AtomicU32,
     data: BTreeMap<Handle, T>,
 }
 
 impl<T> OwnedStore<T> {
-    pub(super) fn new(counter: &'static AtomicU32) -> Self {
+    pub(crate) fn new(counter: &'static AtomicU32) -> Self {
         // Ensure the handle counter isn't 0, which would panic later,
         // when `NonZero::new` (aka `Handle::new`) is called in `alloc`.
         assert_ne!(counter.load(Ordering::Relaxed), 0);
@@ -28,14 +28,14 @@ impl<T> OwnedStore<T> {
 }
 
 impl<T> OwnedStore<T> {
-    pub(super) fn alloc(&mut self, x: T) -> Handle {
+    pub(crate) fn alloc(&mut self, x: T) -> Handle {
         let counter = self.counter.fetch_add(1, Ordering::Relaxed);
         let handle = Handle::new(counter).expect("`proc_macro` handle counter overflowed");
         assert!(self.data.insert(handle, x).is_none());
         handle
     }
 
-    pub(super) fn take(&mut self, h: Handle) -> T {
+    pub(crate) fn take(&mut self, h: Handle) -> T {
         self.data.remove(&h).expect("use-after-free in `proc_macro` handle")
     }
 }
@@ -54,22 +54,22 @@ impl<T> IndexMut<Handle> for OwnedStore<T> {
 }
 
 /// Like `OwnedStore`, but avoids storing any value more than once.
-pub(super) struct InternedStore<T: 'static> {
+pub(crate) struct InternedStore<T: 'static> {
     owned: OwnedStore<T>,
     interner: FxHashMap<T, Handle>,
 }
 
 impl<T: Copy + Eq + Hash> InternedStore<T> {
-    pub(super) fn new(counter: &'static AtomicU32) -> Self {
+    pub(crate) fn new(counter: &'static AtomicU32) -> Self {
         InternedStore { owned: OwnedStore::new(counter), interner: FxHashMap::default() }
     }
 
-    pub(super) fn alloc(&mut self, x: T) -> Handle {
+    pub(crate) fn alloc(&mut self, x: T) -> Handle {
         let owned = &mut self.owned;
         *self.interner.entry(x).or_insert_with(|| owned.alloc(x))
     }
 
-    pub(super) fn copy(&mut self, h: Handle) -> T {
+    pub(crate) fn copy(&mut self, h: Handle) -> T {
         self.owned[h]
     }
 }
diff --git a/library/proc_macro/src/backend/support/mod.rs b/library/proc_macro/src/backend/support/mod.rs
@@ -0,0 +1,12 @@
+#[allow(unsafe_code)]
+pub(crate) mod arena;
+#[allow(unsafe_code)]
+pub(crate) mod buffer;
+#[allow(unsafe_code)]
+pub(crate) mod closure;
+#[forbid(unsafe_code)]
+pub(crate) mod fxhash;
+#[forbid(unsafe_code)]
+pub(crate) mod handle;
+#[allow(unsafe_code)]
+pub(crate) mod selfless_reify;
diff --git a/library/proc_macro/src/backend/support/selfless_reify.rs b/library/proc_macro/src/backend/support/selfless_reify.rs
@@ -44,7 +44,7 @@ macro_rules! define_reify_functions {
         fn $name:ident $(<$($param:ident),*>)?
             for $(extern $abi:tt)? fn($($arg:ident: $arg_ty:ty),*) -> $ret_ty:ty;
     )+) => {
-        $(pub(super) const fn $name<
+        $(pub(crate) const fn $name<
             $($($param,)*)?
             F: Fn($($arg_ty),*) -> $ret_ty + Copy
         >(f: F) -> $(extern $abi)? fn($($arg_ty),*) -> $ret_ty {
@@ -80,5 +80,5 @@ define_reify_functions! {
     // because of the `fn` pointer type being "higher-ranked" (i.e. the
     // `for<'a>` binder).
     // FIXME(eddyb) try to remove the lifetime from `BridgeConfig`, that'd help.
-    fn reify_to_extern_c_fn_hrt_bridge<R> for extern "C" fn(bridge: super::BridgeConfig<'_>) -> R;
+    fn reify_to_extern_c_fn_hrt_bridge<R> for extern "C" fn(bridge: crate::backend::BridgeConfig<'_>) -> R;
 }
diff --git a/library/proc_macro/src/backend/symbol.rs b/library/proc_macro/src/backend/symbol.rs
@@ -127,8 +127,8 @@ impl<S> DecodeMut<'_, '_, S> for Symbol {
 
 thread_local! {
     static INTERNER: RefCell<Interner> = RefCell::new(Interner {
-        arena: arena::Arena::new(),
-        names: fxhash::FxHashMap::default(),
+        arena: Arena::new(),
+        names: FxHashMap::default(),
         strings: Vec::new(),
         // Start with a base of 1 to make sure that `NonZero<u32>` works.
         sym_base: NonZero::new(1).unwrap(),
@@ -137,11 +137,11 @@ thread_local! {
 
 /// Basic interner for a `Symbol`, inspired by the one in `rustc_span`.
 struct Interner {
-    arena: arena::Arena,
+    arena: Arena,
     // SAFETY: These `'static` lifetimes are actually references to data owned
     // by the Arena. This is safe, as we never return them as static references
     // from `Interner`.
-    names: fxhash::FxHashMap<&'static str, Symbol>,
+    names: FxHashMap<&'static str, Symbol>,
     strings: Vec<&'static str>,
     // The offset to apply to symbol names stored in the interner. This is used
     // to ensure that symbol names are not re-used after the interner is
@@ -194,6 +194,6 @@ impl Interner {
 
         // SAFETY: This is cleared after the names and strings tables are
         // cleared out, so no references into the arena should remain.
-        self.arena = arena::Arena::new();
+        self.arena = Arena::new();
     }
 }
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
diff --git a/tests/ui/proc-macro/bad-projection.stderr b/tests/ui/proc-macro/bad-projection.stderr

Original file line number	Diff line number	Diff line change
`@@ -12,15 +12,15 @@ macro_rules! define_server_handles {`
`12`	`12`	`) => {`
`13`	`13`	`#[allow(non_snake_case)]`
`14`	`14`	`pub(super) struct HandleStore<S: Types> {`
`15`		`- $($oty: handle::OwnedStore<S::$oty>,)*`
`16`		`- $($ity: handle::InternedStore<S::$ity>,)*`
	`15`	`+ $($oty: OwnedStore<S::$oty>,)*`
	`16`	`+ $($ity: InternedStore<S::$ity>,)*`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`impl<S: Types> HandleStore<S> {`
`20`	`20`	`fn new(handle_counters: &'static client::HandleCounters) -> Self {`
`21`	`21`	`HandleStore {`
`22`		`- $($oty: handle::OwnedStore::new(&handle_counters.$oty),)*`
`23`		`- $($ity: handle::InternedStore::new(&handle_counters.$ity),)*`
	`22`	`+ $($oty: OwnedStore::new(&handle_counters.$oty),)*`
	`23`	`+ $($ity: InternedStore::new(&handle_counters.$ity),)*`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`}`
`@@ -36,15 +36,15 @@ macro_rules! define_server_handles {`
`36`	`36`	`for Marked<S::$oty, client::$oty>`
`37`	`37`	`{`
`38`	`38`	`fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {`
`39`		`- s.$oty.take(handle::Handle::decode(r, &mut ()))`
	`39`	`+ s.$oty.take(Handle::decode(r, &mut ()))`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>`
`44`	`44`	`for &'s Marked<S::$oty, client::$oty>`
`45`	`45`	`{`
`46`	`46`	`fn decode(r: &mut Reader<'_>, s: &'s HandleStore<MarkedTypes<S>>) -> Self {`
`47`		`- &s.$oty[handle::Handle::decode(r, &mut ())]`
	`47`	`+ &s.$oty[Handle::decode(r, &mut ())]`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`@@ -55,7 +55,7 @@ macro_rules! define_server_handles {`
`55`	`55`	`r: &mut Reader<'_>,`
`56`	`56`	`s: &'s mut HandleStore<MarkedTypes<S>>`
`57`	`57`	`) -> Self {`
`58`		`- &mut s.$oty[handle::Handle::decode(r, &mut ())]`
	`58`	`+ &mut s.$oty[Handle::decode(r, &mut ())]`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`	`)*`
`@@ -71,7 +71,7 @@ macro_rules! define_server_handles {`
`71`	`71`	`for Marked<S::$ity, client::$ity>`
`72`	`72`	`{`
`73`	`73`	`fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {`
`74`		`- s.$ity.copy(handle::Handle::decode(r, &mut ()))`
	`74`	`+ s.$ity.copy(Handle::decode(r, &mut ()))`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`)*`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`use std::marker::PhantomData;`
`4`	`4`
`5`	`5`	`#[repr(C)]`
`6`		`-pub(super) struct Closure<'a, A, R> {`
	`6`	`+pub(crate) struct Closure<'a, A, R> {`
`7`	`7`	`call: unsafe extern "C" fn(*mut Env, A) -> R,`
`8`	`8`	`env: *mut Env,`
`9`	`9`	`// Prevent Send and Sync impls.`
`@@ -24,7 +24,7 @@ impl<'a, A, R, F: FnMut(A) -> R> From<&'a mut F> for Closure<'a, A, R> {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`impl<'a, A, R> Closure<'a, A, R> {`
`27`		`- pub(super) fn call(&mut self, arg: A) -> R {`
	`27`	`+ pub(crate) fn call(&mut self, arg: A) -> R {`
`28`	`28`	`unsafe { (self.call)(self.env, arg) }`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,17 +8,17 @@ use std::sync::atomic::{AtomicU32, Ordering};`
`8`	`8`
`9`	`9`	`use super::fxhash::FxHashMap;`
`10`	`10`
`11`		`-pub(super) type Handle = NonZero<u32>;`
	`11`	`+pub(crate) type Handle = NonZero<u32>;`
`12`	`12`
`13`	`13`	/// A store that associates values of type `T` with numeric handles. A value can
`14`	`14`	`/// be looked up using its handle.`
`15`		`-pub(super) struct OwnedStore<T: 'static> {`
	`15`	`+pub(crate) struct OwnedStore<T: 'static> {`
`16`	`16`	`counter: &'static AtomicU32,`
`17`	`17`	`data: BTreeMap<Handle, T>,`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`impl<T> OwnedStore<T> {`
`21`		`- pub(super) fn new(counter: &'static AtomicU32) -> Self {`
	`21`	`+ pub(crate) fn new(counter: &'static AtomicU32) -> Self {`
`22`	`22`	`// Ensure the handle counter isn't 0, which would panic later,`
`23`	`23`	// when `NonZero::new` (aka `Handle::new`) is called in `alloc`.
`24`	`24`	`assert_ne!(counter.load(Ordering::Relaxed), 0);`
`@@ -28,14 +28,14 @@ impl<T> OwnedStore<T> {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`impl<T> OwnedStore<T> {`
`31`		`- pub(super) fn alloc(&mut self, x: T) -> Handle {`
	`31`	`+ pub(crate) fn alloc(&mut self, x: T) -> Handle {`
`32`	`32`	`let counter = self.counter.fetch_add(1, Ordering::Relaxed);`
`33`	`33`	let handle = Handle::new(counter).expect("`proc_macro` handle counter overflowed");
`34`	`34`	`assert!(self.data.insert(handle, x).is_none());`
`35`	`35`	`handle`
`36`	`36`	`}`
`37`	`37`
`38`		`- pub(super) fn take(&mut self, h: Handle) -> T {`
	`38`	`+ pub(crate) fn take(&mut self, h: Handle) -> T {`
`39`	`39`	self.data.remove(&h).expect("use-after-free in `proc_macro` handle")
`40`	`40`	`}`
`41`	`41`	`}`
`@@ -54,22 +54,22 @@ impl<T> IndexMut<Handle> for OwnedStore<T> {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	/// Like `OwnedStore`, but avoids storing any value more than once.
`57`		`-pub(super) struct InternedStore<T: 'static> {`
	`57`	`+pub(crate) struct InternedStore<T: 'static> {`
`58`	`58`	`owned: OwnedStore<T>,`
`59`	`59`	`interner: FxHashMap<T, Handle>,`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`impl<T: Copy + Eq + Hash> InternedStore<T> {`
`63`		`- pub(super) fn new(counter: &'static AtomicU32) -> Self {`
	`63`	`+ pub(crate) fn new(counter: &'static AtomicU32) -> Self {`
`64`	`64`	`InternedStore { owned: OwnedStore::new(counter), interner: FxHashMap::default() }`
`65`	`65`	`}`
`66`	`66`
`67`		`- pub(super) fn alloc(&mut self, x: T) -> Handle {`
	`67`	`+ pub(crate) fn alloc(&mut self, x: T) -> Handle {`
`68`	`68`	`let owned = &mut self.owned;`
`69`	`69`	`*self.interner.entry(x).or_insert_with(\|\| owned.alloc(x))`
`70`	`70`	`}`
`71`	`71`
`72`		`- pub(super) fn copy(&mut self, h: Handle) -> T {`
	`72`	`+ pub(crate) fn copy(&mut self, h: Handle) -> T {`
`73`	`73`	`self.owned[h]`
`74`	`74`	`}`
`75`	`75`	`}`