rust-analyzer

diff --git a/crates/hir-ty/src/builtin_derive.rs b/crates/hir-ty/src/builtin_derive.rs
index fe60fbc510..4e19fb8067 100644
--- a/crates/hir-ty/src/builtin_derive.rs
+++ b/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 =

diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index bc726b652f..326f920b11 100644
--- a/crates/hir-ty/src/display.rs
+++ b/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)

diff --git a/crates/hir-ty/src/infer.rs b/crates/hir-ty/src/infer.rs
index 39ffb91a8c..6a29b2cedb 100644
--- a/crates/hir-ty/src/infer.rs
+++ b/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);

diff --git a/crates/hir-ty/src/lower.rs b/crates/hir-ty/src/lower.rs
index 5b0bcd2be8..0cb1a2db26 100644
--- a/crates/hir-ty/src/lower.rs
+++ b/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,

diff --git a/crates/hir-ty/src/lower/path.rs b/crates/hir-ty/src/lower/path.rs
index ff9718af11..6633215679 100644
--- a/crates/hir-ty/src/lower/path.rs
+++ b/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.

diff --git a/crates/hir-ty/src/next_solver/infer/traits.rs b/crates/hir-ty/src/next_solver/infer/traits.rs
index 4584b35796..362689ab5c 100644
--- a/crates/hir-ty/src/next_solver/infer/traits.rs
+++ b/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,

})

}

diff --git a/crates/hir-ty/src/next_solver/interner.rs b/crates/hir-ty/src/next_solver/interner.rs
index b3d31dd40b..9871042e61 100644
--- a/crates/hir-ty/src/next_solver/interner.rs
+++ b/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 {

diff --git a/crates/hir-ty/src/next_solver/predicate.rs b/crates/hir-ty/src/next_solver/predicate.rs
index 30738dea5c..cf492e65c3 100644
--- a/crates/hir-ty/src/next_solver/predicate.rs
+++ b/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> {

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 63b834a8d1..ac9adf592d 100644
--- a/crates/hir/src/lib.rs
+++ b/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;

diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 06182620c8..ba62cc11c3 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/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> {

diff --git a/crates/hir/src/term_search.rs b/crates/hir/src/term_search.rs
index af2371d493..1cc6766bfb 100644
--- a/crates/hir/src/term_search.rs
+++ b/crates/hir/src/term_search.rs

@@ -145,7 +145,7 @@ impl<'db> LookupTable<'db> {

self.data

.iter()

.find(|(t, _)| {

- t.add_reference(Mutability::Shared).could_unify_with_deeply(db, ty)

+ t.add_reference(db, Mutability::Shared).could_unify_with_deeply(db, ty)

})

.map(|(t, it)| {

it.exprs(t)

diff --git a/crates/hir/src/term_search/tactics.rs b/crates/hir/src/term_search/tactics.rs
index 8700326e17..67b6fd64c1 100644
--- a/crates/hir/src/term_search/tactics.rs
+++ b/crates/hir/src/term_search/tactics.rs

@@ -774,7 +774,7 @@ pub(super) fn make_tuple<'a, 'lt, 'db, DB: HirDatabase>(

.filter(|_| should_continue())

.map(|params| {

let tys: Vec<Type<'_>> = params.iter().map(|it| it.ty(db)).collect();

- let tuple_ty = Type::new_tuple(module.krate(db).into(), &tys);

+ let tuple_ty = Type::new_tuple(db, module.krate(db).into(), &tys);

let expr = Expr::Tuple { ty: tuple_ty.clone(), params };

lookup.insert(tuple_ty, iter::once(expr.clone()));

diff --git a/crates/ide-assists/src/utils.rs b/crates/ide-assists/src/utils.rs
index 096f6678a5..3ab4279b0a 100644
--- a/crates/ide-assists/src/utils.rs
+++ b/crates/ide-assists/src/utils.rs

@@ -841,8 +841,8 @@ pub(crate) fn convert_reference_type<'db>(

}

fn could_deref_to_target(ty: &hir::Type<'_>, target: &hir::Type<'_>, db: &dyn HirDatabase) -> bool {

- let ty_ref = ty.add_reference(hir::Mutability::Shared);

- let target_ref = target.add_reference(hir::Mutability::Shared);

+ let ty_ref = ty.add_reference(db, hir::Mutability::Shared);

+ let target_ref = target.add_reference(db, hir::Mutability::Shared);

ty_ref.could_coerce_to(db, &target_ref)

}

@@ -870,7 +870,7 @@ fn handle_as_ref_slice(

famous_defs: &FamousDefs<'_, '_>,

) -> Option<(ReferenceConversionType, bool)> {

let type_argument = ty.type_arguments().next()?;

- let slice_type = hir::Type::new_slice(type_argument);

+ let slice_type = hir::Type::new_slice(db, type_argument);

ty.impls_trait(db, famous_defs.core_convert_AsRef()?, slice::from_ref(&slice_type)).then_some((

ReferenceConversionType::AsRefSlice,

diff --git a/crates/ide-completion/src/completions/dot.rs b/crates/ide-completion/src/completions/dot.rs
index 2cc2200df9..c64bdf6bc5 100644
--- a/crates/ide-completion/src/completions/dot.rs
+++ b/crates/ide-completion/src/completions/dot.rs

@@ -93,7 +93,7 @@ pub(crate) fn complete_dot(

// Does <&receiver_ty as IntoIterator>::IntoIter` exist? Assume `iter` is valid

let iter = receiver_ty

.autoderef(ctx.db)

- .map(|ty| ty.strip_references().add_reference(hir::Mutability::Shared))

+ .map(|ty| ty.strip_references().add_reference(ctx.db, hir::Mutability::Shared))

.find_map(|ty| ty.into_iterator_iter(ctx.db))

.map(|ty| (ty, SmolStr::new_static("iter()")));

// Does <receiver_ty as IntoIterator>::IntoIter` exist?

diff --git a/crates/ide-completion/src/context/analysis.rs b/crates/ide-completion/src/context/analysis.rs
index faeb97f93f..6be9813619 100644
--- a/crates/ide-completion/src/context/analysis.rs
+++ b/crates/ide-completion/src/context/analysis.rs

@@ -641,7 +641,7 @@ fn expected_type_and_name<'db>(

}

for _ in refs_level..0 {

cov_mark::hit!(expected_type_fn_param_deref);

- ty = ty.add_reference(hir::Mutability::Shared);

+ ty = ty.add_reference(sema.db, hir::Mutability::Shared);

}

diff --git a/crates/ide-db/src/imports/import_assets.rs b/crates/ide-db/src/imports/import_assets.rs
index e0501b5e44..6edc550b33 100644
--- a/crates/ide-db/src/imports/import_assets.rs
+++ b/crates/ide-db/src/imports/import_assets.rs

@@ -814,13 +814,13 @@ fn trait_applicable_items<'db>(

let mut deref_chain = trait_candidate.receiver_ty.autoderef(db).collect::<Vec<_>>();

// As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!)

if let Some((ty, _len)) = deref_chain.last().and_then(|ty| ty.as_array(db)) {

- let slice = Type::new_slice(ty);

+ let slice = Type::new_slice(db, ty);

deref_chain.push(slice);

}

deref_chain

.into_iter()

.flat_map(|ty| {

- let fingerprint = ty.fingerprint_for_trait_impl()?;

+ let fingerprint = ty.fingerprint_for_trait_impl(db)?;

let mut crates = vec![];

if let Some(adt) = ty.as_adt() {

diff --git a/crates/ide-diagnostics/src/handlers/type_mismatch.rs b/crates/ide-diagnostics/src/handlers/type_mismatch.rs
index 250c692d16..08791fecbe 100644
--- a/crates/ide-diagnostics/src/handlers/type_mismatch.rs
+++ b/crates/ide-diagnostics/src/handlers/type_mismatch.rs

@@ -88,7 +88,7 @@ fn add_reference(

let range = ctx.sema.diagnostics_display_range((*expr_ptr).map(|it| it.into()));

let (_, mutability) = d.expected.as_reference()?;

- let actual_with_ref = d.actual.add_reference(mutability);

+ let actual_with_ref = d.actual.add_reference(ctx.db(), mutability);

if !actual_with_ref.could_coerce_to(ctx.sema.db, &d.expected) {

return None;

}