1 files changed, 359 insertions, 60 deletions

diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 55f75b15a..6a6ddc7bd 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -11,7 +11,7 @@ use crate::{
         CompletionKind, Completions,
     },
     display::{const_label, macro_label, type_label, FunctionSignature},
-    RootDatabase,
+    CompletionScore, RootDatabase,
 };
 
 impl Completions {
@@ -22,16 +22,20 @@ impl Completions {
         ty: &Type,
     ) {
         let is_deprecated = is_deprecated(field, ctx.db);
-        CompletionItem::new(
-            CompletionKind::Reference,
-            ctx.source_range(),
-            field.name(ctx.db).to_string(),
-        )
-        .kind(CompletionItemKind::Field)
-        .detail(ty.display(ctx.db).to_string())
-        .set_documentation(field.docs(ctx.db))
-        .set_deprecated(is_deprecated)
-        .add_to(self);
+        let ty = ty.display(ctx.db).to_string();
+        let name = field.name(ctx.db);
+        let mut completion_item =
+            CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.to_string())
+                .kind(CompletionItemKind::Field)
+                .detail(ty.clone())
+                .set_documentation(field.docs(ctx.db))
+                .set_deprecated(is_deprecated);
+
+        if let Some(score) = compute_score(ctx, &ty, &name.to_string()) {
+            completion_item = completion_item.set_score(score);
+        }
+
+        completion_item.add_to(self);
     }
 
     pub(crate) fn add_tuple_field(&mut self, ctx: &CompletionContext, field: usize, ty: &Type) {
@@ -110,44 +114,23 @@ impl Completions {
 
         // Add `<>` for generic types
         if ctx.is_path_type && !ctx.has_type_args && ctx.config.add_call_parenthesis {
-            let has_non_default_type_params = match resolution {
-                ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(ctx.db),
-                ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(ctx.db),
-                _ => false,
-            };
-            if has_non_default_type_params {
-                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)
-    }
-
-    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.ends_with(|c: char| 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,
-                    _ => {}
+            if let Some(cap) = ctx.config.snippet_cap {
+                let has_non_default_type_params = match resolution {
+                    ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(ctx.db),
+                    ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(ctx.db),
+                    _ => false,
+                };
+                if has_non_default_type_params {
+                    tested_by!(inserts_angle_brackets_for_generics);
+                    completion_item = completion_item
+                        .lookup_by(local_name.clone())
+                        .label(format!("{}<…>", local_name))
+                        .insert_snippet(cap, format!("{}<$0>", local_name));
                 }
             }
         }
 
-        // 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
+        completion_item.kind(kind).set_documentation(docs).add_to(self)
     }
 
     pub(crate) fn add_macro(
@@ -156,6 +139,12 @@ impl Completions {
         name: Option<String>,
         macro_: hir::MacroDef,
     ) {
+        // FIXME: Currently proc-macro do not have ast-node,
+        // such that it does not have source
+        if macro_.is_proc_macro() {
+            return;
+        }
+
         let name = match name {
             Some(it) => it,
             None => return,
@@ -165,22 +154,31 @@ impl Completions {
         let detail = macro_label(&ast_node);
 
         let docs = macro_.docs(ctx.db);
-        let macro_declaration = format!("{}!", name);
 
-        let mut builder =
-            CompletionItem::new(CompletionKind::Reference, ctx.source_range(), &macro_declaration)
-                .kind(CompletionItemKind::Macro)
-                .set_documentation(docs.clone())
-                .set_deprecated(is_deprecated(macro_, ctx.db))
-                .detail(detail);
+        let mut builder = CompletionItem::new(
+            CompletionKind::Reference,
+            ctx.source_range(),
+            &format!("{}!", name),
+        )
+        .kind(CompletionItemKind::Macro)
+        .set_documentation(docs.clone())
+        .set_deprecated(is_deprecated(macro_, ctx.db))
+        .detail(detail);
 
-        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 =
-                self.guess_macro_braces(&name, docs.as_ref().map_or("", |s| s.as_str()));
-            builder.insert_snippet(macro_declaration + macro_braces_to_insert)
+        let needs_bang = ctx.use_item_syntax.is_none() && !ctx.is_macro_call;
+        builder = match ctx.config.snippet_cap {
+            Some(cap) if needs_bang => {
+                let docs = docs.as_ref().map_or("", |s| s.as_str());
+                let (bra, ket) = guess_macro_braces(&name, docs);
+                builder
+                    .insert_snippet(cap, format!("{}!{}$0{}", name, bra, ket))
+                    .label(format!("{}!{}…{}", name, bra, ket))
+            }
+            None if needs_bang => builder.insert_text(format!("{}!", name)),
+            _ => {
+                tested_by!(dont_insert_macro_call_parens_unncessary);
+                builder.insert_text(name)
+            }
         };
 
         self.add(builder);
@@ -294,6 +292,42 @@ impl Completions {
     }
 }
 
+pub(crate) fn compute_score(
+    ctx: &CompletionContext,
+    // FIXME: this definitely should be a `Type`
+    ty: &str,
+    name: &str,
+) -> Option<CompletionScore> {
+    let (active_name, active_type) = if let Some(record_field) = &ctx.record_field_syntax {
+        tested_by!(test_struct_field_completion_in_record_lit);
+        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(),
+        )
+    } else if let Some(active_parameter) = &ctx.active_parameter {
+        tested_by!(test_struct_field_completion_in_func_call);
+        (active_parameter.name.clone(), active_parameter.ty.clone())
+    } else {
+        return None;
+    };
+
+    // Compute score
+    // For the same type
+    if &active_type != ty {
+        return None;
+    }
+
+    let mut res = CompletionScore::TypeMatch;
+
+    // If same type + same name then go top position
+    if active_name == name {
+        res = CompletionScore::TypeAndNameMatch
+    }
+
+    Some(res)
+}
+
 enum Params {
     Named(Vec<String>),
     Anonymous(usize),
@@ -320,6 +354,10 @@ impl Builder {
         if ctx.use_item_syntax.is_some() || ctx.is_call {
             return self;
         }
+        let cap = match ctx.config.snippet_cap {
+            Some(it) => it,
+            None => return self,
+        };
         // If not an import, add parenthesis automatically.
         tested_by!(inserts_parens_for_function_calls);
 
@@ -341,7 +379,7 @@ impl Builder {
 
             (snippet, format!("{}(…)", name))
         };
-        self.lookup_by(name).label(label).insert_snippet(snippet)
+        self.lookup_by(name).label(label).insert_snippet(cap, snippet)
     }
 }
 
@@ -349,6 +387,34 @@ fn is_deprecated(node: impl HasAttrs, db: &RootDatabase) -> bool {
     node.attrs(db).by_key("deprecated").exists()
 }
 
+fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static 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.ends_with(|c: char| 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.
+    let (_vote, (bra, ket)) = votes
+        .iter()
+        .zip(&[(" {", "}"), ("[", "]"), ("(", ")")])
+        .max_by_key(|&(&vote, _)| vote)
+        .unwrap();
+    (*bra, *ket)
+}
+
 #[cfg(test)]
 mod tests {
     use insta::assert_debug_snapshot;
@@ -1025,4 +1091,237 @@ mod tests {
         "###
         );
     }
+
+    #[test]
+    fn test_struct_field_completion_in_func_call() {
+        covers!(test_struct_field_completion_in_func_call);
+        assert_debug_snapshot!(
+        do_reference_completion(
+                r"
+                struct A { another_field: i64, the_field: u32, my_string: String }
+                fn test(my_param: u32) -> u32 { my_param }
+                fn foo(a: A) {
+                    test(a.<|>)
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "another_field",
+                source_range: [201; 201),
+                delete: [201; 201),
+                insert: "another_field",
+                kind: Field,
+                detail: "i64",
+            },
+            CompletionItem {
+                label: "my_string",
+                source_range: [201; 201),
+                delete: [201; 201),
+                insert: "my_string",
+                kind: Field,
+                detail: "{unknown}",
+            },
+            CompletionItem {
+                label: "the_field",
+                source_range: [201; 201),
+                delete: [201; 201),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+                score: TypeMatch,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_struct_field_completion_in_func_call_with_type_and_name() {
+        assert_debug_snapshot!(
+        do_reference_completion(
+                r"
+                struct A { another_field: i64, another_good_type: u32, the_field: u32 }
+                fn test(the_field: u32) -> u32 { the_field }
+                fn foo(a: A) {
+                    test(a.<|>)
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "another_field",
+                source_range: [208; 208),
+                delete: [208; 208),
+                insert: "another_field",
+                kind: Field,
+                detail: "i64",
+            },
+            CompletionItem {
+                label: "another_good_type",
+                source_range: [208; 208),
+                delete: [208; 208),
+                insert: "another_good_type",
+                kind: Field,
+                detail: "u32",
+                score: TypeMatch,
+            },
+            CompletionItem {
+                label: "the_field",
+                source_range: [208; 208),
+                delete: [208; 208),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+                score: TypeAndNameMatch,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_struct_field_completion_in_record_lit() {
+        covers!(test_struct_field_completion_in_func_call);
+        assert_debug_snapshot!(
+        do_reference_completion(
+                r"
+                struct A { another_field: i64, another_good_type: u32, the_field: u32 }
+                struct B { my_string: String, my_vec: Vec<u32>, the_field: u32 }
+                fn foo(a: A) {
+                    let b = B {
+                        the_field: a.<|>
+                    };
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "another_field",
+                source_range: [270; 270),
+                delete: [270; 270),
+                insert: "another_field",
+                kind: Field,
+                detail: "i64",
+            },
+            CompletionItem {
+                label: "another_good_type",
+                source_range: [270; 270),
+                delete: [270; 270),
+                insert: "another_good_type",
+                kind: Field,
+                detail: "u32",
+                score: TypeMatch,
+            },
+            CompletionItem {
+                label: "the_field",
+                source_range: [270; 270),
+                delete: [270; 270),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+                score: TypeAndNameMatch,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_struct_field_completion_in_record_lit_and_fn_call() {
+        assert_debug_snapshot!(
+        do_reference_completion(
+                r"
+                struct A { another_field: i64, another_good_type: u32, the_field: u32 }
+                struct B { my_string: String, my_vec: Vec<u32>, the_field: u32 }
+                fn test(the_field: i64) -> i64 { the_field }
+                fn foo(a: A) {
+                    let b = B {
+                        the_field: test(a.<|>)
+                    };
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "another_field",
+                source_range: [336; 336),
+                delete: [336; 336),
+                insert: "another_field",
+                kind: Field,
+                detail: "i64",
+                score: TypeMatch,
+            },
+            CompletionItem {
+                label: "another_good_type",
+                source_range: [336; 336),
+                delete: [336; 336),
+                insert: "another_good_type",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "the_field",
+                source_range: [336; 336),
+                delete: [336; 336),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_struct_field_completion_in_fn_call_and_record_lit() {
+        assert_debug_snapshot!(
+        do_reference_completion(
+                r"
+                struct A { another_field: i64, another_good_type: u32, the_field: u32 }
+                struct B { my_string: String, my_vec: Vec<u32>, the_field: u32 }
+                fn test(the_field: i64) -> i64 { the_field }
+                fn foo(a: A) {
+                    test(B {
+                        the_field: a.<|>
+                    });
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "another_field",
+                source_range: [328; 328),
+                delete: [328; 328),
+                insert: "another_field",
+                kind: Field,
+                detail: "i64",
+            },
+            CompletionItem {
+                label: "another_good_type",
+                source_range: [328; 328),
+                delete: [328; 328),
+                insert: "another_good_type",
+                kind: Field,
+                detail: "u32",
+                score: TypeMatch,
+            },
+            CompletionItem {
+                label: "the_field",
+                source_range: [328; 328),
+                delete: [328; 328),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+                score: TypeAndNameMatch,
+            },
+        ]
+        "###
+        );
+    }
 }