GC support for solver types

A GC is triggered every X revisions, and is synchronous, unfortunately.

Author: ChayimFriedman2

Cargo.lock

@@ -29,9 +29,9 @@ pub struct Const<'db> {
     pub(super) interned: InternedRef<'db, ConstInterned>,
 }
 
-#[derive(PartialEq, Eq, Hash)]
+#[derive(PartialEq, Eq, Hash, GenericTypeVisitable)]
 #[repr(align(4))] // Required for `GenericArg` bit-tagging.
-pub(super) struct ConstInterned(WithCachedTypeInfo<ConstKind<'static>>);
+pub(super) struct ConstInterned(pub(super) WithCachedTypeInfo<ConstKind<'static>>);
 
 impl_internable!(gc; ConstInterned);
 impl_stored_interned!(ConstInterned, Const, StoredConst);
@@ -219,15 +219,14 @@ pub struct Valtree<'db> {
 
 impl<'db, V: super::WorldExposer> GenericTypeVisitable<V> for Valtree<'db> {
     fn generic_visit_with(&self, visitor: &mut V) {
-        visitor.on_interned(self.interned);
-        self.inner().generic_visit_with(visitor);
+        if visitor.on_interned(self.interned).is_continue() {
+            self.inner().generic_visit_with(visitor);
+        }
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Hash)]
-struct ValtreeInterned {
-    bytes: ConstBytes<'static>,
-}
+#[derive(Debug, PartialEq, Eq, Hash, GenericTypeVisitable)]
+pub(super) struct ValtreeInterned(ConstBytes<'static>);
 
 impl_internable!(gc; ValtreeInterned);
 
@@ -240,12 +239,12 @@ impl<'db> Valtree<'db> {
     #[inline]
     pub fn new(bytes: ConstBytes<'db>) -> Self {
         let bytes = unsafe { std::mem::transmute::<ConstBytes<'db>, ConstBytes<'static>>(bytes) };
-        Self { interned: Interned::new_gc(ValtreeInterned { bytes }) }
+        Self { interned: Interned::new_gc(ValtreeInterned(bytes)) }
     }
 
     #[inline]
     pub fn inner(&self) -> &ConstBytes<'db> {
-        let inner = &self.interned.bytes;
+        let inner = &self.interned.0;
         unsafe { std::mem::transmute::<&ConstBytes<'static>, &ConstBytes<'db>>(inner) }
     }
 }
@@ -277,8 +276,9 @@ impl<'db> IntoKind for Const<'db> {
 
 impl<'db, V: super::WorldExposer> GenericTypeVisitable<V> for Const<'db> {
     fn generic_visit_with(&self, visitor: &mut V) {
-        visitor.on_interned(self.interned);
-        self.kind().generic_visit_with(visitor);
+        if visitor.on_interned(self.interned).is_continue() {
+            self.kind().generic_visit_with(visitor);
+        }
     }
 }
 

crates/hir-ty/src/next_solver/consts.rs

@@ -1,8 +1,9 @@
 //! Things related to the Interner in the next-trait-solver.
 
-use std::fmt;
+use std::{fmt, ops::ControlFlow};
 
 use intern::{Interned, InternedRef, InternedSliceRef, impl_internable};
+use macros::GenericTypeVisitable;
 use rustc_ast_ir::{FloatTy, IntTy, UintTy};
 pub use tls_cache::clear_tls_solver_cache;
 pub use tls_db::{attach_db, attach_db_allow_change, with_attached_db};
@@ -21,8 +22,8 @@ use rustc_hash::FxHashSet;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_type_ir::{
     AliasTermKind, AliasTyKind, BoundVar, CollectAndApply, CoroutineWitnessTypes, DebruijnIndex,
-    EarlyBinder, FlagComputation, Flags, GenericArgKind, ImplPolarity, InferTy, Interner, TraitRef,
-    TypeFlags, TypeVisitableExt, UniverseIndex, Upcast, Variance,
+    EarlyBinder, FlagComputation, Flags, GenericArgKind, GenericTypeVisitable, ImplPolarity,
+    InferTy, Interner, TraitRef, TypeFlags, TypeVisitableExt, UniverseIndex, Upcast, Variance,
     elaborate::elaborate,
     error::TypeError,
     fast_reject,
@@ -169,8 +170,9 @@ macro_rules! interned_slice {
         {
             #[inline]
             fn generic_visit_with(&self, visitor: &mut V) {
-                visitor.on_interned_slice(self.interned);
-                self.as_slice().iter().for_each(|it| it.generic_visit_with(visitor));
+                if visitor.on_interned_slice(self.interned).is_continue() {
+                    self.as_slice().iter().for_each(|it| it.generic_visit_with(visitor));
+                }
             }
         }
     };
@@ -293,8 +295,14 @@ macro_rules! impl_stored_interned {
 pub(crate) use impl_stored_interned;
 
 pub trait WorldExposer {
-    fn on_interned<T: intern::Internable>(&mut self, interned: InternedRef<'_, T>);
-    fn on_interned_slice<T: intern::SliceInternable>(&mut self, interned: InternedSliceRef<'_, T>);
+    fn on_interned<T: intern::Internable>(
+        &mut self,
+        interned: InternedRef<'_, T>,
+    ) -> ControlFlow<()>;
+    fn on_interned_slice<T: intern::SliceInternable>(
+        &mut self,
+        interned: InternedSliceRef<'_, T>,
+    ) -> ControlFlow<()>;
 }
 
 #[derive(Debug, Copy, Clone)]
@@ -803,7 +811,7 @@ pub struct Pattern<'db> {
     interned: InternedRef<'db, PatternInterned>,
 }
 
-#[derive(PartialEq, Eq, Hash)]
+#[derive(PartialEq, Eq, Hash, GenericTypeVisitable)]
 struct PatternInterned(PatternKind<'static>);
 
 impl_internable!(gc; PatternInterned);
@@ -884,8 +892,9 @@ impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for Pattern<'db> {
 
 impl<'db, V: WorldExposer> rustc_type_ir::GenericTypeVisitable<V> for Pattern<'db> {
     fn generic_visit_with(&self, visitor: &mut V) {
-        visitor.on_interned(self.interned);
-        self.kind().generic_visit_with(visitor);
+        if visitor.on_interned(self.interned).is_continue() {
+            self.kind().generic_visit_with(visitor);
+        }
     }
 }
 
@@ -2559,3 +2568,106 @@ mod tls_cache {
         GLOBAL_CACHE.with_borrow_mut(|handle| *handle = None);
     }
 }
+
+impl WorldExposer for intern::GarbageCollector {
+    fn on_interned<T: intern::Internable>(
+        &mut self,
+        interned: InternedRef<'_, T>,
+    ) -> ControlFlow<()> {
+        self.mark_interned_alive(interned)
+    }
+
+    fn on_interned_slice<T: intern::SliceInternable>(
+        &mut self,
+        interned: InternedSliceRef<'_, T>,
+    ) -> ControlFlow<()> {
+        self.mark_interned_slice_alive(interned)
+    }
+}
+
+/// # Safety
+///
+/// This cannot be called if there are some not-yet-recorded type values. Generally, if you have a mutable
+/// reference to the database, and there are no other database - then you can call this safely, but you
+/// also need to make sure to maintain the mutable reference while this is running.
+pub unsafe fn collect_ty_garbage() {
+    let mut gc = intern::GarbageCollector::default();
+
+    gc.add_storage::<super::consts::ConstInterned>();
+    gc.add_storage::<super::consts::ValtreeInterned>();
+    gc.add_storage::<PatternInterned>();
+    gc.add_storage::<super::opaques::ExternalConstraintsInterned>();
+    gc.add_storage::<super::predicate::PredicateInterned>();
+    gc.add_storage::<super::region::RegionInterned>();
+    gc.add_storage::<super::ty::TyInterned>();
+
+    gc.add_slice_storage::<super::predicate::ClausesStorage>();
+    gc.add_slice_storage::<super::generic_arg::GenericArgsStorage>();
+    gc.add_slice_storage::<BoundVarKindsStorage>();
+    gc.add_slice_storage::<VariancesOfStorage>();
+    gc.add_slice_storage::<CanonicalVarsStorage>();
+    gc.add_slice_storage::<PatListStorage>();
+    gc.add_slice_storage::<super::opaques::PredefinedOpaquesStorage>();
+    gc.add_slice_storage::<super::opaques::SolverDefIdsStorage>();
+    gc.add_slice_storage::<super::predicate::BoundExistentialPredicatesStorage>();
+    gc.add_slice_storage::<super::region::RegionAssumptionsStorage>();
+    gc.add_slice_storage::<super::ty::TysStorage>();
+
+    unsafe { gc.collect() };
+}
+
+macro_rules! impl_gc_visit {
+    ( $($ty:ty),* $(,)? ) => {
+        $(
+            impl ::intern::GcInternedVisit for $ty {
+                #[inline]
+                fn visit_with(&self, gc: &mut ::intern::GarbageCollector) {
+                    self.generic_visit_with(gc);
+                }
+            }
+        )*
+    };
+}
+
+impl_gc_visit!(
+    super::consts::ConstInterned,
+    super::consts::ValtreeInterned,
+    PatternInterned,
+    super::opaques::ExternalConstraintsInterned,
+    super::predicate::PredicateInterned,
+    super::region::RegionInterned,
+    super::ty::TyInterned,
+    super::predicate::ClausesCachedTypeInfo,
+);
+
+macro_rules! impl_gc_visit_slice {
+    ( $($ty:ty),* $(,)? ) => {
+        $(
+            impl ::intern::GcInternedSliceVisit for $ty {
+                #[inline]
+                fn visit_header(header: &<Self as ::intern::SliceInternable>::Header, gc: &mut ::intern::GarbageCollector) {
+                    header.generic_visit_with(gc);
+                }
+
+                #[inline]
+                fn visit_slice(header: &[<Self as ::intern::SliceInternable>::SliceType], gc: &mut ::intern::GarbageCollector) {
+                    header.generic_visit_with(gc);
+                }
+            }
+        )*
+    };
+}
+
+impl_gc_visit_slice!(
+    super::predicate::ClausesStorage,
+    super::generic_arg::GenericArgsStorage,
+    BoundVarKindsStorage,
+    VariancesOfStorage,
+    CanonicalVarsStorage,
+    PatListStorage,
+    super::opaques::PredefinedOpaquesStorage,
+    super::opaques::SolverDefIdsStorage,
+    super::predicate::BoundExistentialPredicatesStorage,
+    super::region::RegionAssumptionsStorage,
+    super::ty::TysStorage,
+);

crates/hir-ty/src/next_solver/interner.rs

@@ -1,6 +1,7 @@
 //! Things related to opaques in the next-trait-solver.
 
 use intern::{Interned, InternedRef, impl_internable};
+use macros::GenericTypeVisitable;
 use rustc_ast_ir::try_visit;
 use rustc_type_ir::inherent::SliceLike;
 
@@ -30,8 +31,8 @@ pub struct ExternalConstraints<'db> {
     interned: InternedRef<'db, ExternalConstraintsInterned>,
 }
 
-#[derive(PartialEq, Eq, Hash)]
-struct ExternalConstraintsInterned(ExternalConstraintsData<'static>);
+#[derive(PartialEq, Eq, Hash, GenericTypeVisitable)]
+pub(super) struct ExternalConstraintsInterned(ExternalConstraintsData<'static>);
 
 impl_internable!(gc; ExternalConstraintsInterned);
 

crates/hir-ty/src/next_solver/opaques.rs

@@ -186,8 +186,8 @@ pub struct Predicate<'db> {
     interned: InternedRef<'db, PredicateInterned>,
 }
 
-#[derive(PartialEq, Eq, Hash)]
-struct PredicateInterned(WithCachedTypeInfo<Binder<'static, PredicateKind<'static>>>);
+#[derive(PartialEq, Eq, Hash, GenericTypeVisitable)]
+pub(super) struct PredicateInterned(WithCachedTypeInfo<Binder<'static, PredicateKind<'static>>>);
 
 impl_internable!(gc; PredicateInterned);
 
@@ -252,7 +252,10 @@ impl<'db> std::fmt::Debug for Predicate<'db> {
     }
 }
 
-impl_slice_internable!(gc; ClausesStorage, WithCachedTypeInfo<()>, Clause<'static>);
+#[derive(Clone, Copy, PartialEq, Eq, Hash, GenericTypeVisitable)]
+pub struct ClausesCachedTypeInfo(WithCachedTypeInfo<()>);
+
+impl_slice_internable!(gc; ClausesStorage, ClausesCachedTypeInfo, Clause<'static>);
 impl_stored_interned_slice!(ClausesStorage, Clauses, StoredClauses);
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
@@ -277,11 +280,11 @@ impl<'db> Clauses<'db> {
     pub fn new_from_slice(slice: &[Clause<'db>]) -> Self {
         let slice = unsafe { ::std::mem::transmute::<&[Clause<'db>], &[Clause<'static>]>(slice) };
         let flags = FlagComputation::<DbInterner<'db>>::for_clauses(slice);
-        let flags = WithCachedTypeInfo {
+        let flags = ClausesCachedTypeInfo(WithCachedTypeInfo {
             internee: (),
             flags: flags.flags,
             outer_exclusive_binder: flags.outer_exclusive_binder,
-        };
+        });
         Self { interned: InternedSlice::from_header_and_slice(flags, slice) }
     }
 
@@ -400,20 +403,21 @@ impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for Clauses<'db> {
 
 impl<'db, V: super::WorldExposer> rustc_type_ir::GenericTypeVisitable<V> for Clauses<'db> {
     fn generic_visit_with(&self, visitor: &mut V) {
-        visitor.on_interned_slice(self.interned);
-        self.as_slice().iter().for_each(|it| it.generic_visit_with(visitor));
+        if visitor.on_interned_slice(self.interned).is_continue() {
+            self.as_slice().iter().for_each(|it| it.generic_visit_with(visitor));
+        }
     }
 }
 
 impl<'db> rustc_type_ir::Flags for Clauses<'db> {
     #[inline]
     fn flags(&self) -> rustc_type_ir::TypeFlags {
-        self.interned.header.header.flags
+        self.interned.header.header.0.flags
     }
 
     #[inline]
     fn outer_exclusive_binder(&self) -> rustc_type_ir::DebruijnIndex {
-        self.interned.header.header.outer_exclusive_binder
+        self.interned.header.header.0.outer_exclusive_binder
     }
 }
 
@@ -430,7 +434,9 @@ impl<'db> rustc_type_ir::TypeSuperVisitable<DbInterner<'db>> for Clauses<'db> {
 pub struct Clause<'db>(pub(crate) Predicate<'db>);
 
 // We could cram the reveal into the clauses like rustc does, probably
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, TypeVisitable, TypeFoldable)]
+#[derive(
+    Copy, Clone, Debug, Hash, PartialEq, Eq, TypeVisitable, TypeFoldable, GenericTypeVisitable,
+)]
 pub struct ParamEnv<'db> {
     pub(crate) clauses: Clauses<'db>,
 }
@@ -474,8 +480,9 @@ impl<'db> TypeVisitable<DbInterner<'db>> for Predicate<'db> {
 
 impl<'db, V: super::WorldExposer> GenericTypeVisitable<V> for Predicate<'db> {
     fn generic_visit_with(&self, visitor: &mut V) {
-        visitor.on_interned(self.interned);
-        self.kind().generic_visit_with(visitor);
+        if visitor.on_interned(self.interned).is_continue() {
+            self.kind().generic_visit_with(visitor);
+        }
     }
 }
 

crates/hir-ty/src/next_solver/predicate.rs

@@ -2,6 +2,7 @@
 
 use hir_def::LifetimeParamId;
 use intern::{Interned, InternedRef, Symbol, impl_internable};
+use macros::GenericTypeVisitable;
 use rustc_type_ir::{
     BoundVar, BoundVarIndexKind, DebruijnIndex, Flags, GenericTypeVisitable, INNERMOST, RegionVid,
     TypeFlags, TypeFoldable, TypeVisitable,
@@ -25,7 +26,7 @@ pub struct Region<'db> {
     pub(super) interned: InternedRef<'db, RegionInterned>,
 }
 
-#[derive(PartialEq, Eq, Hash)]
+#[derive(PartialEq, Eq, Hash, GenericTypeVisitable)]
 #[repr(align(4))] // Required for `GenericArg` bit-tagging.
 pub(super) struct RegionInterned(RegionKind<'static>);
 
@@ -388,8 +389,9 @@ impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderRegion {
 
 impl<'db, V: super::WorldExposer> GenericTypeVisitable<V> for Region<'db> {
     fn generic_visit_with(&self, visitor: &mut V) {
-        visitor.on_interned(self.interned);
-        self.kind().generic_visit_with(visitor);
+        if visitor.on_interned(self.interned).is_continue() {
+            self.kind().generic_visit_with(visitor);
+        }
     }
 }