itsscb/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-25 11:17:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use lower_nextsolver::callable_item_signature instead of lower::callable_item_signature

Browse Source
This commit is contained in:
Jack Huey 2025-09-23 02:51:21 -04:00
parent 73a401301d
commit cc7c061e34
16 changed files with 188 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
crates/hir-ty/src/db.rs
View File

@ -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,

6
crates/hir-ty/src/display.rs
View File

@ -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

2
crates/hir-ty/src/dyn_compatibility.rs
View File

@ -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()

4
crates/hir-ty/src/lib.rs
View File

@ -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 {

90
crates/hir-ty/src/lower.rs
View File

@ -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,

15
crates/hir-ty/src/method_resolution.rs
View File

@ -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));
}

14
crates/hir-ty/src/mir/lower.rs
View File

@ -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(

2
crates/hir-ty/src/next_solver/interner.rs
View File

@ -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 {

45
crates/hir-ty/src/next_solver/mapping.rs
View File

@ -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>>>,

2
crates/hir-ty/src/tests/method_resolution.rs
View File

@ -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>>
}
}
"#,

14
crates/hir-ty/src/tests/traits.rs
View File

@ -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 + '?)
"#]],

19
crates/hir-ty/src/variance.rs
View File

@ -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);
}
_ => {}
}

80
crates/hir/src/lib.rs
View File

@ -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() }

13
crates/ide-completion/src/context/analysis.rs
View File

@ -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> {

2
crates/ide/src/inlay_hints/bind_pat.rs
View File

@ -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();

4
crates/ide/src/signature_help.rs
View File

@ -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<()>)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
"#]],
);
}