Generify traversals of interned types

Author: eggyal

compiler/rustc_data_structures/src/intern.rs

@@ -24,6 +24,10 @@ mod private {
 #[rustc_pass_by_value]
 pub struct Interned<'a, T>(pub &'a T, pub private::PrivateZst);
 
+pub trait Internable<'a, I>: Sized {
+    fn intern(self, interner: I) -> Interned<'a, Self>;
+}
+
 impl<'a, T> Interned<'a, T> {
     /// Create a new `Interned` value. The value referred to *must* be interned
     /// and thus be unique, and it *must* remain unique in the future. This

compiler/rustc_middle/src/traits/solve.rs

@@ -4,9 +4,7 @@ use rustc_query_system::cache::Cache;
 use crate::infer::canonical::{CanonicalVarValues, QueryRegionConstraints};
 use crate::traits::query::NoSolution;
 use crate::traits::Canonical;
-use crate::ty::{
-    self, FallibleTypeFolder, ToPredicate, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypeVisitor,
-};
+use crate::ty::{self, ToPredicate, Ty, TyCtxt};
 
 pub type EvaluationCache<'tcx> = Cache<CanonicalGoal<'tcx>, QueryResult<'tcx>>;
 
@@ -96,7 +94,7 @@ pub type CanonicalResponse<'tcx> = Canonical<'tcx, Response<'tcx>>;
 /// solver, merge the two responses again.
 pub type QueryResult<'tcx> = Result<CanonicalResponse<'tcx>, NoSolution>;
 
-#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, TypeFoldable, TypeVisitable)]
 pub struct ExternalConstraints<'tcx>(pub(crate) Interned<'tcx, ExternalConstraintsData<'tcx>>);
 
 impl<'tcx> std::ops::Deref for ExternalConstraints<'tcx> {
@@ -114,26 +112,3 @@ pub struct ExternalConstraintsData<'tcx> {
     pub region_constraints: QueryRegionConstraints<'tcx>,
     pub opaque_types: Vec<(Ty<'tcx>, Ty<'tcx>)>,
 }
-
-// FIXME: Having to clone `region_constraints` for folding feels bad and
-// probably isn't great wrt performance.
-//
-// Not sure how to fix this, maybe we should also intern `opaque_types` and
-// `region_constraints` here or something.
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
-    fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
-        self,
-        folder: &mut F,
-    ) -> Result<Self, F::Error> {
-        Ok(folder.interner().mk_external_constraints((*self).clone().try_fold_with(folder)?))
-    }
-}
-
-impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
-    fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(
-        &self,
-        visitor: &mut V,
-    ) -> std::ops::ControlFlow<V::BreakTy> {
-        (**self).visit_with(visitor)
-    }
-}

compiler/rustc_middle/src/ty/context.rs

@@ -30,7 +30,7 @@ use crate::ty::{GenericArg, InternalSubsts, SubstsRef};
 use rustc_ast as ast;
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_data_structures::intern::Interned;
+use rustc_data_structures::intern::{Internable, Interned};
 use rustc_data_structures::memmap::Mmap;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::sharded::{IntoPointer, ShardedHashMap};
@@ -1555,11 +1555,17 @@ macro_rules! direct_interners {
             }
         }
 
+        impl<'tcx> Internable<'tcx, TyCtxt<'tcx>> for $ty {
+            fn intern(self, tcx: TyCtxt<'tcx>) -> Interned<'tcx, Self> {
+                Interned::new_unchecked(tcx.interners.$name.intern(self, |v| {
+                    InternedInSet(tcx.interners.arena.alloc(v))
+                }).0)
+            }
+        }
+
         impl<'tcx> TyCtxt<'tcx> {
             $vis fn $method(self, v: $ty) -> $ret_ty {
-                $ret_ctor(Interned::new_unchecked(self.interners.$name.intern(v, |v| {
-                    InternedInSet(self.interners.arena.alloc(v))
-                }).0))
+                $ret_ctor(v.intern(self))
             }
         })+
     }

compiler/rustc_type_ir/src/structural_impls.rs

@@ -5,7 +5,10 @@
 use crate::fold::{FallibleTypeFolder, TypeFoldable};
 use crate::visit::{TypeVisitable, TypeVisitor};
 use crate::Interner;
-use rustc_data_structures::functor::IdFunctor;
+use rustc_data_structures::{
+    functor::IdFunctor,
+    intern::{Internable, Interned},
+};
 use rustc_index::vec::{Idx, IndexVec};
 
 use std::ops::ControlFlow;
@@ -189,3 +192,15 @@ impl<I: Interner, T: TypeVisitable<I>, Ix: Idx> TypeVisitable<I> for IndexVec<Ix
         self.iter().try_for_each(|t| t.visit_with(visitor))
     }
 }
+
+impl<'a, I: Interner, T: Internable<'a, I> + TypeFoldable<I>> TypeFoldable<I> for Interned<'a, T> {
+    fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
+        (*self).clone().try_fold_with(folder).map(|v| v.intern(folder.interner()))
+    }
+}
+
+impl<I: Interner, T: TypeVisitable<I>> TypeVisitable<I> for Interned<'_, T> {
+    fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
+        (**self).visit_with(visitor)
+    }
+}