1 //! Renderer for function calls.
3 use hir::{AsAssocItem, HasSource, HirDisplay};
4 use ide_db::SymbolKind;
5 use itertools::Itertools;
9 item::{CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance, ImportEdit},
11 builder_ext::Params, compute_exact_name_match, compute_ref_match, compute_type_match,
16 pub(crate) fn render_fn(
17 ctx: RenderContext<'_>,
18 import_to_add: Option<ImportEdit>,
19 local_name: Option<hir::Name>,
21 ) -> Option<CompletionItem> {
22 let _p = profile::span("render_fn");
23 Some(FunctionRender::new(ctx, None, local_name, fn_, false)?.render(import_to_add))
26 pub(crate) fn render_method(
27 ctx: RenderContext<'_>,
28 import_to_add: Option<ImportEdit>,
29 receiver: Option<hir::Name>,
30 local_name: Option<hir::Name>,
32 ) -> Option<CompletionItem> {
33 let _p = profile::span("render_method");
34 Some(FunctionRender::new(ctx, receiver, local_name, fn_, true)?.render(import_to_add))
38 struct FunctionRender<'a> {
39 ctx: RenderContext<'a>,
41 receiver: Option<hir::Name>,
47 impl<'a> FunctionRender<'a> {
49 ctx: RenderContext<'a>,
50 receiver: Option<hir::Name>,
51 local_name: Option<hir::Name>,
54 ) -> Option<FunctionRender<'a>> {
55 let name = local_name.unwrap_or_else(|| fn_.name(ctx.db())).to_string();
56 let ast_node = fn_.source(ctx.db())?.value;
58 Some(FunctionRender { ctx, name, receiver, func: fn_, ast_node, is_method })
61 fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
62 let params = self.params();
63 let call = if let Some(receiver) = &self.receiver {
64 format!("{}.{}", receiver, &self.name)
69 CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), call.clone());
70 item.kind(self.kind())
71 .set_documentation(self.ctx.docs(self.func))
73 self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
75 .detail(self.detail())
76 .add_call_parens(self.ctx.completion, call.clone(), params);
78 if import_to_add.is_none() {
79 let db = self.ctx.db();
80 if let Some(actm) = self.func.as_assoc_item(db) {
81 if let Some(trt) = actm.containing_trait_or_trait_impl(db) {
82 item.trait_name(trt.name(db).to_string());
87 item.add_import(import_to_add).lookup_by(self.name);
89 let ret_type = self.func.ret_type(self.ctx.db());
90 item.set_relevance(CompletionRelevance {
91 type_match: compute_type_match(self.ctx.completion, &ret_type),
92 exact_name_match: compute_exact_name_match(self.ctx.completion, &call),
93 ..CompletionRelevance::default()
96 if let Some(ref_match) = compute_ref_match(self.ctx.completion, &ret_type) {
98 // For now we don't properly calculate the edits for ref match
99 // completions on methods, so we've disabled them. See #8058.
101 item.ref_match(ref_match);
108 fn detail(&self) -> String {
109 let ret_ty = self.func.ret_type(self.ctx.db());
110 let ret = if ret_ty.is_unit() {
111 // Omit the return type if it is the unit type
114 format!(" {}", self.ty_display())
117 format!("fn({}){}", self.params_display(), ret)
120 fn params_display(&self) -> String {
121 if let Some(self_param) = self.func.self_param(self.ctx.db()) {
124 .assoc_fn_params(self.ctx.db())
126 .skip(1) // skip the self param because we are manually handling that
127 .map(|p| p.ty().display(self.ctx.db()).to_string());
129 std::iter::once(self_param.display(self.ctx.db()).to_owned()).chain(params).join(", ")
133 .assoc_fn_params(self.ctx.db())
135 .map(|p| p.ty().display(self.ctx.db()).to_string())
141 fn ty_display(&self) -> String {
142 let ret_ty = self.func.ret_type(self.ctx.db());
144 format!("-> {}", ret_ty.display(self.ctx.db()))
147 fn add_arg(&self, arg: &str, ty: &hir::Type) -> String {
148 if let Some(derefed_ty) = ty.remove_ref() {
149 for (name, local) in self.ctx.completion.locals.iter() {
150 if name == arg && local.ty(self.ctx.db()) == derefed_ty {
151 let mutability = if ty.is_mutable_reference() { "&mut " } else { "&" };
152 return format!("{}{}", mutability, arg);
159 fn params(&self) -> Params {
160 let ast_params = match self.ast_node.param_list() {
162 None => return Params::Named(Vec::new()),
165 let mut params_pats = Vec::new();
166 let params_ty = if self.ctx.completion.has_dot_receiver() || self.receiver.is_some() {
167 self.func.method_params(self.ctx.db()).unwrap_or_default()
169 if let Some(s) = ast_params.self_param() {
170 cov_mark::hit!(parens_for_method_call_as_assoc_fn);
171 params_pats.push(Some(s.to_string()));
173 self.func.assoc_fn_params(self.ctx.db())
176 .extend(ast_params.params().into_iter().map(|it| it.pat().map(|it| it.to_string())));
178 let params = params_pats
181 .flat_map(|(pat, param_ty)| {
184 let arg = name.trim_start_matches("mut ").trim_start_matches('_');
185 Some(self.add_arg(arg, param_ty.ty()))
188 Params::Named(params)
191 fn kind(&self) -> CompletionItemKind {
192 if self.func.self_param(self.ctx.db()).is_some() {
193 CompletionItemKind::Method
195 SymbolKind::Function.into()
203 tests::{check_edit, check_edit_with_config, TEST_CONFIG},
208 fn inserts_parens_for_function_calls() {
209 cov_mark::check!(inserts_parens_for_function_calls);
218 fn main() { no_args()$0 }
225 fn with_args(x: i32, y: String) {}
226 fn main() { with_$0 }
229 fn with_args(x: i32, y: String) {}
230 fn main() { with_args(${1:x}, ${2:y})$0 }
241 fn bar(s: &S) { s.f$0 }
248 fn bar(s: &S) { s.foo()$0 }
257 fn foo(&self, x: i32) {}
266 fn foo(&self, x: i32) {}
279 fn foo(&self, x: i32) {
287 fn foo(&self, x: i32) {
296 fn parens_for_method_call_as_assoc_fn() {
297 cov_mark::check!(parens_for_method_call_as_assoc_fn);
312 fn main() { S::foo(${1:&self})$0 }
318 fn suppress_arg_snippets() {
319 cov_mark::check!(suppress_arg_snippets);
320 check_edit_with_config(
321 CompletionConfig { add_call_argument_snippets: false, ..TEST_CONFIG },
324 fn with_args(x: i32, y: String) {}
325 fn main() { with_$0 }
328 fn with_args(x: i32, y: String) {}
329 fn main() { with_args($0) }
335 fn strips_underscores_from_args() {
339 fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {}
343 fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {}
344 fn main() { foo(${1:foo}, ${2:bar}, ${3:ho_ge_})$0 }
350 fn insert_ref_when_matching_local_in_scope() {
355 fn ref_arg(x: &Foo) {}
363 fn ref_arg(x: &Foo) {}
373 fn insert_mut_ref_when_matching_local_in_scope() {
378 fn ref_arg(x: &mut Foo) {}
386 fn ref_arg(x: &mut Foo) {}
389 ref_arg(${1:&mut x})$0
396 fn insert_ref_when_matching_local_in_scope_for_method() {
403 fn apply_foo(&self, x: &Foo) {}
416 fn apply_foo(&self, x: &Foo) {}
422 y.apply_foo(${1:&x})$0
429 fn trim_mut_keyword_in_func_completion() {
433 fn take_mutably(mut x: &i32) {}
440 fn take_mutably(mut x: &i32) {}
443 take_mutably(${1:x})$0