1 files changed, 65 insertions, 22 deletions

diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index bfa7e08be..9a94ff476 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -11,7 +11,7 @@ use crate::{
         completion_item::Builder, CompletionContext, CompletionItem, CompletionItemKind,
         CompletionKind, Completions,
     },
-    display::{const_label, macro_label, type_label, FunctionSignature},
+    display::{const_label, function_declaration, macro_label, type_label},
     CompletionScore, RootDatabase,
 };
 
@@ -79,11 +79,10 @@ impl Completions {
                 return self.add_macro(ctx, Some(local_name), *mac);
             }
             ScopeDef::Unknown => {
-                return self.add(CompletionItem::new(
-                    CompletionKind::Reference,
-                    ctx.source_range(),
-                    local_name,
-                ));
+                return self.add(
+                    CompletionItem::new(CompletionKind::Reference, ctx.source_range(), local_name)
+                        .kind(CompletionItemKind::UnresolvedReference),
+                );
             }
         };
 
@@ -196,7 +195,6 @@ impl Completions {
 
         let name = local_name.unwrap_or_else(|| func.name(ctx.db).to_string());
         let ast_node = func.source(ctx.db).value;
-        let function_signature = FunctionSignature::from(&ast_node);
 
         let mut builder =
             CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.clone())
@@ -207,13 +205,14 @@ impl Completions {
                 })
                 .set_documentation(func.docs(ctx.db))
                 .set_deprecated(is_deprecated(func, ctx.db))
-                .detail(function_signature.to_string());
+                .detail(function_declaration(&ast_node));
 
-        let params = function_signature
-            .parameter_names
-            .iter()
-            .skip(if function_signature.has_self_param { 1 } else { 0 })
-            .map(|name| name.trim_start_matches('_').into())
+        let params = ast_node
+            .param_list()
+            .into_iter()
+            .flat_map(|it| it.params())
+            .flat_map(|it| it.pat())
+            .map(|pat| pat.to_string().trim_start_matches('_').into())
             .collect();
 
         builder = builder.add_call_parens(ctx, name, Params::Named(params));
@@ -316,6 +315,7 @@ impl Completions {
         }
 
         if variant_kind == StructKind::Tuple {
+            mark::hit!(inserts_parens_for_tuple_enums);
             let params = Params::Anonymous(variant.fields(ctx.db).len());
             res = res.add_call_parens(ctx, qualified_name, params)
         }
@@ -329,15 +329,10 @@ pub(crate) fn compute_score(
     ty: &Type,
     name: &str,
 ) -> Option<CompletionScore> {
-    // FIXME: this should not fall back to string equality.
-    let ty = &ty.display(ctx.db).to_string();
     let (active_name, active_type) = if let Some(record_field) = &ctx.record_field_syntax {
         mark::hit!(record_field_type_match);
         let (struct_field, _local) = ctx.sema.resolve_record_field(record_field)?;
-        (
-            struct_field.name(ctx.db).to_string(),
-            struct_field.signature_ty(ctx.db).display(ctx.db).to_string(),
-        )
+        (struct_field.name(ctx.db).to_string(), struct_field.signature_ty(ctx.db))
     } else if let Some(active_parameter) = &ctx.active_parameter {
         mark::hit!(active_param_type_match);
         (active_parameter.name.clone(), active_parameter.ty.clone())
@@ -384,10 +379,17 @@ impl Builder {
         if !ctx.config.add_call_parenthesis {
             return self;
         }
-        if ctx.use_item_syntax.is_some() || ctx.is_call {
+        if ctx.use_item_syntax.is_some() {
             mark::hit!(no_parens_in_use_item);
             return self;
         }
+        if ctx.is_pattern_call {
+            mark::hit!(dont_duplicate_pattern_parens);
+            return self;
+        }
+        if ctx.is_call {
+            return self;
+        }
 
         // Don't add parentheses if the expected type is some function reference.
         if let Some(ty) = &ctx.expected_type {
@@ -492,7 +494,7 @@ mod tests {
             }
         }
 
-        let mut completions = get_all_completion_items(ra_fixture, &CompletionConfig::default());
+        let mut completions = get_all_completion_items(CompletionConfig::default(), ra_fixture);
         completions.sort_by_key(|it| (Reverse(it.score()), it.label().to_string()));
         let actual = completions
             .into_iter()
@@ -836,6 +838,7 @@ fn bar(s: &S) {
     fn suppress_arg_snippets() {
         mark::check!(suppress_arg_snippets);
         check_edit_with_config(
+            CompletionConfig { add_call_argument_snippets: false, ..CompletionConfig::default() },
             "with_args",
             r#"
 fn with_args(x: i32, y: String) {}
@@ -845,7 +848,6 @@ fn main() { with_<|> }
 fn with_args(x: i32, y: String) {}
 fn main() { with_args($0) }
 "#,
-            &CompletionConfig { add_call_argument_snippets: false, ..CompletionConfig::default() },
         );
     }
 
@@ -866,6 +868,7 @@ fn main() { foo(${1:foo}, ${2:bar}, ${3:ho_ge_})$0 }
 
     #[test]
     fn inserts_parens_for_tuple_enums() {
+        mark::check!(inserts_parens_for_tuple_enums);
         check_edit(
             "Some",
             r#"
@@ -907,6 +910,30 @@ fn main(value: Option<i32>) {
     }
 
     #[test]
+    fn dont_duplicate_pattern_parens() {
+        mark::check!(dont_duplicate_pattern_parens);
+        check_edit(
+            "Var",
+            r#"
+enum E { Var(i32) }
+fn main() {
+    match E::Var(92) {
+        E::<|>(92) => (),
+    }
+}
+"#,
+            r#"
+enum E { Var(i32) }
+fn main() {
+    match E::Var(92) {
+        E::Var(92) => (),
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
     fn no_call_parens_if_fn_ptr_needed() {
         mark::check!(no_call_parens_if_fn_ptr_needed);
         check_edit(
@@ -1133,6 +1160,22 @@ fn go(world: &WorldSnapshot) { go(w<|>) }
     }
 
     #[test]
+    fn too_many_arguments() {
+        mark::check!(too_many_arguments);
+        check_scores(
+            r#"
+struct Foo;
+fn f(foo: &Foo) { f(foo, w<|>) }
+"#,
+            expect![[r#"
+                st Foo []
+                fn f(…) []
+                bn foo []
+            "#]],
+        );
+    }
+
+    #[test]
     fn guesses_macro_braces() {
         check_edit(
             "vec!",