1 files changed, 288 insertions, 101 deletions

diff --git a/crates/ra_ide_api/src/completion/presentation.rs b/crates/ra_ide_api/src/completion/presentation.rs
index 48028a2f9..aed4ce6d4 100644
--- a/crates/ra_ide_api/src/completion/presentation.rs
+++ b/crates/ra_ide_api/src/completion/presentation.rs
@@ -1,12 +1,12 @@
 //! This modules takes care of rendering various definitions as completion items.
 
-use hir::{Docs, HasSource, HirDisplay, ScopeDef, Ty, TypeWalk};
+use hir::{db::HirDatabase, Docs, HasSource, HirDisplay, ScopeDef, Ty, TypeWalk};
 use join_to_string::join;
 use ra_syntax::ast::NameOwner;
 use test_utils::tested_by;
 
 use crate::completion::{
-    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
+    db, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
 };
 
 use crate::display::{const_label, function_label, macro_label, type_label};
@@ -44,54 +44,56 @@ impl Completions {
     ) {
         use hir::ModuleDef::*;
 
-        let mut completion_kind = CompletionKind::Reference;
-        let (kind, docs) = match resolution {
-            ScopeDef::ModuleDef(Module(it)) => (CompletionItemKind::Module, it.docs(ctx.db)),
+        let completion_kind = match resolution {
+            ScopeDef::ModuleDef(BuiltinType(..)) => CompletionKind::BuiltinType,
+            _ => CompletionKind::Reference,
+        };
+
+        let kind = match resolution {
+            ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::Module,
             ScopeDef::ModuleDef(Function(func)) => {
                 return self.add_function_with_name(ctx, Some(local_name), *func);
             }
-            ScopeDef::ModuleDef(Adt(hir::Adt::Struct(it))) => {
-                (CompletionItemKind::Struct, it.docs(ctx.db))
-            }
-            ScopeDef::ModuleDef(Adt(hir::Adt::Union(it))) => {
-                (CompletionItemKind::Struct, it.docs(ctx.db))
-            }
-            ScopeDef::ModuleDef(Adt(hir::Adt::Enum(it))) => {
-                (CompletionItemKind::Enum, it.docs(ctx.db))
-            }
-            ScopeDef::ModuleDef(EnumVariant(it)) => {
-                (CompletionItemKind::EnumVariant, it.docs(ctx.db))
-            }
-            ScopeDef::ModuleDef(Const(it)) => (CompletionItemKind::Const, it.docs(ctx.db)),
-            ScopeDef::ModuleDef(Static(it)) => (CompletionItemKind::Static, it.docs(ctx.db)),
-            ScopeDef::ModuleDef(Trait(it)) => (CompletionItemKind::Trait, it.docs(ctx.db)),
-            ScopeDef::ModuleDef(TypeAlias(it)) => (CompletionItemKind::TypeAlias, it.docs(ctx.db)),
-            ScopeDef::ModuleDef(BuiltinType(..)) => {
-                completion_kind = CompletionKind::BuiltinType;
-                (CompletionItemKind::BuiltinType, None)
-            }
-            ScopeDef::GenericParam(..) => (CompletionItemKind::TypeParam, None),
-            ScopeDef::LocalBinding(..) => (CompletionItemKind::Binding, None),
-            ScopeDef::SelfType(..) => (
-                CompletionItemKind::TypeParam, // (does this need its own kind?)
-                None,
-            ),
+            ScopeDef::ModuleDef(Adt(hir::Adt::Struct(_))) => CompletionItemKind::Struct,
+            // FIXME: add CompletionItemKind::Union
+            ScopeDef::ModuleDef(Adt(hir::Adt::Union(_))) => CompletionItemKind::Struct,
+            ScopeDef::ModuleDef(Adt(hir::Adt::Enum(_))) => CompletionItemKind::Enum,
+
+            ScopeDef::ModuleDef(EnumVariant(..)) => CompletionItemKind::EnumVariant,
+            ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::Const,
+            ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::Static,
+            ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::Trait,
+            ScopeDef::ModuleDef(TypeAlias(..)) => CompletionItemKind::TypeAlias,
+            ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType,
+            ScopeDef::GenericParam(..) => CompletionItemKind::TypeParam,
+            ScopeDef::LocalBinding(..) => CompletionItemKind::Binding,
+            // (does this need its own kind?)
+            ScopeDef::AdtSelfType(..) | ScopeDef::ImplSelfType(..) => CompletionItemKind::TypeParam,
             ScopeDef::MacroDef(mac) => {
-                self.add_macro(ctx, Some(local_name), *mac);
-                return;
+                return self.add_macro(ctx, Some(local_name), *mac);
             }
             ScopeDef::Unknown => {
-                self.add(CompletionItem::new(
+                return self.add(CompletionItem::new(
                     CompletionKind::Reference,
                     ctx.source_range(),
                     local_name,
                 ));
-                return;
             }
         };
 
+        let docs = match resolution {
+            ScopeDef::ModuleDef(Module(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(Adt(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(EnumVariant(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(Const(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(Static(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(Trait(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(TypeAlias(it)) => it.docs(ctx.db),
+            _ => None,
+        };
+
         let mut completion_item =
-            CompletionItem::new(completion_kind, ctx.source_range(), local_name);
+            CompletionItem::new(completion_kind, ctx.source_range(), local_name.clone());
         if let ScopeDef::LocalBinding(pat_id) = resolution {
             let ty = ctx
                 .analyzer
@@ -100,6 +102,28 @@ impl Completions {
                 .map(|t| t.display(ctx.db).to_string());
             completion_item = completion_item.set_detail(ty);
         };
+
+        // If not an import, add parenthesis automatically.
+        if ctx.is_path_type
+            && !ctx.has_type_args
+            && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis")
+        {
+            let generic_def: Option<hir::GenericDef> = match resolution {
+                ScopeDef::ModuleDef(Adt(it)) => Some((*it).into()),
+                ScopeDef::ModuleDef(TypeAlias(it)) => Some((*it).into()),
+                _ => None,
+            };
+            if let Some(def) = generic_def {
+                if has_non_default_type_params(def, ctx.db) {
+                    tested_by!(inserts_angle_brackets_for_generics);
+                    completion_item = completion_item
+                        .lookup_by(local_name.clone())
+                        .label(format!("{}<…>", local_name))
+                        .insert_snippet(format!("{}<$0>", local_name));
+                }
+            }
+        }
+
         completion_item.kind(kind).set_documentation(docs).add_to(self)
     }
 
@@ -107,6 +131,33 @@ impl Completions {
         self.add_function_with_name(ctx, None, func)
     }
 
+    fn guess_macro_braces(&self, macro_name: &str, docs: &str) -> &'static str {
+        let mut votes = [0, 0, 0];
+        for (idx, s) in docs.match_indices(&macro_name) {
+            let (before, after) = (&docs[..idx], &docs[idx + s.len()..]);
+            // Ensure to match the full word
+            if after.starts_with("!")
+                && before
+                    .chars()
+                    .rev()
+                    .next()
+                    .map_or(true, |c| c != '_' && !c.is_ascii_alphanumeric())
+            {
+                // It may have spaces before the braces like `foo! {}`
+                match after[1..].chars().find(|&c| !c.is_whitespace()) {
+                    Some('{') => votes[0] += 1,
+                    Some('[') => votes[1] += 1,
+                    Some('(') => votes[2] += 1,
+                    _ => {}
+                }
+            }
+        }
+
+        // Insert a space before `{}`.
+        // We prefer the last one when some votes equal.
+        *votes.iter().zip(&[" {$0}", "[$0]", "($0)"]).max_by_key(|&(&vote, _)| vote).unwrap().1
+    }
+
     pub(crate) fn add_macro(
         &mut self,
         ctx: &CompletionContext,
@@ -117,10 +168,9 @@ impl Completions {
         if let Some(name) = name {
             let detail = macro_label(&ast_node);
 
-            let macro_braces_to_insert = match name.as_str() {
-                "vec" => "[$0]",
-                _ => "($0)",
-            };
+            let docs = macro_.docs(ctx.db);
+            let macro_braces_to_insert =
+                self.guess_macro_braces(&name, docs.as_ref().map_or("", |s| s.as_str()));
             let macro_declaration = name + "!";
 
             let builder = CompletionItem::new(
@@ -129,7 +179,7 @@ impl Completions {
                 &macro_declaration,
             )
             .kind(CompletionItemKind::Macro)
-            .set_documentation(macro_.docs(ctx.db))
+            .set_documentation(docs)
             .detail(detail)
             .insert_snippet(macro_declaration + macro_braces_to_insert);
 
@@ -148,28 +198,31 @@ impl Completions {
         let ast_node = func.source(ctx.db).ast;
         let detail = function_label(&ast_node);
 
-        let mut builder = CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name)
-            .kind(if data.has_self_param() {
-                CompletionItemKind::Method
-            } else {
-                CompletionItemKind::Function
-            })
-            .set_documentation(func.docs(ctx.db))
-            .detail(detail);
-        // If not an import, add parenthesis automatically.
+        let mut builder =
+            CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.clone())
+                .kind(if data.has_self_param() {
+                    CompletionItemKind::Method
+                } else {
+                    CompletionItemKind::Function
+                })
+                .set_documentation(func.docs(ctx.db))
+                .detail(detail);
+
+        // Add `<>` for generic types
         if ctx.use_item_syntax.is_none()
             && !ctx.is_call
             && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis")
         {
             tested_by!(inserts_parens_for_function_calls);
-            let snippet =
+            let (snippet, label) =
                 if data.params().is_empty() || data.has_self_param() && data.params().len() == 1 {
-                    format!("{}()$0", data.name())
+                    (format!("{}()$0", data.name()), format!("{}()", name))
                 } else {
-                    format!("{}($0)", data.name())
+                    (format!("{}($0)", data.name()), format!("{}(…)", name))
                 };
-            builder = builder.insert_snippet(snippet);
+            builder = builder.lookup_by(name.clone()).label(label).insert_snippet(snippet);
         }
+
         self.add(builder)
     }
 
@@ -213,7 +266,6 @@ impl Completions {
             .separator(", ")
             .surround_with("(", ")")
             .to_string();
-
         CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.to_string())
             .kind(CompletionItemKind::EnumVariant)
             .set_documentation(variant.docs(ctx.db))
@@ -222,6 +274,11 @@ impl Completions {
     }
 }
 
+fn has_non_default_type_params(def: hir::GenericDef, db: &db::RootDatabase) -> bool {
+    let subst = db.generic_defaults(def);
+    subst.iter().any(|ty| ty == &Ty::Unknown)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::completion::{do_completion, CompletionItem, CompletionKind};
@@ -242,24 +299,28 @@ mod tests {
                 fn main() { no_<|> }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "main",
-        source_range: [61; 64),
-        delete: [61; 64),
-        insert: "main()$0",
-        kind: Function,
-        detail: "fn main()",
-    },
-    CompletionItem {
-        label: "no_args",
-        source_range: [61; 64),
-        delete: [61; 64),
-        insert: "no_args()$0",
-        kind: Function,
-        detail: "fn no_args()",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "main()",
+                source_range: [61; 64),
+                delete: [61; 64),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+            CompletionItem {
+                label: "no_args()",
+                source_range: [61; 64),
+                delete: [61; 64),
+                insert: "no_args()$0",
+                kind: Function,
+                lookup: "no_args",
+                detail: "fn no_args()",
+            },
+        ]
+        "###
         );
         assert_debug_snapshot!(
             do_reference_completion(
@@ -268,24 +329,28 @@ mod tests {
                 fn main() { with_<|> }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "main",
-        source_range: [80; 85),
-        delete: [80; 85),
-        insert: "main()$0",
-        kind: Function,
-        detail: "fn main()",
-    },
-    CompletionItem {
-        label: "with_args",
-        source_range: [80; 85),
-        delete: [80; 85),
-        insert: "with_args($0)",
-        kind: Function,
-        detail: "fn with_args(x: i32, y: String)",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "main()",
+                source_range: [80; 85),
+                delete: [80; 85),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+            CompletionItem {
+                label: "with_args(…)",
+                source_range: [80; 85),
+                delete: [80; 85),
+                insert: "with_args($0)",
+                kind: Function,
+                lookup: "with_args",
+                detail: "fn with_args(x: i32, y: String)",
+            },
+        ]
+        "###
         );
         assert_debug_snapshot!(
             do_reference_completion(
@@ -299,16 +364,19 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "foo",
-        source_range: [163; 164),
-        delete: [163; 164),
-        insert: "foo()$0",
-        kind: Method,
-        detail: "fn foo(&self)",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "foo()",
+                source_range: [163; 164),
+                delete: [163; 164),
+                insert: "foo()$0",
+                kind: Method,
+                lookup: "foo",
+                detail: "fn foo(&self)",
+            },
+        ]
+        "###
         );
     }
 
@@ -389,4 +457,123 @@ mod tests {
 ]"#
         );
     }
+
+    #[test]
+    fn inserts_angle_brackets_for_generics() {
+        covers!(inserts_angle_brackets_for_generics);
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Vec<T> {}
+                fn foo(xs: Ve<|>)
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Vec<…>",
+                source_range: [61; 63),
+                delete: [61; 63),
+                insert: "Vec<$0>",
+                kind: Struct,
+                lookup: "Vec",
+            },
+            CompletionItem {
+                label: "foo(…)",
+                source_range: [61; 63),
+                delete: [61; 63),
+                insert: "foo($0)",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo(xs: Ve)",
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                type Vec<T> = (T,);
+                fn foo(xs: Ve<|>)
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Vec<…>",
+                source_range: [64; 66),
+                delete: [64; 66),
+                insert: "Vec<$0>",
+                kind: TypeAlias,
+                lookup: "Vec",
+            },
+            CompletionItem {
+                label: "foo(…)",
+                source_range: [64; 66),
+                delete: [64; 66),
+                insert: "foo($0)",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo(xs: Ve)",
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Vec<T = i128> {}
+                fn foo(xs: Ve<|>)
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Vec",
+                source_range: [68; 70),
+                delete: [68; 70),
+                insert: "Vec",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "foo(…)",
+                source_range: [68; 70),
+                delete: [68; 70),
+                insert: "foo($0)",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo(xs: Ve)",
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Vec<T> {}
+                fn foo(xs: Ve<|><i128>)
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Vec",
+                source_range: [61; 63),
+                delete: [61; 63),
+                insert: "Vec",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "foo(…)",
+                source_range: [61; 63),
+                delete: [61; 63),
+                insert: "foo($0)",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo(xs: Ve<i128>)",
+            },
+        ]
+        "###
+        );
+    }
 }