Derive traversables over generic interners

Author: eggyal

compiler/rustc_macros/src/lib.rs

@@ -93,13 +93,12 @@ decl_derive!(
     /// to miscompilation if user expectations are not met!**  Nevertheless, such can be achieved
     /// via a `#[skip_traversal(despite_potential_miscompilation_because = "<reason>"]` attribute.
     ///
-    /// If the annotated type has a `'tcx` lifetime parameter, then that will be used as the
-    /// lifetime for the type context/interner; otherwise the lifetime of the type context/interner
-    /// will be unrelated to the annotated type. It therefore matters how any lifetime parameters of
-    /// the annotated type are named. For example, deriving `TypeFoldable` for both `Foo<'a>` and
-    /// `Bar<'tcx>` will respectively produce:
+    /// The derived implementation will use `TyCtxt<'tcx>` as the interner iff the annotated type
+    /// has a `'tcx` lifetime parameter; otherwise it will be generic over all interners. It
+    /// therefore matters how any lifetime parameters of the annotated type are named. For example,
+    /// deriving `TypeFoldable` for both `Foo<'a>` and `Bar<'tcx>` will respectively produce:
     ///
-    /// `impl<'a, 'tcx> TypeFoldable<TyCtxt<'tcx>> for Foo<'a>`
+    /// `impl<'a, I: Interner> TypeFoldable<I> for Foo<'a>`
     ///
     /// and
     ///
@@ -125,13 +124,12 @@ decl_derive!(
     /// to miscompilation if user expectations are not met!**  Nevertheless, such can be achieved
     /// via a `#[skip_traversal(despite_potential_miscompilation_because = "<reason>"]` attribute.
     ///
-    /// If the annotated type has a `'tcx` lifetime parameter, then that will be used as the
-    /// lifetime for the type context/interner; otherwise the lifetime of the type context/interner
-    /// will be unrelated to the annotated type. It therefore matters how any lifetime parameters of
-    /// the annotated type are named. For example, deriving `TypeVisitable` for both `Foo<'a>` and
-    /// `Bar<'tcx>` will respectively produce:
+    /// The derived implementation will use `TyCtxt<'tcx>` as the interner iff the annotated type
+    /// has a `'tcx` lifetime parameter; otherwise it will be generic over all interners. It
+    /// therefore matters how any lifetime parameters of the annotated type are named. For example,
+    /// deriving `TypeVisitable` for both `Foo<'a>` and `Bar<'tcx>` will respectively produce:
     ///
-    /// `impl<'a, 'tcx> TypeVisitable<TyCtxt<'tcx>> for Foo<'a>`
+    /// `impl<'a, I: Interner> TypeVisitable<I> for Foo<'a>`
     ///
     /// and
     ///

compiler/rustc_macros/src/traversable.rs

@@ -113,28 +113,30 @@ impl WhenToSkip {
     }
 }
 
-pub struct Interner<'a>(Option<&'a Lifetime>);
+pub enum Interner<'a> {
+    Middle(&'a Lifetime),
+    Generic(Ident),
+}
 
 impl<'a> Interner<'a> {
-    /// Return the `TyCtxt` interner for the given `structure`.
+    /// Return the interner for the given `structure`.
     ///
-    /// If the input represented by `structure` has a `'tcx` lifetime parameter, then that will be used
-    /// used as the lifetime of the `TyCtxt`. Otherwise a `'tcx` lifetime parameter that is unrelated
-    /// to the input will be used.
-    fn resolve(generics: &'a Generics) -> Self {
-        Self(
-            generics
-                .lifetimes()
-                .find_map(|def| (def.lifetime.ident == "tcx").then_some(&def.lifetime)),
-        )
+    /// If the input represented by `structure` has a `'tcx` lifetime parameter, then `Middle('tcx)`
+    /// will be returned; otherwise our derived implementation will be generic over a new parameter.
+    fn resolve(suffix: impl ToString, generics: &'a Generics) -> Self {
+        generics
+            .lifetimes()
+            .find_map(|def| (def.lifetime.ident == "tcx").then_some(Self::Middle(&def.lifetime)))
+            .unwrap_or_else(|| Self::Generic(gen_param(suffix, generics)))
     }
 }
 
 impl ToTokens for Interner<'_> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let default = parse_quote! { 'tcx };
-        let lt = self.0.unwrap_or(&default);
-        tokens.extend(quote! { ::rustc_middle::ty::TyCtxt<#lt> });
+        match self {
+            Interner::Middle(lt) => tokens.extend(quote! { ::rustc_middle::ty::TyCtxt<#lt> }),
+            Interner::Generic(ident) => ident.to_tokens(tokens),
+        }
     }
 }
 
@@ -273,8 +275,8 @@ impl Interner<'_> {
         if !referenced_ty_params.is_empty() {
             Generic
         } else {
-            match &self.0 {
-                Some(interner)
+            match self {
+                Interner::Middle(interner)
                     if fields.into_iter().any(|field| {
                         let mut visitor = Visitor { interner, contains_interner: false };
                         visitor.visit_type(&field.ty);
@@ -298,16 +300,16 @@ pub fn traversable_derive<T: Traversable>(
 
     let ast = structure.ast();
 
-    let interner = Interner::resolve(&ast.generics);
+    let interner = Interner::resolve("I", &ast.generics);
     let traverser = gen_param("T", &ast.generics);
     let traversable = T::traversable(&interner);
 
     structure.underscore_const(true);
     structure.add_bounds(synstructure::AddBounds::None);
     structure.bind_with(|_| synstructure::BindStyle::Move);
 
-    let not_generic = if interner.0.is_none() {
-        structure.add_impl_generic(parse_quote! { 'tcx });
+    let not_generic = if let Interner::Generic(ident) = &interner {
+        structure.add_impl_generic(parse_quote! { #ident: ::rustc_type_ir::Interner });
         Boring
     } else {
         NotGeneric

compiler/rustc_macros/src/traversable/tests.rs

@@ -275,11 +275,11 @@ fn skipping_generic_type_requires_justification() {
             #[skip_traversal(despite_potential_miscompilation_because = ".")]
             struct SomethingInteresting<T>;
         } => {
-            impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for SomethingInteresting<T>
+            impl<I: Interner, T> TypeFoldable<I> for SomethingInteresting<T>
             where
-                Self: TypeVisitable<TyCtxt<'tcx>>
+                Self: TypeVisitable<I>
             {
-                fn try_fold_with<_T: FallibleTypeFolder<TyCtxt<'tcx>>>(self, folder: &mut _T) -> Result<Self, _T::Error> {
+                fn try_fold_with<_T: FallibleTypeFolder<I>>(self, folder: &mut _T) -> Result<Self, _T::Error> {
                     Ok(self) // no attempt to fold fields
                 }
             }
@@ -303,12 +303,12 @@ fn skipping_generic_field_requires_justification() {
                 T,
             );
         } => {
-            impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for SomethingInteresting<T>
+            impl<I: Interner, T> TypeFoldable<I> for SomethingInteresting<T>
             where
-                Self: TypeVisitable<TyCtxt<'tcx>>,
+                Self: TypeVisitable<I>,
                 T: BoringTraversable // `because_boring`
             {
-                fn try_fold_with<_T: FallibleTypeFolder<TyCtxt<'tcx>>>(self, folder: &mut _T) -> Result<Self, _T::Error> {
+                fn try_fold_with<_T: FallibleTypeFolder<I>>(self, folder: &mut _T) -> Result<Self, _T::Error> {
                     Ok(match self {
                         SomethingInteresting(__binding_0,) => { SomethingInteresting(__binding_0,) } // not folded
                     })
@@ -322,11 +322,11 @@ fn skipping_generic_field_requires_justification() {
                 T,
             );
         } => {
-            impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for SomethingInteresting<T>
+            impl<I: Interner, T> TypeFoldable<I> for SomethingInteresting<T>
             where
-                Self: TypeVisitable<TyCtxt<'tcx>> // no constraint on T
+                Self: TypeVisitable<I> // no constraint on T
             {
-                fn try_fold_with<_T: FallibleTypeFolder<TyCtxt<'tcx>>>(self, folder: &mut _T) -> Result<Self, _T::Error> {
+                fn try_fold_with<_T: FallibleTypeFolder<I>>(self, folder: &mut _T) -> Result<Self, _T::Error> {
                     Ok(match self {
                         SomethingInteresting(__binding_0,) => { SomethingInteresting(__binding_0,) } // not folded
                     })