Auto merge of #17268 - Veykril:signatures, r=Veykril

feat: More callable info
With this PR we retain more info about callables other than functions, allowing for closure parameter type inlay hints to be linkable as well as better signature help around closures and `Fn*` implementors.

Author: bors

src/tools/rust-analyzer/crates/hir-def/src/attr/builtin.rs

@@ -12,9 +12,6 @@ use std::sync::OnceLock;
 
 use rustc_hash::FxHashMap;
 
-/// Ignored attribute namespaces used by tools.
-pubconstTOOL_MODULES:&[&str] = &["rustfmt","clippy"];
-
 pubstructBuiltinAttribute{
 pubname:&'staticstr,
 pubtemplate:AttributeTemplate,

src/tools/rust-analyzer/crates/hir-def/src/nameres.rs

@@ -84,6 +84,14 @@ use crate::{
 LocalModuleId,Lookup,MacroExpander,MacroId,ModuleId,ProcMacroId,UseId,
 };
 
+constPREDEFINED_TOOLS:&[SmolStr] = &[
+SmolStr::new_static("clippy"),
+SmolStr::new_static("rustfmt"),
+SmolStr::new_static("diagnostic"),
+SmolStr::new_static("miri"),
+SmolStr::new_static("rust_analyzer"),
+];
+
 /// Contains the results of (early) name resolution.
 ///
 /// A `DefMap` stores the module tree and the definitions that are in scope in every module after
@@ -160,7 +168,7 @@ impl DefMapCrateData {
 fn_proc_macro_mapping:FxHashMap::default(),
 proc_macro_loading_error:None,
 registered_attrs:Vec::new(),
-registered_tools:Vec::new(),
+registered_tools:PREDEFINED_TOOLS.into(),
 unstable_features:FxHashSet::default(),
 rustc_coherence_is_core:false,
 no_core:false,

src/tools/rust-analyzer/crates/hir-def/src/nameres/attr_resolution.rs

@@ -10,7 +10,7 @@ use syntax::{ast, SmolStr};
 use triomphe::Arc;
 
 usecrate::{
- attr::builtin::{find_builtin_attr_idx,TOOL_MODULES},
+ attr::builtin::find_builtin_attr_idx,
  db::DefDatabase,
  item_scope::BuiltinShadowMode,
  nameres::path_resolution::ResolveMode,
@@ -82,8 +82,7 @@ impl DefMap {
 let name = name.to_smol_str();
 let pred = |n:&_| *n == name;
 
-let registered = self.data.registered_tools.iter().map(SmolStr::as_str);
-let is_tool = TOOL_MODULES.iter().copied().chain(registered).any(pred);
+let is_tool = self.data.registered_tools.iter().map(SmolStr::as_str).any(pred);
 // FIXME: tool modules can be shadowed by actual modules
 if is_tool {
 returntrue;

src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs

@@ -797,19 +797,22 @@ impl<'a> InferenceTable<'a> {
 })
 .build();
 
-let projection = {
-let b = TyBuilder::subst_for_def(self.db, fn_once_trait,None);
-if b.remaining() != 2{
-returnNone;
-}
-let fn_once_subst = b.push(ty.clone()).push(arg_ty).build();
+let b = TyBuilder::trait_ref(self.db, fn_once_trait);
+if b.remaining() != 2{
+returnNone;
+}
+letmut trait_ref = b.push(ty.clone()).push(arg_ty).build();
 
-TyBuilder::assoc_type_projection(self.db, output_assoc_type,Some(fn_once_subst))
-.build()
+let projection = {
+TyBuilder::assoc_type_projection(
+self.db,
+ output_assoc_type,
+Some(trait_ref.substitution.clone()),
+)
+.build()
 };
 
 let trait_env = self.trait_env.env.clone();
-letmut trait_ref = projection.trait_ref(self.db);
 let obligation = InEnvironment{
 goal: trait_ref.clone().cast(Interner),
 environment: trait_env.clone(),

src/tools/rust-analyzer/crates/hir-ty/src/lib.rs

@@ -570,6 +570,10 @@ impl CallableSig {
 }
 }
 
+pubfnabi(&self) -> FnAbi{
+self.abi
+}
+
 pubfnparams(&self) -> &[Ty]{
 &self.params_and_return[0..self.params_and_return.len() - 1]
 }
@@ -892,20 +896,16 @@ where
 Canonical{ value,binders: chalk_ir::CanonicalVarKinds::from_iter(Interner, kinds)}
 }
 
-pubfncallable_sig_from_fnonce(
-mutself_ty:&Ty,
-env:Arc<TraitEnvironment>,
+pubfncallable_sig_from_fn_trait(
+self_ty:&Ty,
+trait_env:Arc<TraitEnvironment>,
 db:&dynHirDatabase,
-) -> Option<CallableSig>{
-ifletSome((ty, _, _)) = self_ty.as_reference(){
-// This will happen when it implements fn or fn mut, since we add a autoborrow adjustment
- self_ty = ty;
-}
-let krate = env.krate;
+) -> Option<(FnTrait,CallableSig)>{
+let krate = trait_env.krate;
 let fn_once_trait = FnTrait::FnOnce.get_id(db, krate)?;
 let output_assoc_type = db.trait_data(fn_once_trait).associated_type_by_name(&name![Output])?;
 
-letmut table = InferenceTable::new(db,env);
+letmut table = InferenceTable::new(db,trait_env.clone());
 let b = TyBuilder::trait_ref(db, fn_once_trait);
 if b.remaining() != 2{
 returnNone;
@@ -915,23 +915,56 @@ pub fn callable_sig_from_fnonce(
 // - Self: FnOnce<?args_ty>
 // - <Self as FnOnce<?args_ty>>::Output == ?ret_ty
 let args_ty = table.new_type_var();
-let trait_ref = b.push(self_ty.clone()).push(args_ty.clone()).build();
+letmuttrait_ref = b.push(self_ty.clone()).push(args_ty.clone()).build();
 let projection = TyBuilder::assoc_type_projection(
  db,
  output_assoc_type,
 Some(trait_ref.substitution.clone()),
 )
 .build();
- table.register_obligation(trait_ref.cast(Interner));
-let ret_ty = table.normalize_projection_ty(projection);
-
-let ret_ty = table.resolve_completely(ret_ty);
-let args_ty = table.resolve_completely(args_ty);
 
-let params =
- args_ty.as_tuple()?.iter(Interner).map(|it| it.assert_ty_ref(Interner)).cloned().collect();
-
-Some(CallableSig::from_params_and_return(params, ret_ty,false,Safety::Safe,FnAbi::RustCall))
+let block = trait_env.block;
+let trait_env = trait_env.env.clone();
+let obligation =
+InEnvironment{goal: trait_ref.clone().cast(Interner),environment: trait_env.clone()};
+let canonical = table.canonicalize(obligation.clone());
+if db.trait_solve(krate, block, canonical.cast(Interner)).is_some(){
+ table.register_obligation(obligation.goal);
+let return_ty = table.normalize_projection_ty(projection);
+for fn_x in[FnTrait::Fn,FnTrait::FnMut,FnTrait::FnOnce]{
+let fn_x_trait = fn_x.get_id(db, krate)?;
+ trait_ref.trait_id = to_chalk_trait_id(fn_x_trait);
+let obligation: chalk_ir::InEnvironment<chalk_ir::Goal<Interner>> = InEnvironment{
+goal: trait_ref.clone().cast(Interner),
+environment: trait_env.clone(),
+};
+let canonical = table.canonicalize(obligation.clone());
+if db.trait_solve(krate, block, canonical.cast(Interner)).is_some(){
+let ret_ty = table.resolve_completely(return_ty);
+let args_ty = table.resolve_completely(args_ty);
+let params = args_ty
+.as_tuple()?
+.iter(Interner)
+.map(|it| it.assert_ty_ref(Interner))
+.cloned()
+.collect();
+
+returnSome((
+ fn_x,
+CallableSig::from_params_and_return(
+ params,
+ ret_ty,
+false,
+Safety::Safe,
+FnAbi::RustCall,
+),
+));
+}
+}
+unreachable!("It should at least implement FnOnce at this point");
+}else{
+None
+}
 }
 
 structPlaceholderCollector<'db>{

src/tools/rust-analyzer/crates/hir-ty/src/traits.rs

@@ -1,5 +1,6 @@
 //! Trait solving using Chalk.
 
+use core::fmt;
 use std::env::var;
 
 use chalk_ir::{fold::TypeFoldable,DebruijnIndex,GoalData};
@@ -209,7 +210,25 @@ pub enum FnTrait {
 Fn,
 }
 
+impl fmt::DisplayforFnTrait{
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+matchself{
+FnTrait::FnOnce => write!(f,"FnOnce"),
+FnTrait::FnMut => write!(f,"FnMut"),
+FnTrait::Fn => write!(f,"Fn"),
+}
+}
+}
+
 implFnTrait{
+pubconstfnfunction_name(&self) -> &'staticstr{
+matchself{
+FnTrait::FnOnce => "call_once",
+FnTrait::FnMut => "call_mut",
+FnTrait::Fn => "call",
+}
+}
+
 constfnlang_item(self) -> LangItem{
 matchself{
 FnTrait::FnOnce => LangItem::FnOnce,