refactor: Intern TraitEnvironment into salsa

Author: Veykril

crates/hir-ty/src/autoderef.rs

@@ -9,7 +9,6 @@ use chalk_ir::cast::Cast;
 use hir_def::lang_item::LangItem;
 use hir_expand::name::Name;
 use intern::sym;
-use triomphe::Arc;
 
 use crate::{
     Canonical, Goal, Interner, ProjectionTyExt, TraitEnvironment, Ty, TyBuilder, TyKind,
@@ -33,7 +32,7 @@ pub(crate) enum AutoderefKind {
 ///   detects a cycle in the deref chain.
 pub fn autoderef(
     db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: TraitEnvironment<'_>,
     ty: Canonical<Ty>,
 ) -> impl Iterator<Item = Ty> {
     let mut table = InferenceTable::new(db, env);
@@ -198,15 +197,16 @@ pub(crate) fn deref_by_trait(
         // blanked impl on `Deref`.
         #[expect(clippy::overly_complex_bool_expr)]
         if use_receiver_trait && false {
-            if let Some(receiver) =
-                db.lang_item(table.trait_env.krate, LangItem::Receiver).and_then(|l| l.as_trait())
+            if let Some(receiver) = db
+                .lang_item(table.trait_env.krate(db), LangItem::Receiver)
+                .and_then(|l| l.as_trait())
             {
                 return Some(receiver);
             }
         }
         // Old rustc versions might not have `Receiver` trait.
         // Fallback to `Deref` if they don't
-        db.lang_item(table.trait_env.krate, LangItem::Deref).and_then(|l| l.as_trait())
+        db.lang_item(table.trait_env.krate(db), LangItem::Deref).and_then(|l| l.as_trait())
     };
     let trait_id = trait_id()?;
     let target = db

crates/hir-ty/src/chalk_ext.rs

@@ -376,7 +376,7 @@ impl TyExt for Ty {
         let trait_ref = TyBuilder::trait_ref(db, copy_trait).push(self).build();
         let env = db.trait_environment_for_body(owner);
         let goal = Canonical {
-            value: InEnvironment::new(&env.env, trait_ref.cast(Interner)),
+            value: InEnvironment::new(env.env(db), trait_ref.cast(Interner)),
             binders: CanonicalVarKinds::empty(Interner),
         };
         db.trait_solve(crate_id, None, goal).is_some()

crates/hir-ty/src/consteval.rs

@@ -165,7 +165,7 @@ pub fn intern_const_ref(
     ty: Ty,
     krate: Crate,
 ) -> Const {
-    let layout = db.layout_of_ty(ty.clone(), TraitEnvironment::empty(krate));
+    let layout = db.layout_of_ty(ty.clone(), TraitEnvironment::empty(db, krate));
     let bytes = match value {
         LiteralConstRef::Int(i) => {
             // FIXME: We should handle failure of layout better.
@@ -233,7 +233,7 @@ pub(crate) fn const_eval_recover(
     _: HirDatabaseData,
     _: GeneralConstId,
     _: Substitution,
-    _: Option<Arc<TraitEnvironment>>,
+    _: Option<TraitEnvironment<'_>>,
 ) -> Result<Const, ConstEvalError> {
     Err(ConstEvalError::MirLowerError(MirLowerError::Loop))
 }
@@ -258,15 +258,15 @@ pub(crate) fn const_eval_query(
     db: &dyn HirDatabase,
     def: GeneralConstId,
     subst: Substitution,
-    trait_env: Option<Arc<TraitEnvironment>>,
+    trait_env: Option<TraitEnvironment<'_>>,
 ) -> Result<Const, ConstEvalError> {
     let body = match def {
         GeneralConstId::ConstId(c) => {
             db.monomorphized_mir_body(c.into(), subst, db.trait_environment(c.into()))?
         }
         GeneralConstId::StaticId(s) => {
             let krate = s.module(db.upcast()).krate();
-            db.monomorphized_mir_body(s.into(), subst, TraitEnvironment::empty(krate))?
+            db.monomorphized_mir_body(s.into(), subst, TraitEnvironment::empty(db, krate))?
         }
         GeneralConstId::ConstBlockId(c) => {
             let ConstBlockLoc { parent, root } = db.lookup_intern_anonymous_const(c);

crates/hir-ty/src/db.rs

@@ -44,19 +44,19 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> + std::fmt::Debug {
 
     #[salsa::invoke(crate::mir::monomorphized_mir_body_query)]
     #[salsa::cycle(crate::mir::monomorphized_mir_body_recover)]
-    fn monomorphized_mir_body(
-        &self,
+    fn monomorphized_mir_body<'db>(
+        &'db self,
         def: DefWithBodyId,
         subst: Substitution,
-        env: Arc<TraitEnvironment>,
+        env: TraitEnvironment<'db>,
     ) -> Result<Arc<MirBody>, MirLowerError>;
 
     #[salsa::invoke(crate::mir::monomorphized_mir_body_for_closure_query)]
-    fn monomorphized_mir_body_for_closure(
-        &self,
+    fn monomorphized_mir_body_for_closure<'db>(
+        &'db self,
         def: ClosureId,
         subst: Substitution,
-        env: Arc<TraitEnvironment>,
+        env: TraitEnvironment<'db>,
     ) -> Result<Arc<MirBody>, MirLowerError>;
 
     #[salsa::invoke(crate::mir::borrowck_query)]
@@ -65,11 +65,11 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> + std::fmt::Debug {
 
     #[salsa::invoke(crate::consteval::const_eval_query)]
     #[salsa::cycle(crate::consteval::const_eval_recover)]
-    fn const_eval(
-        &self,
+    fn const_eval<'db>(
+        &'db self,
         def: GeneralConstId,
         subst: Substitution,
-        trait_env: Option<Arc<TraitEnvironment>>,
+        trait_env: Option<TraitEnvironment<'db>>,
     ) -> Result<Const, ConstEvalError>;
 
     #[salsa::invoke_actual(crate::consteval::const_eval_static_query)]
@@ -81,9 +81,9 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> + std::fmt::Debug {
     fn const_eval_discriminant(&self, def: EnumVariantId) -> Result<i128, ConstEvalError>;
 
     #[salsa::invoke(crate::method_resolution::lookup_impl_method_query)]
-    fn lookup_impl_method(
-        &self,
-        env: Arc<TraitEnvironment>,
+    fn lookup_impl_method<'db>(
+        &'db self,
+        env: TraitEnvironment<'db>,
         func: FunctionId,
         fn_subst: Substitution,
     ) -> (FunctionId, Substitution);
@@ -92,16 +92,20 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> + std::fmt::Debug {
 
     #[salsa::invoke(crate::layout::layout_of_adt_query)]
     #[salsa::cycle(crate::layout::layout_of_adt_recover)]
-    fn layout_of_adt(
-        &self,
+    fn layout_of_adt<'db>(
+        &'db self,
         def: AdtId,
         subst: Substitution,
-        env: Arc<TraitEnvironment>,
+        env: TraitEnvironment<'db>,
     ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::layout_of_ty_query)]
     #[salsa::cycle(crate::layout::layout_of_ty_recover)]
-    fn layout_of_ty(&self, ty: Ty, env: Arc<TraitEnvironment>) -> Result<Arc<Layout>, LayoutError>;
+    fn layout_of_ty<'db>(
+        &'db self,
+        ty: Ty,
+        env: TraitEnvironment<'db>,
+    ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke_actual(crate::layout::target_data_layout_query)]
     fn target_data_layout(&self, krate: Crate) -> Result<Arc<TargetDataLayout>, Arc<str>>;
@@ -181,10 +185,10 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> + std::fmt::Debug {
 
     #[salsa::invoke_actual(crate::lower::trait_environment_for_body_query)]
     #[salsa::transparent]
-    fn trait_environment_for_body(&self, def: DefWithBodyId) -> Arc<TraitEnvironment>;
+    fn trait_environment_for_body<'db>(&'db self, def: DefWithBodyId) -> TraitEnvironment<'db>;
 
     #[salsa::invoke_actual(crate::lower::trait_environment_query)]
-    fn trait_environment(&self, def: GenericDefId) -> Arc<TraitEnvironment>;
+    fn trait_environment<'db>(&'db self, def: GenericDefId) -> TraitEnvironment<'db>;
 
     #[salsa::invoke_actual(crate::lower::generic_defaults_with_diagnostics_query)]
     #[salsa::cycle(crate::lower::generic_defaults_with_diagnostics_recover)]
@@ -286,10 +290,10 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> + std::fmt::Debug {
 
     #[salsa::invoke(crate::traits::normalize_projection_query)]
     #[salsa::transparent]
-    fn normalize_projection(
-        &self,
+    fn normalize_projection<'db>(
+        &'db self,
         projection: crate::ProjectionTy,
-        env: Arc<TraitEnvironment>,
+        env: TraitEnvironment<'db>,
     ) -> Ty;
 
     #[salsa::invoke(crate::traits::trait_solve_query)]
@@ -310,7 +314,7 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> + std::fmt::Debug {
 
     #[salsa::invoke(crate::drop::has_drop_glue)]
     #[salsa::cycle(crate::drop::has_drop_glue_recover)]
-    fn has_drop_glue(&self, ty: Ty, env: Arc<TraitEnvironment>) -> DropGlue;
+    fn has_drop_glue<'db>(&'db self, ty: Ty, env: TraitEnvironment<'db>) -> DropGlue;
 }
 
 #[test]

crates/hir-ty/src/display.rs

@@ -38,7 +38,6 @@ use rustc_hash::FxHashSet;
 use smallvec::SmallVec;
 use span::Edition;
 use stdx::never;
-use triomphe::Arc;
 
 use crate::{
     AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, ConcreteConst, Const,
@@ -682,8 +681,8 @@ fn render_const_scalar(
     memory_map: &MemoryMap,
     ty: &Ty,
 ) -> Result<(), HirDisplayError> {
-    let trait_env = TraitEnvironment::empty(f.krate());
-    let ty = normalize(f.db, trait_env.clone(), ty.clone());
+    let trait_env = TraitEnvironment::empty(f.db, f.krate());
+    let ty = normalize(f.db, trait_env, ty.clone());
     match ty.kind(Interner) {
         TyKind::Scalar(s) => match s {
             Scalar::Bool => write!(f, "{}", b[0] != 0),
@@ -816,7 +815,7 @@ fn render_const_scalar(
             }
         },
         TyKind::Tuple(_, subst) => {
-            let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
+            let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env) else {
                 return f.write_str("<layout-error>");
             };
             f.write_str("(")?;
@@ -829,7 +828,7 @@ fn render_const_scalar(
                 }
                 let ty = ty.assert_ty_ref(Interner); // Tuple only has type argument
                 let offset = layout.fields.offset(id).bytes_usize();
-                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
+                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env) else {
                     f.write_str("<layout-error>")?;
                     continue;
                 };
@@ -839,7 +838,7 @@ fn render_const_scalar(
             f.write_str(")")
         }
         TyKind::Adt(adt, subst) => {
-            let Ok(layout) = f.db.layout_of_adt(adt.0, subst.clone(), trait_env.clone()) else {
+            let Ok(layout) = f.db.layout_of_adt(adt.0, subst.clone(), trait_env) else {
                 return f.write_str("<layout-error>");
             };
             match adt.0 {
@@ -862,7 +861,8 @@ fn render_const_scalar(
                     write!(f, "{}", f.db.union_data(u).name.display(f.db.upcast(), f.edition()))
                 }
                 hir_def::AdtId::EnumId(e) => {
-                    let Ok(target_data_layout) = f.db.target_data_layout(trait_env.krate) else {
+                    let Ok(target_data_layout) = f.db.target_data_layout(trait_env.krate(f.db))
+                    else {
                         return f.write_str("<target-layout-not-available>");
                     };
                     let Some((var_id, var_layout)) =
@@ -935,7 +935,7 @@ fn render_variant_after_name(
     data: &VariantData,
     f: &mut HirFormatter<'_>,
     field_types: &ArenaMap<LocalFieldId, Binders<Ty>>,
-    trait_env: Arc<TraitEnvironment>,
+    trait_env: TraitEnvironment<'_>,
     layout: &Layout,
     subst: &Substitution,
     b: &[u8],
@@ -946,7 +946,7 @@ fn render_variant_after_name(
             let render_field = |f: &mut HirFormatter<'_>, id: LocalFieldId| {
                 let offset = layout.fields.offset(u32::from(id.into_raw()) as usize).bytes_usize();
                 let ty = field_types[id].clone().substitute(Interner, subst);
-                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
+                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();

crates/hir-ty/src/drop.rs

@@ -5,7 +5,6 @@ use hir_def::AdtId;
 use hir_def::data::adt::StructFlags;
 use hir_def::lang_item::LangItem;
 use stdx::never;
-use triomphe::Arc;
 
 use crate::db::HirDatabaseData;
 use crate::{
@@ -47,7 +46,7 @@ pub enum DropGlue {
     HasDropGlue,
 }
 
-pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment>) -> DropGlue {
+pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: TraitEnvironment<'_>) -> DropGlue {
     match ty.kind(Interner) {
         TyKind::Adt(adt, subst) => {
             if has_destructor(db, adt.0) {
@@ -61,10 +60,7 @@ pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironm
                     db.field_types(id.into())
                         .iter()
                         .map(|(_, field_ty)| {
-                            db.has_drop_glue(
-                                field_ty.clone().substitute(Interner, subst),
-                                env.clone(),
-                            )
+                            db.has_drop_glue(field_ty.clone().substitute(Interner, subst), env)
                         })
                         .max()
                         .unwrap_or(DropGlue::None)
@@ -79,10 +75,7 @@ pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironm
                         db.field_types(variant.into())
                             .iter()
                             .map(|(_, field_ty)| {
-                                db.has_drop_glue(
-                                    field_ty.clone().substitute(Interner, subst),
-                                    env.clone(),
-                                )
+                                db.has_drop_glue(field_ty.clone().substitute(Interner, subst), env)
                             })
                             .max()
                             .unwrap_or(DropGlue::None)
@@ -94,7 +87,7 @@ pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironm
         TyKind::Tuple(_, subst) => subst
             .iter(Interner)
             .map(|ty| ty.assert_ty_ref(Interner))
-            .map(|ty| db.has_drop_glue(ty.clone(), env.clone()))
+            .map(|ty| db.has_drop_glue(ty.clone(), env))
             .max()
             .unwrap_or(DropGlue::None),
         TyKind::Array(ty, len) => {
@@ -124,7 +117,7 @@ pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironm
             let env = db.trait_environment_for_body(owner);
             captures
                 .iter()
-                .map(|capture| db.has_drop_glue(capture.ty(subst), env.clone()))
+                .map(|capture| db.has_drop_glue(capture.ty(subst), env))
                 .max()
                 .unwrap_or(DropGlue::None)
         }
@@ -169,11 +162,11 @@ pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironm
 
 fn projection_has_drop_glue(
     db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: TraitEnvironment<'_>,
     projection: ProjectionTy,
     ty: Ty,
 ) -> DropGlue {
-    let normalized = db.normalize_projection(projection, env.clone());
+    let normalized = db.normalize_projection(projection, env);
     match normalized.kind(Interner) {
         TyKind::Alias(AliasTy::Projection(_)) | TyKind::AssociatedType(..) => {
             if is_copy(db, ty, env) { DropGlue::None } else { DropGlue::DependOnParams }
@@ -182,25 +175,25 @@ fn projection_has_drop_glue(
     }
 }
 
-fn is_copy(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment>) -> bool {
-    let Some(copy_trait) = db.lang_item(env.krate, LangItem::Copy).and_then(|it| it.as_trait())
+fn is_copy(db: &dyn HirDatabase, ty: Ty, env: TraitEnvironment<'_>) -> bool {
+    let Some(copy_trait) = db.lang_item(env.krate(db), LangItem::Copy).and_then(|it| it.as_trait())
     else {
         return false;
     };
     let trait_ref = TyBuilder::trait_ref(db, copy_trait).push(ty).build();
     let goal = Canonical {
-        value: InEnvironment::new(&env.env, trait_ref.cast(Interner)),
+        value: InEnvironment::new(env.env(db), trait_ref.cast(Interner)),
         binders: CanonicalVarKinds::empty(Interner),
     };
-    db.trait_solve(env.krate, env.block, goal).is_some()
+    db.trait_solve(env.krate(db), env.block(db), goal).is_some()
 }
 
 pub(crate) fn has_drop_glue_recover(
     _db: &dyn HirDatabase,
     _cycle: &salsa::Cycle,
     _: HirDatabaseData,
     _ty: Ty,
-    _env: Arc<TraitEnvironment>,
+    _env: TraitEnvironment<'_>,
 ) -> DropGlue {
     DropGlue::None
 }

crates/hir-ty/src/infer.rs

@@ -149,7 +149,7 @@ pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<Infer
 ///
 /// This is appropriate to use only after type-check: it assumes
 /// that normalization will succeed, for example.
-pub(crate) fn normalize(db: &dyn HirDatabase, trait_env: Arc<TraitEnvironment>, ty: Ty) -> Ty {
+pub(crate) fn normalize(db: &dyn HirDatabase, trait_env: TraitEnvironment<'_>, ty: Ty) -> Ty {
     // FIXME: TypeFlags::HAS_CT_PROJECTION is not implemented in chalk, so TypeFlags::HAS_PROJECTION only
     // works for the type case, so we check array unconditionally. Remove the array part
     // when the bug in chalk becomes fixed.

crates/hir-ty/src/infer/cast.rs

@@ -297,9 +297,9 @@ impl CastCheck {
                             return Ok(());
                         }
                         let src_principal =
-                            table.db.trait_datum(table.trait_env.krate, src_principal);
+                            table.db.trait_datum(table.trait_env.krate(table.db), src_principal);
                         let dst_principal =
-                            table.db.trait_datum(table.trait_env.krate, dst_principal);
+                            table.db.trait_datum(table.trait_env.krate(table.db), dst_principal);
                         if src_principal.is_auto_trait() && dst_principal.is_auto_trait() {
                             Ok(())
                         } else {