Make no-op traversables generic over the interner

Author: eggyal

Cargo.lock

@@ -3931,6 +3931,7 @@ dependencies = [
  "rustc_serialize",
  "rustc_span",
  "rustc_target",
+ "rustc_type_ir",
  "smallvec",
  "tracing",
 ]
@@ -4585,6 +4586,7 @@ dependencies = [
  "rustc_macros",
  "rustc_serialize",
  "rustc_span",
+ "rustc_type_ir",
  "serde_json",
  "tracing",
 ]

compiler/rustc_hir/Cargo.toml

@@ -15,6 +15,7 @@ rustc_macros = { path = "../rustc_macros" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
+rustc_type_ir = { path = "../rustc_type_ir" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 tracing = "0.1"
 # tidy-alphabetical-end

compiler/rustc_hir/src/hir.rs

@@ -3256,7 +3256,7 @@ impl<'hir> Item<'hir> {
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-#[derive(Encodable, Decodable, HashStable_Generic)]
+#[derive(Encodable, Decodable, HashStable_Generic, TypeFoldable, TypeVisitable)]
 pub enum Unsafety {
     Unsafe,
     Normal,

compiler/rustc_middle/src/macros.rs

@@ -59,28 +59,28 @@ macro_rules! TrivialLiftImpls {
 /// allocated data** (i.e., don't need to be folded).
 #[macro_export]
 macro_rules! TrivialTypeTraversalImpls {
-    ($($ty:ty),+ $(,)?) => {
+    ($(for { $($generic:tt)+ } { $interner:ty } { $ty:ty })+) => {
         $(
-            impl<'tcx> $crate::ty::fold::TypeFoldable<$crate::ty::TyCtxt<'tcx>> for $ty {
-                fn try_fold_with<F: $crate::ty::fold::FallibleTypeFolder<$crate::ty::TyCtxt<'tcx>>>(
+            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<$crate::ty::TyCtxt<'tcx>>>(
+                fn fold_with<F: $crate::ty::fold::TypeFolder<$interner>>(
                     self,
                     _: &mut F,
                 ) -> Self {
                     self
                 }
             }
 
-            impl<'tcx> $crate::ty::visit::TypeVisitable<$crate::ty::TyCtxt<'tcx>> for $ty {
+            impl<$($generic)+> $crate::ty::visit::TypeVisitable<$interner> for $ty {
                 #[inline]
-                fn visit_with<F: $crate::ty::visit::TypeVisitor<$crate::ty::TyCtxt<'tcx>>>(
+                fn visit_with<F: $crate::ty::visit::TypeVisitor<$interner>>(
                     &self,
                     _: &mut F)
                     -> ::std::ops::ControlFlow<F::BreakTy>
@@ -90,12 +90,16 @@ macro_rules! TrivialTypeTraversalImpls {
             }
         )+
     };
-}
 
-#[macro_export]
-macro_rules! TrivialTypeTraversalAndLiftImpls {
-    ($($t:tt)*) => {
-        TrivialTypeTraversalImpls! { $($t)* }
-        TrivialLiftImpls! { $($t)* }
-    }
+    (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/structural_impls.rs

@@ -10,7 +10,6 @@ use crate::ty::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor};
 use crate::ty::{self, AliasTy, InferConst, Lift, Term, TermKind, Ty, TyCtxt};
 use rustc_hir::def::Namespace;
 use rustc_span::source_map::Spanned;
-use rustc_target::abi::TyAndLayout;
 use rustc_type_ir::{ConstKind, DebugWithInfcx, InferCtxtLike, WithInfcx};
 
 use std::fmt::{self, Debug};
@@ -409,6 +408,8 @@ TrivialLiftImpls! {
      u64,
      ::rustc_hir::def_id::DefId,
      ::rustc_hir::Mutability,
+     ::rustc_hir::Unsafety,
+     ::rustc_target::spec::abi::Abi,
      crate::ty::ClosureKind,
      crate::ty::ParamConst,
      crate::ty::ParamTy,
@@ -423,14 +424,6 @@ TrivialLiftImpls! {
 TrivialTypeTraversalImpls! {
     crate::ty::BoundConstness,
 }
-// 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 and a lift implementation (the former only for TyCtxt<'_>
-// interners).
-TrivialTypeTraversalAndLiftImpls! {
-    ::rustc_hir::Unsafety,
-    ::rustc_target::spec::abi::Abi,
-}
 
 ///////////////////////////////////////////////////////////////////////////
 // Lift implementations
@@ -753,9 +746,3 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for ty::UnevaluatedConst<'tcx> {
         self.args.visit_with(visitor)
     }
 }
-
-impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for TyAndLayout<'tcx, Ty<'tcx>> {
-    fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
-        visitor.visit_ty(self.ty)
-    }
-}

compiler/rustc_target/Cargo.toml

@@ -14,6 +14,7 @@ rustc_index = { path = "../rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_span = { path = "../rustc_span" }
+rustc_type_ir = { path = "../rustc_type_ir" }
 serde_json = "1.0.59"
 tracing = "0.1"
 # tidy-alphabetical-end

compiler/rustc_target/src/abi/mod.rs

@@ -131,7 +131,7 @@ impl<'a> Layout<'a> {
 /// to that obtained from `layout_of(ty)`, as we need to produce
 /// layouts for which Rust types do not exist, such as enum variants
 /// or synthetic fields of enums (i.e., discriminants) and fat pointers.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable_Generic)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable_Generic, TypeVisitable)]
 pub struct TyAndLayout<'a, Ty> {
     pub ty: Ty,
     pub layout: Layout<'a>,

compiler/rustc_target/src/spec/abi.rs

@@ -8,7 +8,7 @@ use rustc_span::{Span, Symbol};
 mod tests;
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Debug)]
-#[derive(HashStable_Generic, Encodable, Decodable)]
+#[derive(HashStable_Generic, Encodable, Decodable, TypeFoldable, TypeVisitable)]
 pub enum Abi {
     // Some of the ABIs come first because every time we add a new ABI, we have to re-bless all the
     // hashing tests. These are used in many places, so giving them stable values reduces test