Merge pull request #22119 from Veykril/veykril/push-nkqzszrqyumu

Less conjuration magic

Author: Veykril

crates/hir-ty/src/builtin_derive.rs

@@ -193,7 +193,7 @@ pub fn predicates(db: &dyn HirDatabase, impl_: BuiltinDeriveImplId) -> GenericPr
             else {
                 // Malformed derive.
                 return GenericPredicates::from_explicit_own_predicates(StoredEarlyBinder::bind(
-                    Clauses::default().store(),
+                    Clauses::empty(interner).store(),
                 ));
             };
             let duplicated_bounds =

crates/hir-ty/src/display.rs

@@ -780,7 +780,7 @@ fn render_const_scalar<'db>(
     memory_map: &MemoryMap<'db>,
     ty: Ty<'db>,
 ) -> Result {
-    let param_env = ParamEnv::empty();
+    let param_env = ParamEnv::empty(f.interner);
     let infcx = f.interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let ty = infcx.at(&ObligationCause::dummy(), param_env).deeply_normalize(ty).unwrap_or(ty);
     render_const_scalar_inner(f, b, memory_map, ty, param_env)
@@ -1065,7 +1065,7 @@ fn render_const_scalar_from_valtree<'db>(
     ty: Ty<'db>,
     valtree: ValTree<'db>,
 ) -> Result {
-    let param_env = ParamEnv::empty();
+    let param_env = ParamEnv::empty(f.interner);
     let infcx = f.interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let ty = infcx.at(&ObligationCause::dummy(), param_env).deeply_normalize(ty).unwrap_or(ty);
     render_const_scalar_from_valtree_inner(f, ty, valtree, param_env)

crates/hir-ty/src/infer.rs

@@ -2438,8 +2438,8 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
                 };
                 let args =
                     path_ctx.substs_from_path_segment(it.into(), true, None, false, node.into());
+                let interner = path_ctx.interner();
                 drop(ctx);
-                let interner = DbInterner::conjure();
                 let ty = self.db.ty(it.into()).instantiate(interner, args).skip_norm_wip();
                 let ty = self.insert_type_vars(ty);
 

crates/hir-ty/src/lower.rs

@@ -198,7 +198,7 @@ pub trait TyLoweringInferVarsCtx<'db> {
 
 pub struct TyLoweringContext<'db, 'a> {
     pub db: &'db dyn HirDatabase,
-    interner: DbInterner<'db>,
+    pub(crate) interner: DbInterner<'db>,
     types: &'db crate::next_solver::DefaultAny<'db>,
     lang_items: &'db LangItems,
     resolver: &'a Resolver<'db>,
@@ -2072,12 +2072,12 @@ impl<'db> GenericPredicates {
 
 /// A cycle can occur from malformed code.
 fn generic_predicates_cycle_result(
-    _db: &dyn HirDatabase,
+    db: &dyn HirDatabase,
     _: salsa::Id,
     _def: GenericDefId,
 ) -> TyLoweringResult<GenericPredicates> {
     TyLoweringResult::empty(GenericPredicates::from_explicit_own_predicates(
-        StoredEarlyBinder::bind(Clauses::default().store()),
+        StoredEarlyBinder::bind(Clauses::empty(DbInterner::new_no_crate(db)).store()),
     ))
 }
 
@@ -2086,7 +2086,7 @@ impl GenericPredicates {
     pub fn empty() -> &'static GenericPredicates {
         static EMPTY: OnceLock<GenericPredicates> = OnceLock::new();
         EMPTY.get_or_init(|| GenericPredicates {
-            predicates: StoredEarlyBinder::bind(Clauses::default().store()),
+            predicates: StoredEarlyBinder::bind(Clauses::new_from_slice(&[]).store()),
             has_trait_implied_predicate: false,
             parent_explicit_self_predicates_start: 0,
             own_predicates_start: 0,

crates/hir-ty/src/lower/path.rs

@@ -994,6 +994,10 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
             })
         })
     }
+
+    pub(crate) fn interner(&self) -> DbInterner<'db> {
+        self.ctx.interner
+    }
 }
 
 /// A const that were parsed like a type.

crates/hir-ty/src/next_solver/infer/traits.rs

@@ -161,11 +161,11 @@ impl<'db> PredicateObligation<'db> {
     /// Flips the polarity of the inner predicate.
     ///
     /// Given `T: Trait` predicate it returns `T: !Trait` and given `T: !Trait` returns `T: Trait`.
-    pub fn flip_polarity(&self, _interner: DbInterner<'db>) -> Option<PredicateObligation<'db>> {
+    pub fn flip_polarity(&self, interner: DbInterner<'db>) -> Option<PredicateObligation<'db>> {
         Some(PredicateObligation {
             cause: self.cause,
             param_env: self.param_env,
-            predicate: self.predicate.flip_polarity()?,
+            predicate: self.predicate.flip_polarity(interner)?,
             recursion_depth: self.recursion_depth,
         })
     }

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

@@ -330,6 +330,7 @@ unsafe impl Sync for DbInterner<'_> {}
 
 impl<'db> DbInterner<'db> {
     // FIXME(next-solver): remove this method
+    #[doc(hidden)]
     pub fn conjure() -> DbInterner<'db> {
         // Here we can not reinit the cache since we do that when we attach the db.
         crate::with_attached_db(|db| DbInterner {

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

@@ -229,7 +229,7 @@ impl<'db> Predicate<'db> {
     /// Flips the polarity of a Predicate.
     ///
     /// Given `T: Trait` predicate it returns `T: !Trait` and given `T: !Trait` returns `T: Trait`.
-    pub fn flip_polarity(self) -> Option<Predicate<'db>> {
+    pub fn flip_polarity(self, interner: DbInterner<'db>) -> Option<Predicate<'db>> {
         let kind = self
             .kind()
             .map_bound(|kind| match kind {
@@ -245,7 +245,7 @@ impl<'db> Predicate<'db> {
             })
             .transpose()?;
 
-        Some(Predicate::new(DbInterner::conjure(), kind))
+        Some(Predicate::new(interner, kind))
     }
 }
 
@@ -355,13 +355,6 @@ impl<'db> rustc_type_ir::inherent::SliceLike for Clauses<'db> {
     }
 }
 
-impl<'db> Default for Clauses<'db> {
-    #[inline]
-    fn default() -> Self {
-        Clauses::empty(DbInterner::conjure())
-    }
-}
-
 impl<'db> rustc_type_ir::inherent::Clauses<DbInterner<'db>> for Clauses<'db> {}
 
 impl<'db> rustc_type_ir::TypeSuperFoldable<DbInterner<'db>> for Clauses<'db> {
@@ -444,8 +437,8 @@ pub struct ParamEnv<'db> {
 }
 
 impl<'db> ParamEnv<'db> {
-    pub fn empty() -> Self {
-        ParamEnv { clauses: Clauses::empty(DbInterner::conjure()) }
+    pub fn empty(interner: DbInterner<'db>) -> Self {
+        ParamEnv { clauses: Clauses::empty(interner) }
     }
 
     pub fn clauses(self) -> Clauses<'db> {

crates/hir/src/lib.rs

@@ -1665,9 +1665,11 @@ impl Enum {
 
     /// The type of the enum variant bodies.
     pub fn variant_body_ty<'db>(self, db: &'db dyn HirDatabase) -> Type<'db> {
-        let interner = DbInterner::new_no_crate(db);
+        let krate = self.id.lookup(db).container.krate(db);
+        let interner = DbInterner::new_with(db, krate);
         Type::new_for_crate(
-            self.id.lookup(db).container.krate(db),
+            db,
+            krate,
             match EnumSignature::variant_body_type(db, self.id) {
                 layout::IntegerType::Pointer(sign) => match sign {
                     true => Ty::new_int(interner, rustc_type_ir::IntTy::Isize),
@@ -2267,8 +2269,11 @@ impl DefWithBody {
                         mir::MirSpan::Unknown => continue,
                     };
                     acc.push(
-                        MovedOutOfRef { ty: Type::new_for_crate(krate, moof.ty.as_ref()), span }
-                            .into(),
+                        MovedOutOfRef {
+                            ty: Type::new_for_crate(db, krate, moof.ty.as_ref()),
+                            span,
+                        }
+                        .into(),
                     )
                 }
                 let mol = &borrowck_result.mutability_of_locals;
@@ -3485,7 +3490,7 @@ impl BuiltinType {
     pub fn ty<'db>(self, db: &'db dyn HirDatabase) -> Type<'db> {
         let core = Crate::core(db).map(|core| core.id).unwrap_or_else(|| all_crates(db)[0]);
         let interner = DbInterner::new_no_crate(db);
-        Type::new_for_crate(core, Ty::from_builtin_type(interner, self.inner))
+        Type::new_for_crate(db, core, Ty::from_builtin_type(interner, self.inner))
     }
 
     pub fn name(self) -> Name {
@@ -5534,8 +5539,13 @@ impl<'db> Type<'db> {
         Type { env: environment, ty }
     }
 
-    pub(crate) fn new_for_crate(krate: base_db::Crate, ty: Ty<'db>) -> Self {
-        Type { env: empty_param_env(krate), ty }
+    pub(crate) fn new_for_crate(
+        db: &'db dyn HirDatabase,
+        krate: base_db::Crate,
+        ty: Ty<'db>,
+    ) -> Self {
+        let interner = DbInterner::new_with(db, krate);
+        Type { env: ParamEnvAndCrate { param_env: ParamEnv::empty(interner), krate }, ty }
     }
 
     fn new(db: &'db dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty<'db>) -> Self {
@@ -5588,15 +5598,18 @@ impl<'db> Type<'db> {
         Type::new(db, def, ty.instantiate(interner, args).skip_norm_wip())
     }
 
-    pub fn new_slice(ty: Self) -> Self {
-        let interner = DbInterner::conjure();
+    pub fn new_slice(db: &'db dyn HirDatabase, ty: Self) -> Self {
+        let interner = DbInterner::new_no_crate(db);
         Type { env: ty.env, ty: Ty::new_slice(interner, ty.ty) }
     }
 
-    pub fn new_tuple(krate: base_db::Crate, tys: &[Self]) -> Self {
+    pub fn new_tuple(db: &'db dyn HirDatabase, krate: base_db::Crate, tys: &[Self]) -> Self {
         let tys = tys.iter().map(|it| it.ty);
-        let interner = DbInterner::conjure();
-        Type { env: empty_param_env(krate), ty: Ty::new_tup_from_iter(interner, tys) }
+        let interner = DbInterner::new_with(db, krate);
+        Type {
+            env: ParamEnvAndCrate { param_env: ParamEnv::empty(interner), krate },
+            ty: Ty::new_tup_from_iter(interner, tys),
+        }
     }
 
     pub fn is_unit(&self) -> bool {
@@ -5708,8 +5721,8 @@ impl<'db> Type<'db> {
         Some((self.derived(ty), m))
     }
 
-    pub fn add_reference(&self, mutability: Mutability) -> Self {
-        let interner = DbInterner::conjure();
+    pub fn add_reference(&self, db: &'db dyn HirDatabase, mutability: Mutability) -> Self {
+        let interner = DbInterner::new_no_crate(db);
         let ty_mutability = match mutability {
             Mutability::Shared => hir_ty::next_solver::Mutability::Not,
             Mutability::Mut => hir_ty::next_solver::Mutability::Mut,
@@ -6012,9 +6025,9 @@ impl<'db> Type<'db> {
         }
     }
 
-    pub fn fingerprint_for_trait_impl(&self) -> Option<SimplifiedType> {
+    pub fn fingerprint_for_trait_impl(&self, db: &'db dyn HirDatabase) -> Option<SimplifiedType> {
         fast_reject::simplify_type(
-            DbInterner::conjure(),
+            DbInterner::new_no_crate(db),
             self.ty,
             fast_reject::TreatParams::AsRigid,
         )
@@ -7430,9 +7443,10 @@ fn param_env_from_resolver<'db>(
     resolver: &Resolver<'_>,
 ) -> ParamEnvAndCrate<'db> {
     ParamEnvAndCrate {
-        param_env: resolver
-            .generic_def()
-            .map_or_else(ParamEnv::empty, |generic_def| db.trait_environment(generic_def.into())),
+        param_env: resolver.generic_def().map_or_else(
+            || ParamEnv::empty(DbInterner::new_no_crate(db)),
+            |generic_def| db.trait_environment(generic_def.into()),
+        ),
         krate: resolver.krate(),
     }
 }
@@ -7451,10 +7465,6 @@ fn body_param_env_from_has_crate<'db>(
     ParamEnvAndCrate { param_env: db.trait_environment(id.into()), krate: id.krate(db) }
 }
 
-fn empty_param_env<'db>(krate: base_db::Crate) -> ParamEnvAndCrate<'db> {
-    ParamEnvAndCrate { param_env: ParamEnv::empty(), krate }
-}
-
 // FIXME: We probably don't want to expose this.
 pub trait MacroCallIdExt {
     fn loc(self, db: &dyn HirDatabase) -> hir_expand::MacroCallLoc;

crates/hir/src/source_analyzer.rs

@@ -330,13 +330,14 @@ impl<'db> SourceAnalyzer<'db> {
     }
 
     fn trait_environment(&self, db: &'db dyn HirDatabase) -> ParamEnvAndCrate<'db> {
-        self.param_and(self.body_or_sig.as_ref().map_or_else(ParamEnv::empty, |body_or_sig| {
-            match *body_or_sig {
+        self.param_and(self.body_or_sig.as_ref().map_or_else(
+            || ParamEnv::empty(DbInterner::new_no_crate(db)),
+            |body_or_sig| match *body_or_sig {
                 BodyOrSig::Body { def, .. } => db.trait_environment(def.into()),
                 BodyOrSig::VariantFields { def, .. } => db.trait_environment(def.into()),
                 BodyOrSig::Sig { def, .. } => db.trait_environment(def.into()),
-            }
-        }))
+            },
+        ))
     }
 
     pub(crate) fn expr_id(&self, expr: ast::Expr) -> Option<ExprOrPatId> {