2 files changed, 55 insertions, 19 deletions

diff --git a/crates/completion/src/render/builder_ext.rs b/crates/completion/src/render/builder_ext.rs
index 37b0d0459..ce8718bd5 100644
--- a/crates/completion/src/render/builder_ext.rs
+++ b/crates/completion/src/render/builder_ext.rs
@@ -5,6 +5,7 @@ use test_utils::mark;
 
 use crate::{item::Builder, CompletionContext};
 
+#[derive(Debug)]
 pub(super) enum Params {
     Named(Vec<String>),
     Anonymous(usize),
@@ -24,7 +25,7 @@ impl Params {
 }
 
 impl Builder {
-    pub(super) fn should_add_parems(&self, ctx: &CompletionContext) -> bool {
+    fn should_add_parens(&self, ctx: &CompletionContext) -> bool {
         if !ctx.config.add_call_parenthesis {
             return false;
         }
@@ -58,7 +59,7 @@ impl Builder {
         name: String,
         params: Params,
     ) -> Builder {
-        if !self.should_add_parems(ctx) {
+        if !self.should_add_parens(ctx) {
             return self;
         }
 
diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs
index 542383d7e..00e3eb203 100644
--- a/crates/completion/src/render/function.rs
+++ b/crates/completion/src/render/function.rs
@@ -2,6 +2,7 @@
 
 use hir::{HasSource, Type};
 use syntax::{ast::Fn, display::function_declaration};
+use test_utils::mark;
 
 use crate::{
     item::{CompletionItem, CompletionItemKind, CompletionKind, ImportToAdd},
@@ -22,7 +23,7 @@ pub(crate) fn render_fn<'a>(
 struct FunctionRender<'a> {
     ctx: RenderContext<'a>,
     name: String,
-    fn_: hir::Function,
+    func: hir::Function,
     ast_node: Fn,
 }
 
@@ -35,15 +36,15 @@ impl<'a> FunctionRender<'a> {
         let name = local_name.unwrap_or_else(|| fn_.name(ctx.db()).to_string());
         let ast_node = fn_.source(ctx.db()).value;
 
-        FunctionRender { ctx, name, fn_, ast_node }
+        FunctionRender { ctx, name, func: fn_, ast_node }
     }
 
     fn render(self, import_to_add: Option<ImportToAdd>) -> CompletionItem {
         let params = self.params();
         CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
             .kind(self.kind())
-            .set_documentation(self.ctx.docs(self.fn_))
-            .set_deprecated(self.ctx.is_deprecated(self.fn_))
+            .set_documentation(self.ctx.docs(self.func))
+            .set_deprecated(self.ctx.is_deprecated(self.func))
             .detail(self.detail())
             .add_call_parens(self.ctx.completion, self.name, params)
             .add_import(import_to_add)
@@ -67,27 +68,39 @@ impl<'a> FunctionRender<'a> {
     }
 
     fn params(&self) -> Params {
-        let params_ty = self.fn_.params(self.ctx.db());
-        let params = self
-            .ast_node
-            .param_list()
+        let ast_params = match self.ast_node.param_list() {
+            Some(it) => it,
+            None => return Params::Named(Vec::new()),
+        };
+
+        let mut params_pats = Vec::new();
+        let params_ty = if self.ctx.completion.dot_receiver.is_some() {
+            self.func.method_params(self.ctx.db()).unwrap_or_default()
+        } else {
+            if let Some(s) = ast_params.self_param() {
+                mark::hit!(parens_for_method_call_as_assoc_fn);
+                params_pats.push(Some(s.to_string()));
+            }
+            self.func.assoc_fn_params(self.ctx.db())
+        };
+        params_pats
+            .extend(ast_params.params().into_iter().map(|it| it.pat().map(|it| it.to_string())));
+
+        let params = params_pats
             .into_iter()
-            .flat_map(|it| it.params())
             .zip(params_ty)
-            .flat_map(|(it, param_ty)| {
-                if let Some(pat) = it.pat() {
-                    let name = pat.to_string();
-                    let arg = name.trim_start_matches("mut ").trim_start_matches('_');
-                    return Some(self.add_arg(arg, param_ty.ty()));
-                }
-                None
+            .flat_map(|(pat, param_ty)| {
+                let pat = pat?;
+                let name = pat.to_string();
+                let arg = name.trim_start_matches("mut ").trim_start_matches('_');
+                Some(self.add_arg(arg, param_ty.ty()))
             })
             .collect();
         Params::Named(params)
     }
 
     fn kind(&self) -> CompletionItemKind {
-        if self.fn_.self_param(self.ctx.db()).is_some() {
+        if self.func.self_param(self.ctx.db()).is_some() {
             CompletionItemKind::Method
         } else {
             CompletionItemKind::Function
@@ -173,6 +186,28 @@ fn bar(s: &S) {
     }
 
     #[test]
+    fn parens_for_method_call_as_assoc_fn() {
+        mark::check!(parens_for_method_call_as_assoc_fn);
+        check_edit(
+            "foo",
+            r#"
+struct S;
+impl S {
+    fn foo(&self) {}
+}
+fn main() { S::f<|> }
+"#,
+            r#"
+struct S;
+impl S {
+    fn foo(&self) {}
+}
+fn main() { S::foo(${1:&self})$0 }
+"#,
+        );
+    }
+
+    #[test]
     fn suppress_arg_snippets() {
         mark::check!(suppress_arg_snippets);
         check_edit_with_config(