Generify trivial traversables over the interner

Author: eggyal

Cargo.lock

@@ -3918,6 +3918,7 @@ dependencies = [
  "rustc_serialize",
  "rustc_span",
  "rustc_target",
+ "rustc_type_ir",
  "smallvec",
  "tracing",
 ]
@@ -4572,6 +4573,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/closure.rs

@@ -77,7 +77,7 @@ pub type MinCaptureList<'tcx> = Vec<CapturedPlace<'tcx>>;
 /// You can get the environment type of a closure using
 /// `tcx.closure_env_ty()`.
 #[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable)]
-#[derive(HashStable)]
+#[derive(HashStable, TypeFoldable, TypeVisitable)]
 pub enum ClosureKind {
     // Warning: Ordering is significant here! The ordering is chosen
     // because the trait Fn is a subtrait of FnMut and so in turn, and

compiler/rustc_middle/src/ty/mod.rs

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

@@ -12,7 +12,6 @@ use crate::ty::{
 };
 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,31 +408,18 @@ TrivialLiftImpls! {
      bool,
      usize,
      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,
      interpret::Scalar,
      interpret::AllocId,
      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,
-}
-// 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::def_id::DefId,
-    ::rustc_hir::Unsafety,
-    ::rustc_target::spec::abi::Abi,
-    crate::ty::ClosureKind,
-}
-
 ///////////////////////////////////////////////////////////////////////////
 // Lift implementations
 
@@ -807,9 +793,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_span/src/def_id.rs

@@ -238,7 +238,7 @@ impl<D: Decoder> Decodable<D> for DefIndex {
 /// index and a def index.
 ///
 /// You can create a `DefId` from a `LocalDefId` using `local_def_id.to_def_id()`.
-#[derive(Clone, PartialEq, Eq, Copy)]
+#[derive(Clone, PartialEq, Eq, Copy, TypeFoldable, TypeVisitable)]
 // Don't derive order on 64-bit big-endian, so we can be consistent regardless of field order.
 #[cfg_attr(not(all(target_pointer_width = "64", target_endian = "big")), derive(PartialOrd, Ord))]
 // On below-64 bit systems we can simply use the derived `Hash` impl

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/mod.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