rust-analyzer

diff --git a/crates/hir-ty/src/db.rs b/crates/hir-ty/src/db.rs
index 6eb5f8defa..84c6c0471b 100644
--- a/crates/hir-ty/src/db.rs
+++ b/crates/hir-ty/src/db.rs

@@ -16,8 +16,8 @@ use smallvec::SmallVec;

use triomphe::Arc;

use crate::{

- Binders, Const, ImplTraitId, ImplTraits, InferenceResult, PolyFnSig, Substitution,

- TraitEnvironment, TraitRef, Ty, TyDefId, ValueTyDefId, chalk_db,

+ Binders, Const, ImplTraitId, ImplTraits, InferenceResult, Substitution, TraitEnvironment,

+ TraitRef, Ty, TyDefId, ValueTyDefId, chalk_db,

consteval::ConstEvalError,

drop::DropGlue,

dyn_compatibility::DynCompatibilityViolation,

@@ -167,8 +167,11 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {

#[salsa::transparent]

fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>>;

- #[salsa::invoke(crate::lower::callable_item_signature_query)]

- fn callable_item_signature(&self, def: CallableDefId) -> PolyFnSig;

+ #[salsa::invoke(crate::lower_nextsolver::callable_item_signature_query)]

+ fn callable_item_signature<'db>(

+ &'db self,

+ def: CallableDefId,

+ ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::PolyFnSig<'db>>;

#[salsa::invoke(crate::lower::return_type_impl_traits)]

fn return_type_impl_traits(&self, def: FunctionId) -> Option<Arc<Binders<ImplTraits>>>;

@@ -354,12 +357,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {

ArenaMap<LocalFieldId, crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>>,

- #[salsa::invoke(crate::lower_nextsolver::callable_item_signature_query)]

- fn callable_item_signature_ns<'db>(

- &'db self,

- def: CallableDefId,

- ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::PolyFnSig<'db>>;

#[salsa::invoke(crate::lower_nextsolver::return_type_impl_traits)]

fn return_type_impl_traits_ns<'db>(

&'db self,

diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index dc42304e1c..e11ce51cdb 100644
--- a/crates/hir-ty/src/display.rs
+++ b/crates/hir-ty/src/display.rs

@@ -46,8 +46,8 @@ use span::Edition;

use stdx::never;

use triomphe::Arc;

-use crate::next_solver::infer::DbInternerInferExt;

use crate::next_solver::infer::traits::ObligationCause;

+use crate::next_solver::{infer::DbInternerInferExt, mapping::NextSolverToChalk};

use crate::{

AliasEq, AliasTy, Binders, CallableDefId, CallableSig, ConcreteConst, Const, ConstScalar,

ConstValue, DomainGoal, FnAbi, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,

@@ -1298,7 +1298,9 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {

let def = def.0;

let sig = db

.callable_item_signature(def)

- .substitute(Interner, &convert_args_for_result(interner, args.as_slice()));

+ .instantiate(interner, args)

+ .skip_binder()

+ .to_chalk(interner);

if f.display_kind.is_source_code() {

// `FnDef` is anonymous and there's no surface syntax for it. Show it as a

diff --git a/crates/hir-ty/src/dyn_compatibility.rs b/crates/hir-ty/src/dyn_compatibility.rs
index b87c998217..f033c511ac 100644
--- a/crates/hir-ty/src/dyn_compatibility.rs
+++ b/crates/hir-ty/src/dyn_compatibility.rs

@@ -329,7 +329,7 @@ where

cb(MethodViolationCode::AsyncFn)?;

}

- let sig = db.callable_item_signature_ns(func.into());

+ let sig = db.callable_item_signature(func.into());

if sig

.skip_binder()

.inputs()

diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs
index 05c5a7a28b..c2acfc4142 100644
--- a/crates/hir-ty/src/lib.rs
+++ b/crates/hir-ty/src/lib.rs

@@ -578,8 +578,10 @@ impl CallableSig {

pub fn from_def(db: &dyn HirDatabase, def: FnDefId, substs: &Substitution) -> CallableSig {

let callable_def = ToChalk::from_chalk(db, def);

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

let sig = db.callable_item_signature(callable_def);

- sig.substitute(Interner, substs)

+ sig.instantiate(interner, args).skip_binder().to_chalk(interner)

}

pub fn from_fn_ptr(fn_ptr: &FnPointer) -> CallableSig {

CallableSig {

diff --git a/crates/hir-ty/src/lower.rs b/crates/hir-ty/src/lower.rs
index 756769a217..598fd38b4b 100644
--- a/crates/hir-ty/src/lower.rs
+++ b/crates/hir-ty/src/lower.rs

@@ -24,9 +24,9 @@ use chalk_ir::{

use either::Either;

use hir_def::{

- AdtId, AssocItemId, CallableDefId, ConstId, ConstParamId, EnumId, EnumVariantId, FunctionId,

- GenericDefId, GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StaticId,

- StructId, TypeAliasId, TypeOrConstParamId, UnionId, VariantId,

+ AdtId, AssocItemId, ConstId, ConstParamId, EnumId, EnumVariantId, FunctionId, GenericDefId,

+ GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StaticId, StructId, TypeAliasId,

+ TypeOrConstParamId, UnionId, VariantId,

builtin_type::BuiltinType,

expr_store::{ExpressionStore, path::Path},

hir::generics::{GenericParamDataRef, TypeOrConstParamData, WherePredicate},

@@ -45,10 +45,10 @@ use stdx::{impl_from, never};

use triomphe::{Arc, ThinArc};

use crate::{

- AliasTy, Binders, BoundVar, CallableSig, Const, DebruijnIndex, DynTy, FnAbi, FnPointer, FnSig,

- FnSubst, ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime, LifetimeData,

- LifetimeOutlives, PolyFnSig, QuantifiedWhereClause, QuantifiedWhereClauses, Substitution,

- TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause, all_super_traits,

+ AliasTy, Binders, BoundVar, Const, DebruijnIndex, DynTy, FnAbi, FnPointer, FnSig, FnSubst,

+ ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime, LifetimeData, LifetimeOutlives,

+ QuantifiedWhereClause, QuantifiedWhereClauses, Substitution, TraitRef, TraitRefExt, Ty,

+ TyBuilder, TyKind, WhereClause, all_super_traits,

consteval::{intern_const_ref, path_to_const, unknown_const, unknown_const_as_generic},

db::HirDatabase,

error_lifetime,

@@ -824,15 +824,6 @@ impl<'a> TyLoweringContext<'a> {

}

-/// Build the signature of a callable item (function, struct or enum variant).

-pub(crate) fn callable_item_signature_query(db: &dyn HirDatabase, def: CallableDefId) -> PolyFnSig {

- match def {

- CallableDefId::FunctionId(f) => fn_sig_for_fn(db, f),

- CallableDefId::StructId(s) => fn_sig_for_struct_constructor(db, s),

- CallableDefId::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e),

- }

fn named_associated_type_shorthand_candidates<R>(

db: &dyn HirDatabase,

// If the type parameter is defined in an impl and we're in a method, there

@@ -1312,73 +1303,6 @@ pub(crate) fn generic_defaults_with_diagnostics_cycle_result(

(GenericDefaults(None), None)

}

-fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {

- let data = db.function_signature(def);

- let resolver = def.resolver(db);

- let mut ctx_params = TyLoweringContext::new(

- db,

- &resolver,

- &data.store,

- def.into(),

- LifetimeElisionKind::for_fn_params(&data),

- )

- .with_type_param_mode(ParamLoweringMode::Variable);

- let params = data.params.iter().map(|&tr| ctx_params.lower_ty(tr));

- let ret = match data.ret_type {

- Some(ret_type) => {

- let mut ctx_ret = TyLoweringContext::new(

- db,

- &resolver,

- &data.store,

- def.into(),

- LifetimeElisionKind::for_fn_ret(),

- )

- .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)

- .with_type_param_mode(ParamLoweringMode::Variable);

- ctx_ret.lower_ty(ret_type)

- }

- None => TyKind::Tuple(0, Substitution::empty(Interner)).intern(Interner),

- };

- let generics = generics(db, def.into());

- let sig = CallableSig::from_params_and_return(

- params,

- ret,

- data.is_varargs(),

- if data.is_unsafe() { Safety::Unsafe } else { Safety::Safe },

- data.abi.as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),

- );

- make_binders(db, &generics, sig)

-fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig {

- let field_tys = db.field_types(def.into());

- let params = field_tys.iter().map(|(_, ty)| ty.skip_binders().clone());

- let (ret, binders) = type_for_adt(db, def.into()).into_value_and_skipped_binders();

- Binders::new(

- binders,

- CallableSig::from_params_and_return(params, ret, false, Safety::Safe, FnAbi::RustCall),

- )

-fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig {

- let field_tys = db.field_types(def.into());

- let params = field_tys.iter().map(|(_, ty)| ty.skip_binders().clone());

- let parent = def.lookup(db).parent;

- let (ret, binders) = type_for_adt(db, parent.into()).into_value_and_skipped_binders();

- Binders::new(

- binders,

- CallableSig::from_params_and_return(params, ret, false, Safety::Safe, FnAbi::RustCall),

- )

-fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {

- let generics = generics(db, adt.into());

- let subst = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST);

- let ty = TyKind::Adt(crate::AdtId(adt), subst).intern(Interner);

- make_binders(db, &generics, ty)

pub(crate) fn type_for_type_alias_with_diagnostics_query(

db: &dyn HirDatabase,

t: TypeAliasId,

diff --git a/crates/hir-ty/src/method_resolution.rs b/crates/hir-ty/src/method_resolution.rs
index 66687490b4..93ef64272d 100644
--- a/crates/hir-ty/src/method_resolution.rs
+++ b/crates/hir-ty/src/method_resolution.rs

@@ -1746,9 +1746,13 @@ fn is_valid_trait_method_candidate(

.fill_with_inference_vars(table)

.build();

+ let args: crate::next_solver::GenericArgs<'_> =

+ fn_subst.to_nextsolver(table.interner);

let sig = db.callable_item_signature(fn_id.into());

- let expected_receiver =

- sig.map(|s| s.params()[0].clone()).substitute(Interner, &fn_subst);

+ let expected_receiver = sig

+ .map_bound(|s| s.skip_binder().inputs_and_output.as_slice()[0])

+ .instantiate(table.interner, args)

+ .to_chalk(table.interner);

// FIXME: Clean up this mess with some context struct like rustc's `ProbeContext`

let variance = match mode {

@@ -1833,9 +1837,12 @@ fn is_valid_impl_fn_candidate(

let fn_subst: crate::Substitution =

table.infer_ctxt.fresh_args_for_item(fn_id.into()).to_chalk(table.interner);

+ let args: crate::next_solver::GenericArgs<'_> = fn_subst.to_nextsolver(table.interner);

let sig = db.callable_item_signature(fn_id.into());

- let expected_receiver =

- sig.map(|s| s.params()[0].clone()).substitute(Interner, &fn_subst);

+ let expected_receiver = sig

+ .map_bound(|s| s.skip_binder().inputs_and_output.as_slice()[0])

+ .instantiate(table.interner, args)

+ .to_chalk(table.interner);

check_that!(table.unify(receiver_ty, &expected_receiver));

}

diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
index 0416f4315d..3e44e8c68d 100644
--- a/crates/hir-ty/src/mir/lower.rs
+++ b/crates/hir-ty/src/mir/lower.rs

@@ -43,7 +43,10 @@ use crate::{

Terminator, TerminatorKind, TupleFieldId, Ty, UnOp, VariantId, intern_const_scalar,

return_slot,

- next_solver::{DbInterner, mapping::ChalkToNextSolver},

+ next_solver::{

+ DbInterner,

+ mapping::{ChalkToNextSolver, NextSolverToChalk},

+ },

static_lifetime,

traits::FnTrait,

utils::ClosureSubst,

@@ -2207,8 +2210,13 @@ pub fn lower_to_mir(

// otherwise it's an inline const, and has no parameter

if let DefWithBodyId::FunctionId(fid) = owner {

let substs = TyBuilder::placeholder_subst(db, fid);

- let callable_sig =

- db.callable_item_signature(fid.into()).substitute(Interner, &substs);

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let callable_sig = db

+ .callable_item_signature(fid.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .to_chalk(interner);

let mut params = callable_sig.params().iter();

let self_param = body.self_param.and_then(|id| Some((id, params.next()?.clone())));

break 'b ctx.lower_params_and_bindings(

diff --git a/crates/hir-ty/src/next_solver/interner.rs b/crates/hir-ty/src/next_solver/interner.rs
index 3f61b9f026..1a14ac9a74 100644
--- a/crates/hir-ty/src/next_solver/interner.rs
+++ b/crates/hir-ty/src/next_solver/interner.rs

@@ -1225,7 +1225,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {

self,

def_id: Self::FunctionId,

) -> EarlyBinder<Self, rustc_type_ir::Binder<Self, rustc_type_ir::FnSig<Self>>> {

- self.db().callable_item_signature_ns(def_id.0)

+ self.db().callable_item_signature(def_id.0)

}

fn coroutine_movability(self, def_id: Self::CoroutineId) -> rustc_ast_ir::Movability {

diff --git a/crates/hir-ty/src/next_solver/mapping.rs b/crates/hir-ty/src/next_solver/mapping.rs
index 5dcb1e6232..f3f74f67c0 100644
--- a/crates/hir-ty/src/next_solver/mapping.rs
+++ b/crates/hir-ty/src/next_solver/mapping.rs

@@ -575,6 +575,17 @@ impl<

}

+impl<'db, T: NextSolverToChalk<'db, U>, U: HasInterner<Interner = Interner>>

+ NextSolverToChalk<'db, chalk_ir::Binders<U>> for rustc_type_ir::Binder<DbInterner<'db>, T>

+ fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::Binders<U> {

+ chalk_ir::Binders::new(

+ self.bound_vars().to_chalk(interner),

+ self.skip_binder().to_chalk(interner),

+ )

+ }

impl<'db> ChalkToNextSolver<'db, BoundVarKinds> for chalk_ir::VariableKinds<Interner> {

fn to_nextsolver(&self, interner: DbInterner<'db>) -> BoundVarKinds {

BoundVarKinds::new_from_iter(

@@ -584,6 +595,12 @@ impl<'db> ChalkToNextSolver<'db, BoundVarKinds> for chalk_ir::VariableKinds<Inte

}

+impl<'db> NextSolverToChalk<'db, chalk_ir::VariableKinds<Interner>> for BoundVarKinds {

+ fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::VariableKinds<Interner> {

+ chalk_ir::VariableKinds::from_iter(Interner, self.iter().map(|v| v.to_chalk(interner)))

+ }

impl<'db> ChalkToNextSolver<'db, BoundVarKind> for chalk_ir::VariableKind<Interner> {

fn to_nextsolver(&self, interner: DbInterner<'db>) -> BoundVarKind {

match self {

@@ -594,6 +611,18 @@ impl<'db> ChalkToNextSolver<'db, BoundVarKind> for chalk_ir::VariableKind<Intern

}

+impl<'db> NextSolverToChalk<'db, chalk_ir::VariableKind<Interner>> for BoundVarKind {

+ fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::VariableKind<Interner> {

+ match self {

+ BoundVarKind::Ty(_) => chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),

+ BoundVarKind::Region(_) => chalk_ir::VariableKind::Lifetime,

+ BoundVarKind::Const => {

+ chalk_ir::VariableKind::Const(chalk_ir::TyKind::Error.intern(Interner))

+ }

impl<'db> ChalkToNextSolver<'db, GenericArg<'db>> for chalk_ir::GenericArg<Interner> {

fn to_nextsolver(&self, interner: DbInterner<'db>) -> GenericArg<'db> {

match self.data(Interner) {

@@ -1233,6 +1262,22 @@ where

}

+impl<'db> NextSolverToChalk<'db, crate::CallableSig> for rustc_type_ir::FnSig<DbInterner<'db>> {

+ fn to_chalk(self, interner: DbInterner<'db>) -> crate::CallableSig {

+ crate::CallableSig {

+ abi: self.abi,

+ is_varargs: self.c_variadic,

+ safety: match self.safety {

+ super::abi::Safety::Safe => chalk_ir::Safety::Safe,

+ super::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,

+ },

+ params_and_return: triomphe::Arc::from_iter(

+ self.inputs_and_output.iter().map(|ty| convert_ty_for_result(interner, ty)),

+ ),

+ }

pub fn convert_canonical_args_for_result<'db>(

interner: DbInterner<'db>,

args: Canonical<'db, Vec<GenericArg<'db>>>,

diff --git a/crates/hir-ty/src/tests/method_resolution.rs b/crates/hir-ty/src/tests/method_resolution.rs
index 6a566a5055..5ada14bc53 100644
--- a/crates/hir-ty/src/tests/method_resolution.rs
+++ b/crates/hir-ty/src/tests/method_resolution.rs

@@ -2053,7 +2053,7 @@ impl dyn Error + Send {

// ^^^^ expected Box<dyn Error + '?>, got Box<dyn Error + Send + '?>

// FIXME, type mismatch should not occur

<dyn Error>::downcast(err).map_err(|_| loop {})

- //^^^^^^^^^^^^^^^^^^^^^ type: fn downcast<{unknown}>(Box<dyn Error + 'static>) -> Result<Box<{unknown}>, Box<dyn Error + '?>>

+ //^^^^^^^^^^^^^^^^^^^^^ type: fn downcast<{unknown}>(Box<dyn Error + 'static>) -> Result<Box<{unknown}>, Box<dyn Error + 'static>>

}

"#,

diff --git a/crates/hir-ty/src/tests/traits.rs b/crates/hir-ty/src/tests/traits.rs
index 41f8d4ed55..66faac09cc 100644
--- a/crates/hir-ty/src/tests/traits.rs
+++ b/crates/hir-ty/src/tests/traits.rs

@@ -1487,8 +1487,8 @@ fn test(x: Box<dyn Trait<u64>>, y: &dyn Trait<u64>) {

268..269 'x': Box<dyn Trait<u64> + '?>

275..276 'y': &'? (dyn Trait<u64> + '?)

286..287 'z': Box<dyn Trait<u64> + '?>

- 290..293 'bar': fn bar() -> Box<dyn Trait<u64> + '?>

- 290..295 'bar()': Box<dyn Trait<u64> + '?>

+ 290..293 'bar': fn bar() -> Box<dyn Trait<u64> + 'static>

+ 290..295 'bar()': Box<dyn Trait<u64> + 'static>

301..302 'x': Box<dyn Trait<u64> + '?>

301..308 'x.foo()': u64

314..315 'y': &'? (dyn Trait<u64> + '?)

@@ -1535,7 +1535,7 @@ fn test(s: S<u32, i32>) {

251..252 's': S<u32, i32>

267..289 '{ ...z(); }': ()

273..274 's': S<u32, i32>

- 273..280 's.bar()': &'? (dyn Trait<u32, i32> + '?)

+ 273..280 's.bar()': &'? (dyn Trait<u32, i32> + 'static)

273..286 's.bar().baz()': (u32, i32)

"#]],

);

@@ -1568,8 +1568,8 @@ fn test(x: Trait, y: &Trait) -> u64 {

106..107 'x': dyn Trait + '?

113..114 'y': &'? (dyn Trait + '?)

124..125 'z': dyn Trait + '?

- 128..131 'bar': fn bar() -> dyn Trait + '?

- 128..133 'bar()': dyn Trait + '?

+ 128..131 'bar': fn bar() -> dyn Trait + 'static

+ 128..133 'bar()': dyn Trait + 'static

139..140 'x': dyn Trait + '?

139..146 'x.foo()': u64

152..153 'y': &'? (dyn Trait + '?)

@@ -1597,7 +1597,7 @@ fn main() {

47..48 '_': &'? (dyn Fn(S) + '?)

58..60 '{}': ()

71..105 '{ ...()); }': ()

- 77..78 'f': fn f(&'? (dyn Fn(S) + '?))

+ 77..78 'f': fn f(&'? (dyn Fn(S) + 'static))

77..102 'f(&|nu...foo())': ()

79..101 '&|numb....foo()': &'? impl Fn(S)

80..101 '|numbe....foo()': impl Fn(S)

@@ -2952,7 +2952,7 @@ fn test(x: &dyn Foo) {

34..36 '{}': ()

46..47 'x': &'? (dyn Foo + '?)

59..74 '{ foo(x); }': ()

- 65..68 'foo': fn foo(&'? (dyn Foo + '?))

+ 65..68 'foo': fn foo(&'? (dyn Foo + 'static))

65..71 'foo(x)': ()

69..70 'x': &'? (dyn Foo + '?)

"#]],

diff --git a/crates/hir-ty/src/variance.rs b/crates/hir-ty/src/variance.rs
index 8593dba301..a17cf37827 100644
--- a/crates/hir-ty/src/variance.rs
+++ b/crates/hir-ty/src/variance.rs

@@ -15,6 +15,8 @@

use crate::db::HirDatabase;

use crate::generics::{Generics, generics};

+use crate::next_solver::DbInterner;

+use crate::next_solver::mapping::{ChalkToNextSolver, NextSolverToChalk};

use crate::{

AliasTy, Const, ConstScalar, DynTyExt, GenericArg, GenericArgData, Interner, Lifetime,

LifetimeData, Ty, TyKind,

@@ -238,14 +240,15 @@ impl Context<'_> {

}

GenericDefId::FunctionId(f) => {

let subst = self.generics.placeholder_subst(self.db);

- self.add_constraints_from_sig(

- self.db

- .callable_item_signature(f.into())

- .substitute(Interner, &subst)

- .params_and_return

- .iter(),

- Variance::Covariant,

- );

+ let interner = DbInterner::new_with(self.db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = subst.to_nextsolver(interner);

+ let sig = self

+ .db

+ .callable_item_signature(f.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .to_chalk(interner);

+ self.add_constraints_from_sig(sig.params_and_return.iter(), Variance::Covariant);

}

_ => {}

}

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 8b440611e6..709d165e0b 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs

@@ -2287,7 +2287,13 @@ impl Function {

pub fn fn_ptr_type(self, db: &dyn HirDatabase) -> Type<'_> {

let resolver = self.id.resolver(db);

let substs = TyBuilder::placeholder_subst(db, self.id);

- let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let callable_sig = db

+ .callable_item_signature(self.id.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .to_chalk(interner);

let ty = TyKind::Function(callable_sig.to_fn_ptr()).intern(Interner);

Type::new_with_resolver_inner(db, &resolver, ty)

}

@@ -2296,8 +2302,14 @@ impl Function {

pub fn ret_type(self, db: &dyn HirDatabase) -> Type<'_> {

let resolver = self.id.resolver(db);

let substs = TyBuilder::placeholder_subst(db, self.id);

- let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

- let ty = callable_sig.ret().clone();

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let ty = db

+ .callable_item_signature(self.id.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .output()

+ .to_chalk(interner);

Type::new_with_resolver_inner(db, &resolver, ty)

}

@@ -2326,8 +2338,14 @@ impl Function {

parent_id.map(|id| TyBuilder::subst_for_def(db, id, None).fill(&mut filler).build());

let substs = TyBuilder::subst_for_def(db, self.id, parent_substs).fill(&mut filler).build();

- let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

- let ty = callable_sig.ret().clone();

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let ty = db

+ .callable_item_signature(self.id.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .output()

+ .to_chalk(interner);

Type::new_with_resolver_inner(db, &resolver, ty)

}

@@ -2337,8 +2355,14 @@ impl Function {

}

let resolver = self.id.resolver(db);

let substs = TyBuilder::placeholder_subst(db, self.id);

- let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

- let ret_ty = callable_sig.ret().clone();

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let ret_ty = db

+ .callable_item_signature(self.id.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .output()

+ .to_chalk(interner);

for pred in ret_ty.impl_trait_bounds(db).into_iter().flatten() {

if let WhereClause::AliasEq(output_eq) = pred.into_value_and_skipped_binders().0 {

return Type::new_with_resolver_inner(db, &resolver, output_eq.ty).into();

@@ -2358,7 +2382,13 @@ impl Function {

pub fn assoc_fn_params(self, db: &dyn HirDatabase) -> Vec<Param<'_>> {

let environment = db.trait_environment(self.id.into());

let substs = TyBuilder::placeholder_subst(db, self.id);

- let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let callable_sig = db

+ .callable_item_signature(self.id.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .to_chalk(interner);

callable_sig

.params()

.iter()

@@ -2386,7 +2416,13 @@ impl Function {

pub fn params_without_self(self, db: &dyn HirDatabase) -> Vec<Param<'_>> {

let environment = db.trait_environment(self.id.into());

let substs = TyBuilder::placeholder_subst(db, self.id);

- let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let callable_sig = db

+ .callable_item_signature(self.id.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .to_chalk(interner);

let skip = if db.function_signature(self.id).has_self_param() { 1 } else { 0 };

callable_sig

.params()

@@ -2436,7 +2472,13 @@ impl Function {

GenericArg::new(Interner, GenericArgData::Ty(ty))

})

.build();

- let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let callable_sig = db

+ .callable_item_signature(self.id.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .to_chalk(interner);

let skip = if db.function_signature(self.id).has_self_param() { 1 } else { 0 };

callable_sig

.params()

@@ -2731,8 +2773,13 @@ impl SelfParam {

pub fn ty<'db>(&self, db: &'db dyn HirDatabase) -> Type<'db> {

let substs = TyBuilder::placeholder_subst(db, self.func);

- let callable_sig =

- db.callable_item_signature(self.func.into()).substitute(Interner, &substs);

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let callable_sig = db

+ .callable_item_signature(self.func.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .to_chalk(interner);

let environment = db.trait_environment(self.func.into());

let ty = callable_sig.params()[0].clone();

Type { env: environment, ty, _pd: PhantomCovariantLifetime::new() }

@@ -2764,8 +2811,13 @@ impl SelfParam {

let parent_substs = TyBuilder::subst_for_def(db, parent_id, None).fill(&mut filler).build();

let substs =

TyBuilder::subst_for_def(db, self.func, Some(parent_substs)).fill(&mut filler).build();

- let callable_sig =

- db.callable_item_signature(self.func.into()).substitute(Interner, &substs);

+ let interner = DbInterner::new_with(db, None, None);

+ let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

+ let callable_sig = db

+ .callable_item_signature(self.func.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .to_chalk(interner);

let environment = db.trait_environment(self.func.into());

let ty = callable_sig.params()[0].clone();

Type { env: environment, ty, _pd: PhantomCovariantLifetime::new() }

diff --git a/crates/ide-completion/src/context/analysis.rs b/crates/ide-completion/src/context/analysis.rs
index cdb1ad8b38..77a94403ab 100644
--- a/crates/ide-completion/src/context/analysis.rs
+++ b/crates/ide-completion/src/context/analysis.rs

@@ -1,6 +1,7 @@

//! Module responsible for analyzing the code surrounding the cursor for completion.

use std::iter;

+use base_db::salsa;

use hir::{ExpandResult, InFile, Semantics, Type, TypeInfo, Variant};

use ide_db::{RootDatabase, active_parameter::ActiveParameter};

use itertools::Either;

@@ -85,9 +86,15 @@ pub(super) fn expand_and_analyze<'db>(

let original_offset = expansion.original_offset + relative_offset;

let token = expansion.original_file.token_at_offset(original_offset).left_biased()?;

- analyze(sema, expansion, original_token, &token).map(|(analysis, expected, qualifier_ctx)| {

- AnalysisResult { analysis, expected, qualifier_ctx, token, original_offset }

- })

+ salsa::attach(sema.db, || analyze(sema, expansion, original_token, &token)).map(

+ |(analysis, expected, qualifier_ctx)| AnalysisResult {

+ analysis,

+ expected,

+ qualifier_ctx,

+ token,

+ original_offset,

+ },

+ )

}

fn token_at_offset_ignore_whitespace(file: &SyntaxNode, offset: TextSize) -> Option<SyntaxToken> {

diff --git a/crates/ide/src/inlay_hints/bind_pat.rs b/crates/ide/src/inlay_hints/bind_pat.rs
index 104740cbbf..b7c1241396 100644
--- a/crates/ide/src/inlay_hints/bind_pat.rs
+++ b/crates/ide/src/inlay_hints/bind_pat.rs

@@ -380,7 +380,7 @@ fn main() {

let foo = foo4();

// ^^^ &dyn Fn(f64, f64) -> u32

let foo = foo5();

- // ^^^ &dyn Fn(&dyn Fn(f64, f64) -> u32, f64) -> u32

+ // ^^^ &dyn Fn(&(dyn Fn(f64, f64) -> u32 + 'static), f64) -> u32

let foo = foo6();

// ^^^ impl Fn(f64, f64) -> u32

let foo = foo7();

diff --git a/crates/ide/src/signature_help.rs b/crates/ide/src/signature_help.rs
index e74d997e97..6f55886adc 100644
--- a/crates/ide/src/signature_help.rs
+++ b/crates/ide/src/signature_help.rs

@@ -1097,8 +1097,8 @@ fn foo(mut r: impl WriteHandler<()>) {

By default this method stops actor's `Context`.

------

- fn finished(&mut self, ctx: &mut <impl WriteHandler<()> as Actor>::Context)

- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

+ fn finished(&mut self, ctx: &mut <impl WriteHandler<()> as Actor>::Context<()>)

+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

"#]],

);

}