Allow hir::Param to refer to other entity params aside from functions

Author: Veykril

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

@@ -35,7 +35,7 @@ pub mod term_search;
 
 mod display;
 
-use std::{iter,mem::discriminant, ops::ControlFlow};
+use std::{mem::discriminant, ops::ControlFlow};
 
 use arrayvec::ArrayVec;
 use base_db::{CrateDisplayName,CrateId,CrateOrigin,FileId};
@@ -52,7 +52,6 @@ use hir_def::{
  path::ImportAlias,
  per_ns::PerNs,
  resolver::{HasResolver,Resolver},
- src::HasSourceas _,
 AssocItemId,AssocItemLoc,AttrDefId,ConstId,ConstParamId,CrateRootModuleId,DefWithBodyId,
 EnumId,EnumVariantId,ExternCrateId,FunctionId,GenericDefId,GenericParamId,HasModule,
 ImplId,InTypeConstId,ItemContainerId,LifetimeParamId,LocalFieldId,Lookup,MacroExpander,
@@ -1965,7 +1964,7 @@ impl Function {
 .enumerate()
 .map(|(idx, ty)| {
 let ty = Type{env: environment.clone(),ty: ty.clone()};
-Param{func:self, ty, idx }
+Param{func:Callee::Def(CallableDefId::FunctionId(self.id)), ty, idx }
 })
 .collect()
 }
@@ -1991,7 +1990,7 @@ impl Function {
 .skip(skip)
 .map(|(idx, ty)| {
 let ty = Type{env: environment.clone(),ty: ty.clone()};
-Param{func:self, ty, idx }
+Param{func:Callee::Def(CallableDefId::FunctionId(self.id)), ty, idx }
 })
 .collect()
 }
@@ -2037,7 +2036,7 @@ impl Function {
 .skip(skip)
 .map(|(idx, ty)| {
 let ty = Type{env: environment.clone(),ty: ty.clone()};
-Param{func:self, ty, idx }
+Param{func:Callee::Def(CallableDefId::FunctionId(self.id)), ty, idx }
 })
 .collect()
 }
@@ -2167,17 +2166,24 @@ impl From<hir_ty::Mutability> for Access {
 
 #[derive(Clone,PartialEq,Eq,Hash,Debug)]
 pubstructParam{
-func:Function,
+func:Callee,
 /// The index in parameter list, including self parameter.
 idx:usize,
 ty:Type,
 }
 
 implParam{
-pubfnparent_fn(&self) -> Function{
-self.func
+pubfnparent_fn(&self) -> Option<Function>{
+matchself.func{
+Callee::Def(CallableDefId::FunctionId(f)) => Some(f.into()),
+ _ => None,
+}
 }
 
+// pub fn parent_closure(&self) -> Option<Closure> {
+// self.func.as_ref().right().cloned()
+// }
+
 pubfnindex(&self) -> usize{
 self.idx
 }
@@ -2191,7 +2197,11 @@ impl Param {
 }
 
 pubfnas_local(&self,db:&dynHirDatabase) -> Option<Local>{
-let parent = DefWithBodyId::FunctionId(self.func.into());
+let parent = matchself.func{
+Callee::Def(CallableDefId::FunctionId(it)) => DefWithBodyId::FunctionId(it),
+Callee::Closure(closure) => db.lookup_intern_closure(closure.into()).0,
+ _ => returnNone,
+};
 let body = db.body(parent);
 ifletSome(self_param) = body.self_param.filter(|_| self.idx == 0){
 Some(Local{ parent,binding_id: self_param })
@@ -2205,18 +2215,45 @@ impl Param {
 }
 
 pubfnpattern_source(&self,db:&dynHirDatabase) -> Option<ast::Pat>{
-self.source(db).and_then(|p| p.value.pat())
+self.source(db).and_then(|p| p.value.right()?.pat())
 }
 
-pubfnsource(&self,db:&dynHirDatabase) -> Option<InFile<ast::Param>>{
-letInFile{ file_id, value } = self.func.source(db)?;
-let params = value.param_list()?;
-if params.self_param().is_some(){
- params.params().nth(self.idx.checked_sub(params.self_param().is_some()asusize)?)
-}else{
- params.params().nth(self.idx)
+pubfnsource(
+&self,
+db:&dynHirDatabase,
+) -> Option<InFile<Either<ast::SelfParam, ast::Param>>>{
+matchself.func{
+Callee::Def(CallableDefId::FunctionId(func)) => {
+letInFile{ file_id, value } = Function{id: func }.source(db)?;
+let params = value.param_list()?;
+ifletSome(self_param) = params.self_param(){
+ifletSome(idx) = self.idx.checked_sub(1asusize){
+ params.params().nth(idx).map(Either::Right)
+}else{
+Some(Either::Left(self_param))
+}
+}else{
+ params.params().nth(self.idx).map(Either::Right)
+}
+.map(|value| InFile{ file_id, value })
+}
+Callee::Closure(closure) => {
+letInternedClosure(owner, expr_id) = db.lookup_intern_closure(closure.into());
+let(_, source_map) = db.body_with_source_map(owner);
+let ast @ InFile{ file_id, value } = source_map.expr_syntax(expr_id).ok()?;
+let root = db.parse_or_expand(file_id);
+match value.to_node(&root){
+ ast::Expr::ClosureExpr(it) => it
+.param_list()?
+.params()
+.nth(self.idx)
+.map(Either::Right)
+.map(|value| InFile{file_id: ast.file_id, value }),
+ _ => None,
+}
+}
+ _ => None,
 }
-.map(|value| InFile{ file_id, value })
 }
 }
 
@@ -4919,7 +4956,7 @@ pub struct Callable {
 pub(crate)is_bound_method:bool,
 }
 
-#[derive(Debug)]
+#[derive(Copy,Clone,PartialEq,Eq,Hash,Debug)]
 enumCallee{
 Def(CallableDefId),
 Closure(ClosureId),
@@ -4960,43 +4997,15 @@ impl Callable {
 pubfnn_params(&self) -> usize{
 self.sig.params().len() - ifself.is_bound_method{1}else{0}
 }
-pubfnparams(
-&self,
-db:&dynHirDatabase,
-) -> Vec<(Option<Either<ast::SelfParam, ast::Pat>>,Type)>{
-let types = self
-.sig
+pubfnparams(&self) -> Vec<Param>{
+self.sig
 .params()
 .iter()
+.enumerate()
 .skip(ifself.is_bound_method{1}else{0})
-.map(|ty| self.ty.derived(ty.clone()));
-let map_param = |it: ast::Param| it.pat().map(Either::Right);
-let patterns = matchself.callee{
-Callee::Def(CallableDefId::FunctionId(func)) => {
-let src = func.lookup(db.upcast()).source(db.upcast());
- src.value.param_list().map(|param_list| {
- param_list
-.self_param()
-.map(|it| Some(Either::Left(it)))
-.filter(|_| !self.is_bound_method)
-.into_iter()
-.chain(param_list.params().map(map_param))
-})
-}
-Callee::Closure(closure_id) => matchclosure_source(db, closure_id){
-Some(src) => src.param_list().map(|param_list| {
- param_list
-.self_param()
-.map(|it| Some(Either::Left(it)))
-.filter(|_| !self.is_bound_method)
-.into_iter()
-.chain(param_list.params().map(map_param))
-}),
-None => None,
-},
- _ => None,
-};
- patterns.into_iter().flatten().chain(iter::repeat(None)).zip(types).collect()
+.map(|(idx, ty)| (idx,self.ty.derived(ty.clone())))
+.map(|(idx, ty)| Param{func:self.callee, idx, ty })
+.collect()
 }
 pubfnreturn_type(&self) -> Type{
 self.ty.derived(self.sig.ret().clone())
@@ -5006,18 +5015,6 @@ impl Callable {
 }
 }
 
-fnclosure_source(db:&dynHirDatabase,closure:ClosureId) -> Option<ast::ClosureExpr>{
-letInternedClosure(owner, expr_id) = db.lookup_intern_closure(closure.into());
-let(_, source_map) = db.body_with_source_map(owner);
-let ast = source_map.expr_syntax(expr_id).ok()?;
-let root = ast.file_syntax(db.upcast());
-let expr = ast.value.to_node(&root);
-match expr {
- ast::Expr::ClosureExpr(it) => Some(it),
- _ => None,
-}
-}
-
 #[derive(Clone,Debug,Eq,PartialEq)]
 pubstructLayout(Arc<TyLayout>,Arc<TargetDataLayout>);
 

src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_method_eager_lazy.rs

@@ -114,10 +114,10 @@ pub(crate) fn replace_with_eager_method(acc: &mut Assists, ctx: &AssistContext<'
 let callable = ctx.sema.resolve_method_call_as_callable(&call)?;
 let(_, receiver_ty) = callable.receiver_param(ctx.sema.db)?;
 let n_params = callable.n_params() + 1;
-let params = callable.params(ctx.sema.db);
+let params = callable.params();
 
 // FIXME: Check that the arg is of the form `() -> T`
-if !params.first()?.1.impls_fnonce(ctx.sema.db){
+if !params.first()?.ty().impls_fnonce(ctx.sema.db){
 returnNone;
 }
 

src/tools/rust-analyzer/crates/ide-assists/src/utils/suggest_name.rs

@@ -253,11 +253,8 @@ fn from_param(expr: &ast::Expr, sema: &Semantics<'_, RootDatabase>) -> Option<St
 };
 
 let(idx, _) = arg_list.args().find_position(|it| it == expr).unwrap();
-let(pat, _) = func.params(sema.db).into_iter().nth(idx)?;
-let pat = match pat? {
- either::Either::Right(pat) => pat,
- _ => returnNone,
-};
+let param = func.params().into_iter().nth(idx)?;
+let pat = param.source(sema.db)?.value.right()?.pat()?;
 let name = var_name_from_pat(&pat)?;
 normalize(&name.to_string())
 }

src/tools/rust-analyzer/crates/ide-db/src/active_parameter.rs

@@ -1,7 +1,7 @@
 //! This module provides functionality for querying callable information about a token.
 
 use either::Either;
-use hir::{Semantics,Type};
+use hir::{InFile,Semantics,Type};
 use parser::T;
 use syntax::{
  ast::{self,HasArgList,HasName},
@@ -13,7 +13,7 @@ use crate::RootDatabase;
 #[derive(Debug)]
 pubstructActiveParameter{
 pubty:Type,
-pubpat:Option<Either<ast::SelfParam, ast::Pat>>,
+pubsrc:Option<InFile<Either<ast::SelfParam, ast::Param>>>,
 }
 
 implActiveParameter{
@@ -22,18 +22,18 @@ impl ActiveParameter {
 let(signature, active_parameter) = callable_for_token(sema, token)?;
 
 let idx = active_parameter?;
-letmut params = signature.params(sema.db);
+letmut params = signature.params();
 if idx >= params.len(){
  cov_mark::hit!(too_many_arguments);
 returnNone;
 }
-let(pat, ty) = params.swap_remove(idx);
-Some(ActiveParameter{ ty, pat})
+letparam = params.swap_remove(idx);
+Some(ActiveParameter{ty: param.ty().clone(),src: param.source(sema.db)})
 }
 
 pubfnident(&self) -> Option<ast::Name>{
-self.pat.as_ref().and_then(|param| match param {
-Either::Right(ast::Pat::IdentPat(ident)) => ident.name(),
+self.src.as_ref().and_then(|param| match param.value.as_ref().right()?.pat()?{
+ ast::Pat::IdentPat(ident) => ident.name(),
  _ => None,
 })
 }

src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/format_string.rs

@@ -41,6 +41,7 @@ pub enum FormatSpecifier {
 Escape,
 }
 
+// FIXME: Remove this, we can use rustc_format_parse instead
 pubfnlex_format_specifiers(
 string:&ast::String,
 mutcallback:&mutdynFnMut(TextRange,FormatSpecifier),

src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs

@@ -24,15 +24,15 @@ pub(super) fn hints(
 
 let(callable, arg_list) = get_callable(sema,&expr)?;
 let hints = callable
-.params(sema.db)
+.params()
 .into_iter()
 .zip(arg_list.args())
-.filter_map(|((param, _ty), arg)| {
+.filter_map(|(p, arg)| {
 // Only annotate hints for expressions that exist in the original file
 let range = sema.original_range_opt(arg.syntax())?;
-let(param_name, name_syntax) = matchparam.as_ref()?{
+let(param_name, name_syntax) = matchp.source(sema.db)?.value.as_ref(){
 Either::Left(pat) => (pat.name()?, pat.name()),
-Either::Right(pat) => match pat {
+Either::Right(param) => matchparam.pat()?{
  ast::Pat::IdentPat(it) => (it.name()?, it.name()),
  _ => returnNone,
 },

src/tools/rust-analyzer/crates/ide/src/signature_help.rs

@@ -210,22 +210,25 @@ fn signature_help_for_call(
 format_to!(res.signature,"{}", self_param.display(db))
 }
 letmut buf = String::new();
-for(idx,(pat, ty))in callable.params(db).into_iter().enumerate(){
+for(idx,p)in callable.params().into_iter().enumerate(){
  buf.clear();
-ifletSome(pat) = pat {
-match pat {
-Either::Left(_self) => format_to!(buf,"self: "),
-Either::Right(pat) => format_to!(buf,"{}: ", pat),
+ifletSome(param) = p.source(sema.db){
+match param.value{
+Either::Right(param) => match param.pat(){
+Some(pat) => format_to!(buf,"{}: ", pat),
+None => format_to!(buf,"?: "),
+},
+Either::Left(_) => format_to!(buf,"self: "),
 }
 }
 // APITs (argument position `impl Trait`s) are inferred as {unknown} as the user is
 // in the middle of entering call arguments.
 // In that case, fall back to render definitions of the respective parameters.
 // This is overly conservative: we do not substitute known type vars
 // (see FIXME in tests::impl_trait) and falling back on any unknowns.
-match(ty.contains_unknown(), fn_params.as_deref()){
+match(p.ty().contains_unknown(), fn_params.as_deref()){
 (true,Some(fn_params)) => format_to!(buf,"{}", fn_params[idx].ty().display(db)),
- _ => format_to!(buf,"{}",ty.display(db)),
+ _ => format_to!(buf,"{}",p.ty().display(db)),
 }
  res.push_call_param(&buf);
 }