Make no-op traversables generic over the interner

Author: eggyal

Cargo.lock

@@ -4693,6 +4693,7 @@ dependencies = [
  "rustc_serialize",
  "rustc_span",
  "rustc_target",
+ "rustc_type_ir",
  "smallvec",
  "tracing",
 ]
@@ -5340,6 +5341,7 @@ dependencies = [
  "rustc_macros",
  "rustc_serialize",
  "rustc_span",
+ "rustc_type_ir",
  "serde_json",
  "tracing",
 ]

compiler/rustc_hir/Cargo.toml

@@ -15,6 +15,7 @@ rustc_index = { path = "../rustc_index" }
 rustc_span = { path = "../rustc_span" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_ast = { path = "../rustc_ast" }
+rustc_type_ir = { path = "../rustc_type_ir" }
 tracing = "0.1"
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 odht = { version = "0.3.1", features = ["nightly"] }

compiler/rustc_hir/src/hir.rs

@@ -3190,7 +3190,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

@@ -67,28 +67,28 @@ macro_rules! CloneLiftImpls {
 /// allocated data** (i.e., don't need to be folded).
 #[macro_export]
 macro_rules! TrivialTypeTraversalImpls {
-    (for <$tcx:lifetime> { $($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>
@@ -99,11 +99,15 @@ macro_rules! TrivialTypeTraversalImpls {
         )+
     };
 
+    (for <$tcx:lifetime> { $($ty:ty,)+ }) => {
+        TrivialTypeTraversalImpls! {
+            $(for { $tcx } { $crate::ty::TyCtxt<$tcx> } { $ty })+
+        }
+    };
+
     ($($ty:ty,)+) => {
         TrivialTypeTraversalImpls! {
-            for<'tcx> {
-                $($ty,)+
-            }
+            $(for { I: $crate::ty::Interner } { I } { $ty })+
         }
     };
 }

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -12,7 +12,6 @@ use crate::ty::{self, AliasTy, Lift, Term, TermKind, Ty, TyCtxt};
 use rustc_hir::def::Namespace;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_span::source_map::Spanned;
-use rustc_target::abi::TyAndLayout;
 
 use std::fmt;
 use std::ops::ControlFlow;
@@ -223,7 +222,9 @@ CloneLiftImpls! {
     ::rustc_hir::HirId,
     ::rustc_hir::MatchSource,
     ::rustc_hir::Mutability,
+    ::rustc_hir::Unsafety,
     ::rustc_target::asm::InlineAsmRegOrRegClass,
+    ::rustc_target::spec::abi::Abi,
     crate::mir::coverage::ExpressionOperandId,
     crate::mir::coverage::CounterValueReference,
     crate::mir::coverage::InjectedExpressionId,
@@ -265,8 +266,6 @@ CloneLiftImpls! {
 // implementation and traversal implementations (the latter only for
 // TyCtxt<'_> interners).
 TrivialTypeTraversalAndLiftImpls! {
-    ::rustc_hir::Unsafety,
-    ::rustc_target::spec::abi::Abi,
     crate::ty::BoundConstness,
 }
 
@@ -675,9 +674,3 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for ty::UnevaluatedConst<'tcx> {
         self.substs.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,3 +14,4 @@ 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" }

compiler/rustc_target/src/abi/mod.rs

@@ -24,7 +24,7 @@ impl ToJson for Endian {
 /// 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, Debug, PartialEq, Eq, Hash, HashStable_Generic)]
+#[derive(Copy, Clone, Debug, 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