Replace TrivialTypeTraversal macros with derives

Author: eggyal

compiler/rustc_middle/src/macros.rs

@@ -62,60 +62,3 @@ macro_rules! CloneLiftImpls {
         }
     };
 }
-
-/// 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 })+
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! TrivialTypeTraversalAndLiftImpls {
-    ($($t:tt)*) => {
-        TrivialTypeTraversalImpls! { $($t)* }
-        CloneLiftImpls! { $($t)* }
-    }
-}

compiler/rustc_middle/src/ty/mod.rs

@@ -291,6 +291,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

@@ -235,6 +235,7 @@ CloneLiftImpls! {
     crate::traits::Reveal,
     crate::ty::adjustment::AutoBorrowMutability,
     crate::ty::AdtKind,
+    crate::ty::BoundConstness,
     crate::ty::BoundRegionKind,
     crate::ty::AssocItem,
     crate::ty::AssocKind,
@@ -261,14 +262,6 @@ CloneLiftImpls! {
     ty::Placeholder<ty::BoundVar>,
 }
 
-// For things about which the type library does not know, or does not
-// provide any traversal implementations, we need to provide both a Lift
-// implementation and traversal implementations (the latter only for
-// TyCtxt<'_> interners).
-TrivialTypeTraversalAndLiftImpls! {
-    crate::ty::BoundConstness,
-}
-
 CloneLiftImpls! {
     for<'tcx> {
         ty::ValTree<'tcx>,

compiler/rustc_type_ir/src/macros.rs

@@ -1,39 +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(())
-                }
-            }
-        )+
-    };
-}
-
 macro_rules! EnumTypeTraversalImpl {
     (impl<$($p:tt),*> TypeFoldable<$tcx:tt> for $s:path {
         $($variants:tt)*

compiler/rustc_type_ir/src/structural_impls.rs

@@ -13,17 +13,22 @@ use std::rc::Rc;
 use std::sync::Arc;
 
 ///////////////////////////////////////////////////////////////////////////
-// Atomic structs
-//
-// For things that don't carry any arena-allocated data (and are
-// copy...), just add them to this list.
+// Traversable implementations for upstream types.
 
-TrivialTypeTraversalImpls! {
-    (),
+// `()` is (obviously) a no-op traversal and therefore the auto-deref specialisation normally
+// negates any need for explicit implementation, however `ProjectionElem`'s implementation
+// requires its second type parameter to implement these traits and (annoyingly)
+// `ProjectionKind` (currently) uses unit type for that parameter.
+impl<I: Interner> TypeFoldable<I> for () {
+    fn try_fold_with<F: FallibleTypeFolder<I>>(self, _: &mut F) -> Result<(), F::Error> {
+        Ok(())
+    }
+}
+impl<I: Interner> TypeVisitable<I> for () {
+    fn visit_with<V: TypeVisitor<I>>(&self, _: &mut V) -> ControlFlow<V::BreakTy> {
+        ControlFlow::Continue(())
+    }
 }
-
-///////////////////////////////////////////////////////////////////////////
-// Traversable implementations for upstream types.
 
 // 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