9 files changed, 332 insertions, 190 deletions

diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 82ec16913..f433faef3 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -61,7 +61,7 @@ fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &T
                 && ctx.scope().module().map_or(true, |m| func.is_visible_from(ctx.db, m))
                 && seen_methods.insert(func.name(ctx.db))
             {
-                acc.add_function(ctx, func);
+                acc.add_function(ctx, func, None);
             }
             None::<()>
         });
diff --git a/crates/ra_ide/src/completion/complete_fn_param.rs b/crates/ra_ide/src/completion/complete_fn_param.rs
index 9226ac055..62ae5ccb4 100644
--- a/crates/ra_ide/src/completion/complete_fn_param.rs
+++ b/crates/ra_ide/src/completion/complete_fn_param.rs
@@ -18,8 +18,8 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
     for node in ctx.token.parent().ancestors() {
         match_ast! {
             match node {
-                ast::SourceFile(it) => { process(it, &mut params) },
-                ast::ItemList(it) => { process(it, &mut params) },
+                ast::SourceFile(it) => process(it, &mut params),
+                ast::ItemList(it) => process(it, &mut params),
                 _ => (),
             }
         }
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index 1e053ea4a..38f9c34e7 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -86,9 +86,9 @@ fn is_in_loop_body(leaf: &SyntaxToken) -> bool {
         }
         let loop_body = match_ast! {
             match node {
-                ast::ForExpr(it) => { it.loop_body() },
-                ast::WhileExpr(it) => { it.loop_body() },
-                ast::LoopExpr(it) => { it.loop_body() },
+                ast::ForExpr(it) => it.loop_body(),
+                ast::WhileExpr(it) => it.loop_body(),
+                ast::LoopExpr(it) => it.loop_body(),
                 _ => None,
             }
         };
diff --git a/crates/ra_ide/src/completion/complete_pattern.rs b/crates/ra_ide/src/completion/complete_pattern.rs
index bc8fade6f..1b7d3122f 100644
--- a/crates/ra_ide/src/completion/complete_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_pattern.rs
@@ -4,23 +4,25 @@ use crate::completion::{CompletionContext, Completions};
 
 /// Completes constats and paths in patterns.
 pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_pat_binding {
+    if !ctx.is_pat_binding_or_const {
         return;
     }
     // FIXME: ideally, we should look at the type we are matching against and
     // suggest variants + auto-imports
     ctx.scope().process_all_names(&mut |name, res| {
-        let def = match &res {
-            hir::ScopeDef::ModuleDef(def) => def,
+        match &res {
+            hir::ScopeDef::ModuleDef(def) => match def {
+                hir::ModuleDef::Adt(hir::Adt::Enum(..))
+                | hir::ModuleDef::Adt(hir::Adt::Struct(..))
+                | hir::ModuleDef::EnumVariant(..)
+                | hir::ModuleDef::Const(..)
+                | hir::ModuleDef::Module(..) => (),
+                _ => return,
+            },
+            hir::ScopeDef::MacroDef(_) => (),
             _ => return,
         };
-        match def {
-            hir::ModuleDef::Adt(hir::Adt::Enum(..))
-            | hir::ModuleDef::EnumVariant(..)
-            | hir::ModuleDef::Const(..)
-            | hir::ModuleDef::Module(..) => (),
-            _ => return,
-        }
+
         acc.add_resolution(ctx, name.to_string(), &res)
     });
 }
@@ -70,32 +72,12 @@ mod tests {
                 kind: Enum,
             },
             CompletionItem {
-                label: "E",
-                source_range: [246; 246),
-                delete: [246; 246),
-                insert: "E",
-                kind: Enum,
-            },
-            CompletionItem {
                 label: "X",
                 source_range: [246; 246),
                 delete: [246; 246),
                 insert: "X",
                 kind: EnumVariant,
-            },
-            CompletionItem {
-                label: "X",
-                source_range: [246; 246),
-                delete: [246; 246),
-                insert: "X",
-                kind: EnumVariant,
-            },
-            CompletionItem {
-                label: "Z",
-                source_range: [246; 246),
-                delete: [246; 246),
-                insert: "Z",
-                kind: Const,
+                detail: "()",
             },
             CompletionItem {
                 label: "Z",
@@ -111,13 +93,6 @@ mod tests {
                 insert: "m",
                 kind: Module,
             },
-            CompletionItem {
-                label: "m",
-                source_range: [246; 246),
-                delete: [246; 246),
-                insert: "m",
-                kind: Module,
-            },
         ]
         "###);
     }
@@ -146,13 +121,6 @@ mod tests {
                 kind: Enum,
             },
             CompletionItem {
-                label: "E",
-                source_range: [151; 151),
-                delete: [151; 151),
-                insert: "E",
-                kind: Enum,
-            },
-            CompletionItem {
                 label: "m!",
                 source_range: [151; 151),
                 delete: [151; 151),
diff --git a/crates/ra_ide/src/completion/complete_path.rs b/crates/ra_ide/src/completion/complete_qualified_path.rs
index 3db17f15f..d98523406 100644
--- a/crates/ra_ide/src/completion/complete_path.rs
+++ b/crates/ra_ide/src/completion/complete_qualified_path.rs
@@ -6,7 +6,7 @@ use test_utils::tested_by;
 
 use crate::completion::{CompletionContext, Completions};
 
-pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
+pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     let path = match &ctx.path_prefix {
         Some(path) => path.clone(),
         _ => return,
@@ -38,7 +38,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
         hir::ModuleDef::Adt(_) | hir::ModuleDef::TypeAlias(_) => {
             if let hir::ModuleDef::Adt(Adt::Enum(e)) = def {
                 for variant in e.variants(ctx.db) {
-                    acc.add_enum_variant(ctx, variant);
+                    acc.add_enum_variant(ctx, variant, None);
                 }
             }
             let ty = match def {
@@ -58,7 +58,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
                     match item {
                         hir::AssocItem::Function(func) => {
                             if !func.has_self_param(ctx.db) {
-                                acc.add_function(ctx, func);
+                                acc.add_function(ctx, func, None);
                             }
                         }
                         hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
@@ -87,7 +87,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
                 match item {
                     hir::AssocItem::Function(func) => {
                         if !func.has_self_param(ctx.db) {
-                            acc.add_function(ctx, func);
+                            acc.add_function(ctx, func, None);
                         }
                     }
                     hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
@@ -355,15 +355,17 @@ mod tests {
             @r###"
         [
             CompletionItem {
-                label: "Bar",
+                label: "Bar(…)",
                 source_range: [116; 116),
                 delete: [116; 116),
-                insert: "Bar",
+                insert: "Bar($0)",
                 kind: EnumVariant,
+                lookup: "Bar",
                 detail: "(i32)",
                 documentation: Documentation(
                     "Bar Variant with i32",
                 ),
+                trigger_call_info: true,
             },
             CompletionItem {
                 label: "Foo",
@@ -403,15 +405,17 @@ mod tests {
             @r###"
         [
             CompletionItem {
-                label: "Bar",
+                label: "Bar(…)",
                 source_range: [180; 180),
                 delete: [180; 180),
-                insert: "Bar",
+                insert: "Bar($0)",
                 kind: EnumVariant,
+                lookup: "Bar",
                 detail: "(i32, u32)",
                 documentation: Documentation(
                     "Bar Variant with i32 and u32",
                 ),
+                trigger_call_info: true,
             },
             CompletionItem {
                 label: "Foo",
@@ -425,15 +429,17 @@ mod tests {
                 ),
             },
             CompletionItem {
-                label: "S",
+                label: "S(…)",
                 source_range: [180; 180),
                 delete: [180; 180),
-                insert: "S",
+                insert: "S($0)",
                 kind: EnumVariant,
+                lookup: "S",
                 detail: "(S)",
                 documentation: Documentation(
                     "",
                 ),
+                trigger_call_info: true,
             },
         ]
         "###
diff --git a/crates/ra_ide/src/completion/complete_record.rs b/crates/ra_ide/src/completion/complete_record.rs
index 01dd8c6db..f46bcee5c 100644
--- a/crates/ra_ide/src/completion/complete_record.rs
+++ b/crates/ra_ide/src/completion/complete_record.rs
@@ -1,67 +1,28 @@
 //! Complete fields in record literals and patterns.
 use crate::completion::{CompletionContext, Completions};
-use ra_syntax::{ast, ast::NameOwner, SmolStr};
 
 pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let (ty, variant, already_present_fields) =
-        match (ctx.record_lit_pat.as_ref(), ctx.record_lit_syntax.as_ref()) {
-            (None, None) => return None,
-            (Some(_), Some(_)) => panic!("A record cannot be both a literal and a pattern"),
-            (Some(record_pat), _) => (
-                ctx.sema.type_of_pat(&record_pat.clone().into())?,
-                ctx.sema.resolve_record_pattern(record_pat)?,
-                pattern_ascribed_fields(record_pat),
-            ),
-            (_, Some(record_lit)) => (
-                ctx.sema.type_of_expr(&record_lit.clone().into())?,
-                ctx.sema.resolve_record_literal(record_lit)?,
-                literal_ascribed_fields(record_lit),
-            ),
-        };
+    let missing_fields = match (ctx.record_lit_pat.as_ref(), ctx.record_lit_syntax.as_ref()) {
+        (None, None) => return None,
+        (Some(_), Some(_)) => unreachable!("A record cannot be both a literal and a pattern"),
+        (Some(record_pat), _) => ctx.sema.record_pattern_missing_fields(record_pat),
+        (_, Some(record_lit)) => ctx.sema.record_literal_missing_fields(record_lit),
+    };
 
-    for (field, field_ty) in ty.variant_fields(ctx.db, variant).into_iter().filter(|(field, _)| {
-        // FIXME: already_present_names better be `Vec<hir::Name>`
-        !already_present_fields.contains(&SmolStr::from(field.name(ctx.db).to_string()))
-    }) {
-        acc.add_field(ctx, field, &field_ty);
+    for (field, ty) in missing_fields {
+        acc.add_field(ctx, field, &ty)
     }
-    Some(())
-}
-
-fn literal_ascribed_fields(record_lit: &ast::RecordLit) -> Vec<SmolStr> {
-    record_lit
-        .record_field_list()
-        .map(|field_list| field_list.fields())
-        .map(|fields| {
-            fields
-                .into_iter()
-                .filter_map(|field| field.name_ref())
-                .map(|name_ref| name_ref.text().clone())
-                .collect()
-        })
-        .unwrap_or_default()
-}
 
-fn pattern_ascribed_fields(record_pat: &ast::RecordPat) -> Vec<SmolStr> {
-    record_pat
-        .record_field_pat_list()
-        .map(|pat_list| {
-            pat_list
-                .record_field_pats()
-                .filter_map(|fild_pat| fild_pat.name())
-                .chain(pat_list.bind_pats().filter_map(|bind_pat| bind_pat.name()))
-                .map(|name| name.text().clone())
-                .collect()
-        })
-        .unwrap_or_default()
+    Some(())
 }
 
 #[cfg(test)]
 mod tests {
-    mod record_lit_tests {
-        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    mod record_pat_tests {
         use insta::assert_debug_snapshot;
 
+        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+
         fn complete(code: &str) -> Vec<CompletionItem> {
             do_completion(code, CompletionKind::Reference)
         }
@@ -203,10 +164,11 @@ mod tests {
         }
     }
 
-    mod record_pat_tests {
-        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    mod record_lit_tests {
         use insta::assert_debug_snapshot;
 
+        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+
         fn complete(code: &str) -> Vec<CompletionItem> {
             do_completion(code, CompletionKind::Reference)
         }
@@ -407,5 +369,38 @@ mod tests {
         ]
         "###);
         }
+
+        #[test]
+        fn completes_functional_update() {
+            let completions = complete(
+                r"
+            struct S {
+                foo1: u32,
+                foo2: u32,
+            }
+
+            fn main() {
+                let foo1 = 1;
+                let s = S {
+                    foo1,
+                    <|>
+                    .. loop {}
+                }
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "foo2",
+                source_range: [221; 221),
+                delete: [221; 221),
+                insert: "foo2",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
index 2ca552733..efde9bf73 100644
--- a/crates/ra_ide/src/completion/complete_scope.rs
+++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -1,19 +1,13 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 
 use crate::completion::{CompletionContext, Completions};
-use hir::{ModuleDef, ScopeDef};
 
-pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_trivial_path && !ctx.is_pat_binding_and_path {
+pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
+    if !(ctx.is_trivial_path && !ctx.is_pat_binding_or_const) {
         return;
     }
 
-    ctx.scope().process_all_names(&mut |name, res| match (ctx.is_pat_binding_and_path, &res) {
-        (true, ScopeDef::ModuleDef(ModuleDef::Function(..))) => (),
-        (true, ScopeDef::ModuleDef(ModuleDef::Static(..))) => (),
-        (true, ScopeDef::Local(..)) => (),
-        _ => acc.add_resolution(ctx, name.to_string(), &res),
-    });
+    ctx.scope().process_all_names(&mut |name, res| acc.add_resolution(ctx, name.to_string(), &res));
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index fdc0da2c5..f833d2a9a 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -35,10 +35,7 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) is_param: bool,
     /// If a name-binding or reference to a const in a pattern.
     /// Irrefutable patterns (like let) are excluded.
-    pub(super) is_pat_binding: bool,
-    // A bind battern which may also be part of a path.
-    // if let Some(En<|>) = Some(Enum::A)
-    pub(super) is_pat_binding_and_path: bool,
+    pub(super) is_pat_binding_or_const: bool,
     /// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
     pub(super) is_trivial_path: bool,
     /// If not a trivial path, the prefix (qualifier).
@@ -53,6 +50,8 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) dot_receiver_is_ambiguous_float_literal: bool,
     /// If this is a call (method or function) in particular, i.e. the () are already there.
     pub(super) is_call: bool,
+    /// If this is a macro call, i.e. the () are already there.
+    pub(super) is_macro_call: bool,
     pub(super) is_path_type: bool,
     pub(super) has_type_args: bool,
 }
@@ -97,8 +96,7 @@ impl<'a> CompletionContext<'a> {
             record_lit_pat: None,
             impl_def: None,
             is_param: false,
-            is_pat_binding: false,
-            is_pat_binding_and_path: false,
+            is_pat_binding_or_const: false,
             is_trivial_path: false,
             path_prefix: None,
             after_if: false,
@@ -106,6 +104,7 @@ impl<'a> CompletionContext<'a> {
             is_new_item: false,
             dot_receiver: None,
             is_call: false,
+            is_macro_call: false,
             is_path_type: false,
             has_type_args: false,
             dot_receiver_is_ambiguous_float_literal: false,
@@ -190,18 +189,19 @@ impl<'a> CompletionContext<'a> {
         // suggest declaration names, see `CompletionKind::Magic`.
         if let Some(name) = find_node_at_offset::<ast::Name>(&file_with_fake_ident, offset) {
             if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) {
-                let parent = bind_pat.syntax().parent();
-                if parent.clone().and_then(ast::MatchArm::cast).is_some()
-                    || parent.clone().and_then(ast::Condition::cast).is_some()
-                {
-                    self.is_pat_binding = true;
+                self.is_pat_binding_or_const = true;
+                if bind_pat.has_at() || bind_pat.is_ref() || bind_pat.is_mutable() {
+                    self.is_pat_binding_or_const = false;
                 }
-
-                if parent.and_then(ast::RecordFieldPatList::cast).is_none()
-                    && bind_pat.pat().is_none()
-                    && !bind_pat.is_ref()
-                {
-                    self.is_pat_binding_and_path = true;
+                if bind_pat.syntax().parent().and_then(ast::RecordFieldPatList::cast).is_some() {
+                    self.is_pat_binding_or_const = false;
+                }
+                if let Some(let_stmt) = bind_pat.syntax().ancestors().find_map(ast::LetStmt::cast) {
+                    if let Some(pat) = let_stmt.pat() {
+                        if bind_pat.syntax().text_range().is_subrange(&pat.syntax().text_range()) {
+                            self.is_pat_binding_or_const = false;
+                        }
+                    }
                 }
             }
             if is_node::<ast::Param>(name.syntax()) {
@@ -272,6 +272,7 @@ impl<'a> CompletionContext<'a> {
                 .and_then(ast::PathExpr::cast)
                 .and_then(|it| it.syntax().parent().and_then(ast::CallExpr::cast))
                 .is_some();
+            self.is_macro_call = path.syntax().parent().and_then(ast::MacroCall::cast).is_some();
 
             self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
             self.has_type_args = segment.type_arg_list().is_some();
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 1c7c0924d..55f75b15a 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -7,7 +7,8 @@ use test_utils::tested_by;
 
 use crate::{
     completion::{
-        CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
+        completion_item::Builder, CompletionContext, CompletionItem, CompletionItemKind,
+        CompletionKind, Completions,
     },
     display::{const_label, macro_label, type_label, FunctionSignature},
     RootDatabase,
@@ -56,14 +57,16 @@ impl Completions {
         let kind = match resolution {
             ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::Module,
             ScopeDef::ModuleDef(Function(func)) => {
-                return self.add_function_with_name(ctx, Some(local_name), *func);
+                return self.add_function(ctx, *func, Some(local_name));
             }
             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(EnumVariant(var)) => {
+                return self.add_enum_variant(ctx, *var, Some(local_name));
+            }
             ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::Const,
             ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::Static,
             ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::Trait,
@@ -124,10 +127,6 @@ impl Completions {
         completion_item.kind(kind).set_documentation(docs).add_to(self)
     }
 
-    pub(crate) fn add_function(&mut self, ctx: &CompletionContext, func: hir::Function) {
-        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) {
@@ -175,7 +174,8 @@ impl Completions {
                 .set_deprecated(is_deprecated(macro_, ctx.db))
                 .detail(detail);
 
-        builder = if ctx.use_item_syntax.is_some() {
+        builder = if ctx.use_item_syntax.is_some() || ctx.is_macro_call {
+            tested_by!(dont_insert_macro_call_parens_unncessary);
             builder.insert_text(name)
         } else {
             let macro_braces_to_insert =
@@ -186,16 +186,15 @@ impl Completions {
         self.add(builder);
     }
 
-    fn add_function_with_name(
+    pub(crate) fn add_function(
         &mut self,
         ctx: &CompletionContext,
-        name: Option<String>,
         func: hir::Function,
+        local_name: Option<String>,
     ) {
         let has_self_param = func.has_self_param(ctx.db);
-        let params = func.params(ctx.db);
 
-        let name = name.unwrap_or_else(|| func.name(ctx.db).to_string());
+        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);
 
@@ -210,32 +209,14 @@ impl Completions {
                 .set_deprecated(is_deprecated(func, ctx.db))
                 .detail(function_signature.to_string());
 
-        // If not an import, add parenthesis automatically.
-        if ctx.use_item_syntax.is_none() && !ctx.is_call && ctx.config.add_call_parenthesis {
-            tested_by!(inserts_parens_for_function_calls);
-
-            let (snippet, label) = if params.is_empty() || has_self_param && params.len() == 1 {
-                (format!("{}()$0", name), format!("{}()", name))
-            } else {
-                builder = builder.trigger_call_info();
-                let snippet = if ctx.config.add_call_argument_snippets {
-                    let to_skip = if has_self_param { 1 } else { 0 };
-                    let function_params_snippet = function_signature
-                        .parameter_names
-                        .iter()
-                        .skip(to_skip)
-                        .enumerate()
-                        .map(|(index, param_name)| format!("${{{}:{}}}", index + 1, param_name))
-                        .sep_by(", ");
-                    format!("{}({})$0", name, function_params_snippet)
-                } else {
-                    format!("{}($0)", name)
-                };
+        let params = function_signature
+            .parameter_names
+            .iter()
+            .skip(if function_signature.has_self_param { 1 } else { 0 })
+            .cloned()
+            .collect();
 
-                (snippet, format!("{}(…)", name))
-            };
-            builder = builder.lookup_by(name).label(label).insert_snippet(snippet);
-        }
+        builder = builder.add_call_parens(ctx, name, Params::Named(params));
 
         self.add(builder)
     }
@@ -272,14 +253,20 @@ impl Completions {
             .add_to(self);
     }
 
-    pub(crate) fn add_enum_variant(&mut self, ctx: &CompletionContext, variant: hir::EnumVariant) {
+    pub(crate) fn add_enum_variant(
+        &mut self,
+        ctx: &CompletionContext,
+        variant: hir::EnumVariant,
+        local_name: Option<String>,
+    ) {
         let is_deprecated = is_deprecated(variant, ctx.db);
-        let name = variant.name(ctx.db);
+        let name = local_name.unwrap_or_else(|| variant.name(ctx.db).to_string());
         let detail_types = variant
             .fields(ctx.db)
             .into_iter()
             .map(|field| (field.name(ctx.db), field.signature_ty(ctx.db)));
-        let detail = match variant.kind(ctx.db) {
+        let variant_kind = variant.kind(ctx.db);
+        let detail = match variant_kind {
             StructKind::Tuple | StructKind::Unit => detail_types
                 .map(|(_, t)| t.display(ctx.db).to_string())
                 .sep_by(", ")
@@ -291,12 +278,70 @@ impl Completions {
                 .surround_with("{ ", " }")
                 .to_string(),
         };
-        CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.to_string())
-            .kind(CompletionItemKind::EnumVariant)
-            .set_documentation(variant.docs(ctx.db))
-            .set_deprecated(is_deprecated)
-            .detail(detail)
-            .add_to(self);
+        let mut res =
+            CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.clone())
+                .kind(CompletionItemKind::EnumVariant)
+                .set_documentation(variant.docs(ctx.db))
+                .set_deprecated(is_deprecated)
+                .detail(detail);
+
+        if variant_kind == StructKind::Tuple {
+            let params = Params::Anonymous(variant.fields(ctx.db).len());
+            res = res.add_call_parens(ctx, name, params)
+        }
+
+        res.add_to(self);
+    }
+}
+
+enum Params {
+    Named(Vec<String>),
+    Anonymous(usize),
+}
+
+impl Params {
+    fn len(&self) -> usize {
+        match self {
+            Params::Named(xs) => xs.len(),
+            Params::Anonymous(len) => *len,
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl Builder {
+    fn add_call_parens(mut self, ctx: &CompletionContext, name: String, params: Params) -> Builder {
+        if !ctx.config.add_call_parenthesis {
+            return self;
+        }
+        if ctx.use_item_syntax.is_some() || ctx.is_call {
+            return self;
+        }
+        // If not an import, add parenthesis automatically.
+        tested_by!(inserts_parens_for_function_calls);
+
+        let (snippet, label) = if params.is_empty() {
+            (format!("{}()$0", name), format!("{}()", name))
+        } else {
+            self = self.trigger_call_info();
+            let snippet = match (ctx.config.add_call_argument_snippets, params) {
+                (true, Params::Named(params)) => {
+                    let function_params_snippet = params
+                        .iter()
+                        .enumerate()
+                        .map(|(index, param_name)| format!("${{{}:{}}}", index + 1, param_name))
+                        .sep_by(", ");
+                    format!("{}({})$0", name, function_params_snippet)
+                }
+                _ => format!("{}($0)", name),
+            };
+
+            (snippet, format!("{}(…)", name))
+        };
+        self.lookup_by(name).label(label).insert_snippet(snippet)
     }
 }
 
@@ -366,12 +411,14 @@ mod tests {
         @r###"
         [
             CompletionItem {
-                label: "Foo",
+                label: "Foo(…)",
                 source_range: [115; 117),
                 delete: [115; 117),
-                insert: "Foo",
+                insert: "Foo($0)",
                 kind: EnumVariant,
+                lookup: "Foo",
                 detail: "(i32, i32)",
+                trigger_call_info: true,
             },
         ]"###
         );
@@ -546,6 +593,101 @@ mod tests {
     }
 
     #[test]
+    fn inserts_parens_for_tuple_enums() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum Option<T> { Some(T), None }
+                use Option::*;
+                fn main() -> Option<i32> {
+                    Som<|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "None",
+                source_range: [144; 147),
+                delete: [144; 147),
+                insert: "None",
+                kind: EnumVariant,
+                detail: "()",
+            },
+            CompletionItem {
+                label: "Option",
+                source_range: [144; 147),
+                delete: [144; 147),
+                insert: "Option",
+                kind: Enum,
+            },
+            CompletionItem {
+                label: "Some(…)",
+                source_range: [144; 147),
+                delete: [144; 147),
+                insert: "Some($0)",
+                kind: EnumVariant,
+                lookup: "Some",
+                detail: "(T)",
+                trigger_call_info: true,
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [144; 147),
+                delete: [144; 147),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main() -> Option<i32>",
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum Option<T> { Some(T), None }
+                use Option::*;
+                fn main(value: Option<i32>) {
+                    match value {
+                        Som<|>
+                    }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "None",
+                source_range: [185; 188),
+                delete: [185; 188),
+                insert: "None",
+                kind: EnumVariant,
+                detail: "()",
+            },
+            CompletionItem {
+                label: "Option",
+                source_range: [185; 188),
+                delete: [185; 188),
+                insert: "Option",
+                kind: Enum,
+            },
+            CompletionItem {
+                label: "Some(…)",
+                source_range: [185; 188),
+                delete: [185; 188),
+                insert: "Some($0)",
+                kind: EnumVariant,
+                lookup: "Some",
+                detail: "(T)",
+                trigger_call_info: true,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
     fn arg_snippets_for_method_call() {
         assert_debug_snapshot!(
             do_reference_completion(
@@ -819,7 +961,8 @@ mod tests {
     }
 
     #[test]
-    fn dont_insert_macro_call_braces_in_use() {
+    fn dont_insert_macro_call_parens_unncessary() {
+        covers!(dont_insert_macro_call_parens_unncessary);
         assert_debug_snapshot!(
             do_reference_completion(
                 r"
@@ -845,6 +988,41 @@ mod tests {
             },
         ]
         "###
-        )
+        );
+
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                //- /main.rs
+                macro_rules frobnicate {
+                    () => ()
+                }
+                fn main() {
+                    frob<|>!();
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "frobnicate!",
+                source_range: [56; 60),
+                delete: [56; 60),
+                insert: "frobnicate",
+                kind: Macro,
+                detail: "macro_rules! frobnicate",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [56; 60),
+                delete: [56; 60),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
     }
 }