Remove TrivialTypeTraversal macros

Author: eggyal

compiler/rustc_middle/src/macros.rs

@@ -54,52 +54,3 @@ macro_rules! TrivialLiftImpls {
         )+
     };
 }
-
-/// Used for types that are `Copy` and which **do not care arena
-/// allocated data** (i.e., don't need to be folded).
-#[macro_export]
-macro_rules! TrivialTypeTraversalImpls {
-    ($(for { $($generic:tt)+ } { $interner:ty } { $ty:ty })+) => {
-        $(
-            impl<$($generic)+> $crate::ty::fold::TypeFoldable<$interner> for $ty {
-                fn try_fold_with<F: $crate::ty::fold::FallibleTypeFolder<$interner>>(
-                    self,
-                    _: &mut F,
-                ) -> ::std::result::Result<Self, F::Error> {
-                    Ok(self)
-                }
-
-                #[inline]
-                fn fold_with<F: $crate::ty::fold::TypeFolder<$interner>>(
-                    self,
-                    _: &mut F,
-                ) -> Self {
-                    self
-                }
-            }
-
-            impl<$($generic)+> $crate::ty::visit::TypeVisitable<$interner> for $ty {
-                #[inline]
-                fn visit_with<F: $crate::ty::visit::TypeVisitor<$interner>>(
-                    &self,
-                    _: &mut F)
-                    -> ::std::ops::ControlFlow<F::BreakTy>
-                {
-                    ::std::ops::ControlFlow::Continue(())
-                }
-            }
-        )+
-    };
-
-    (for <$tcx:lifetime> { $($ty:ty),+ $(,)? }) => {
-        TrivialTypeTraversalImpls! {
-            $(for { $tcx } { $crate::ty::TyCtxt<$tcx> } { $ty })+
-        }
-    };
-
-    ($($ty:ty),+ $(,)?) => {
-        TrivialTypeTraversalImpls! {
-            $(for { I: $crate::ty::Interner } { I } { $ty })+
-        }
-    };
-}

compiler/rustc_middle/src/ty/mod.rs

@@ -304,6 +304,7 @@ pub enum Visibility<Id = LocalDefId> {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable, TyEncodable, TyDecodable)]
+#[derive(TypeFoldable, TypeVisitable)]
 pub enum BoundConstness {
     /// `T: Trait`
     NotConst,

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -418,13 +418,6 @@ TrivialLiftImpls! {
      rustc_target::abi::Size,
 }
 
-// For some things about which the type library does not know, or does not
-// provide any traversal implementations, we need to provide a traversal
-// implementation (only for TyCtxt<'_> interners).
-TrivialTypeTraversalImpls! {
-    crate::ty::BoundConstness,
-}
-
 ///////////////////////////////////////////////////////////////////////////
 // Lift implementations
 

compiler/rustc_type_ir/src/fold.rs

@@ -287,6 +287,16 @@ impl<I: Interner, T: BoringTraversable> SpecTypeFoldable<I> for &PhantomData<T>
 ///////////////////////////////////////////////////////////////////////////
 // Traversable implementations for upstream types.
 
+// `()` is (obviously) a no-op traversal and therefore the auto-deref specialisation normally
+// negates any need for explicit implementation, however there are implementations of
+// `QueryTypeOp` that have have unit `QueryResponse` -- and that associated type must be
+// traversable for some generic operations to work upon it.
+impl<I: Interner> TypeFoldable<I> for () {
+    fn try_fold_with<F: FallibleTypeFolder<I>>(self, _: &mut F) -> Result<(), F::Error> {
+        Ok(())
+    }
+}
+
 // We provide implementations for 2- and 3-element tuples, however (absent specialisation)
 // we can only provide for one case: we choose our implementations to be where all elements
 // themselves implement the respective traits; thus if an element is a no-op traversal, it

compiler/rustc_type_ir/src/macros.rs

@@ -1,49 +1,3 @@
-/// Used for types that are `Copy` and which **do not care arena
-/// allocated data** (i.e., don't need to be folded).
-macro_rules! TrivialTypeTraversalImpls {
-    ($($ty:ty,)+) => {
-        $(
-            impl<I: $crate::Interner> $crate::fold::TypeFoldable<I> for $ty {
-                fn try_fold_with<F: $crate::fold::FallibleTypeFolder<I>>(
-                    self,
-                    _: &mut F,
-                ) -> ::std::result::Result<Self, F::Error> {
-                    Ok(self)
-                }
-
-                #[inline]
-                fn fold_with<F: $crate::fold::TypeFolder<I>>(
-                    self,
-                    _: &mut F,
-                ) -> Self {
-                    self
-                }
-            }
-
-            impl<I: $crate::Interner> $crate::visit::TypeVisitable<I> for $ty {
-                #[inline]
-                fn visit_with<F: $crate::visit::TypeVisitor<I>>(
-                    &self,
-                    _: &mut F)
-                    -> ::std::ops::ControlFlow<F::BreakTy>
-                {
-                    ::std::ops::ControlFlow::Continue(())
-                }
-            }
-        )+
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////
-// Atomic structs
-//
-// For things that don't carry any arena-allocated data (and are
-// copy...), just add them to this list.
-
-TrivialTypeTraversalImpls! {
-    (),
-}
-
 #[macro_export]
 macro_rules! noop_traversal_if_boring {
     ($val:tt.try_fold_with($folder:expr)) => {{

compiler/rustc_type_ir/src/visit.rs

@@ -155,6 +155,16 @@ impl<I: Interner, T: ?Sized + BoringTraversable> SpecTypeVisitable<I> for &Phant
 ///////////////////////////////////////////////////////////////////////////
 // Traversable implementations for upstream types.
 
+// `()` is (obviously) a no-op traversal and therefore the auto-deref specialisation normally
+// negates any need for explicit implementation, however there are implementations of
+// `QueryTypeOp` that have have unit `QueryResponse` -- and that associated type must be
+// traversable for some generic operations to work upon it.
+impl<I: Interner> TypeVisitable<I> for () {
+    fn visit_with<V: TypeVisitor<I>>(&self, _: &mut V) -> ControlFlow<V::BreakTy> {
+        ControlFlow::Continue(())
+    }
+}
+
 // We provide implementations for 2- and 3-element tuples, however (absent specialisation)
 // we can only provide for one case: we choose our implementations to be where all elements
 // themselves implement the respective traits; thus if an element is a no-op traversal, it