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

@@ -3,9 +3,7 @@ use rustc_data_structures::intern::Interned;
 use crate::infer::canonical::{CanonicalVarValues, QueryRegionConstraints};
 use crate::traits::query::NoSolution;
 use crate::traits::{Canonical, DefiningAnchor};
-use crate::ty::{
-    self, FallibleTypeFolder, ToPredicate, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypeVisitor,
-};
+use crate::ty::{self, ToPredicate, Ty, TyCtxt};
 use rustc_span::def_id::DefId;
 
 use super::BuiltinImplSource;
@@ -112,7 +110,7 @@ pub struct PredefinedOpaquesData<'tcx> {
     pub opaque_types: Vec<(ty::OpaqueTypeKey<'tcx>, Ty<'tcx>)>,
 }
 
-#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, HashStable)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, HashStable, TypeVisitable, TypeFoldable)]
 pub struct PredefinedOpaques<'tcx>(pub(crate) Interned<'tcx, PredefinedOpaquesData<'tcx>>);
 
 impl<'tcx> std::ops::Deref for PredefinedOpaques<'tcx> {
@@ -135,7 +133,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, HashStable)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, HashStable, TypeFoldable, TypeVisitable)]
 pub struct ExternalConstraints<'tcx>(pub(crate) Interned<'tcx, ExternalConstraintsData<'tcx>>);
 
 impl<'tcx> std::ops::Deref for ExternalConstraints<'tcx> {
@@ -154,52 +152,6 @@ pub struct ExternalConstraintsData<'tcx> {
     pub opaque_types: Vec<(ty::OpaqueTypeKey<'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)
-    }
-}
-
-// 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 PredefinedOpaques<'tcx> {
-    fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
-        self,
-        folder: &mut F,
-    ) -> Result<Self, F::Error> {
-        Ok(folder.interner().mk_predefined_opaques_in_body((*self).clone().try_fold_with(folder)?))
-    }
-}
-
-impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for PredefinedOpaques<'tcx> {
-    fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(
-        &self,
-        visitor: &mut V,
-    ) -> std::ops::ControlFlow<V::BreakTy> {
-        (**self).visit_with(visitor)
-    }
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, HashStable)]
 pub enum IsNormalizesToHack {
     Yes,

compiler/rustc_middle/src/ty/context.rs

@@ -34,7 +34,7 @@ use crate::ty::{GenericArg, GenericArgs, GenericArgsRef};
 use rustc_ast::{self as ast, attr};
 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::profiling::SelfProfilerRef;
 use rustc_data_structures::sharded::{IntoPointer, ShardedHashMap};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -1549,11 +1549,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/fold.rs

@@ -45,7 +45,10 @@
 //! - u.fold_with(folder)
 //! ```
 
-use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::{
+    intern::{Internable, Interned},
+    sync::Lrc,
+};
 use rustc_index::{Idx, IndexVec};
 use std::marker::PhantomData;
 use std::mem;
@@ -403,3 +406,9 @@ impl<I: Interner, T: TypeFoldable<I>, Ix: Idx> TypeFoldable<I> for IndexVec<Ix,
         self.raw.try_fold_with(folder).map(IndexVec::from_raw)
     }
 }
+
+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()))
+    }
+}

compiler/rustc_type_ir/src/visit.rs

@@ -41,7 +41,7 @@
 //! - u.visit_with(visitor)
 //! ```
 
-use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::{intern::Interned, sync::Lrc};
 use rustc_index::{Idx, IndexVec};
 use std::fmt;
 use std::marker::PhantomData;
@@ -250,3 +250,9 @@ impl<I: Interner, T: TypeVisitable<I>, Ix: Idx> TypeVisitable<I> for IndexVec<Ix
         self.iter().try_for_each(|t| t.visit_with(visitor))
     }
 }
+
+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)
+    }
+}