15 files changed, 556 insertions, 109 deletions

diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index f95b6baf3..5da254a6e 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -19,10 +19,24 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
     call_info_for_token(&sema, token)
 }
 
-pub(crate) fn call_info_for_token(
-    sema: &Semantics<RootDatabase>,
-    token: SyntaxToken,
-) -> Option<CallInfo> {
+#[derive(Debug)]
+pub(crate) struct ActiveParameter {
+    /// FIXME: should be `Type` and `Name
+    pub(crate) ty: String,
+    pub(crate) name: String,
+}
+
+impl ActiveParameter {
+    pub(crate) fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> {
+        call_info(db, position)?.into_active_parameter()
+    }
+
+    pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
+        call_info_for_token(sema, token)?.into_active_parameter()
+    }
+}
+
+fn call_info_for_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<CallInfo> {
     // Find the calling expression and it's NameRef
     let calling_node = FnCallNode::with_node(&token.parent())?;
 
@@ -160,6 +174,14 @@ impl FnCallNode {
 }
 
 impl CallInfo {
+    fn into_active_parameter(self) -> Option<ActiveParameter> {
+        let idx = self.active_parameter?;
+        let ty = self.signature.parameter_types.get(idx)?.clone();
+        let name = self.signature.parameter_names.get(idx)?.clone();
+        let res = ActiveParameter { ty, name };
+        Some(res)
+    }
+
     fn with_fn(db: &RootDatabase, function: hir::Function) -> Self {
         let signature = FunctionSignature::from_hir(db, function);
 
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index 4a1a2a04a..f0e02180b 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -1,5 +1,6 @@
 //! FIXME: write short doc here
 
+mod completion_config;
 mod completion_item;
 mod completion_context;
 mod presentation;
@@ -28,27 +29,11 @@ use crate::{
     FilePosition,
 };
 
-pub use crate::completion::completion_item::{
-    CompletionItem, CompletionItemKind, InsertTextFormat,
+pub use crate::completion::{
+    completion_config::CompletionConfig,
+    completion_item::{CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat},
 };
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct CompletionConfig {
-    pub enable_postfix_completions: bool,
-    pub add_call_parenthesis: bool,
-    pub add_call_argument_snippets: bool,
-}
-
-impl Default for CompletionConfig {
-    fn default() -> Self {
-        CompletionConfig {
-            enable_postfix_completions: true,
-            add_call_parenthesis: true,
-            add_call_argument_snippets: true,
-        }
-    }
-}
-
 /// Main entry point for completion. We run completion as a two-phase process.
 ///
 /// First, we look at the position and collect a so-called `CompletionContext.
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index f433faef3..b93153b48 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -2,9 +2,11 @@
 
 use hir::{HasVisibility, Type};
 
-use crate::completion::completion_item::CompletionKind;
 use crate::{
-    completion::{completion_context::CompletionContext, completion_item::Completions},
+    completion::{
+        completion_context::CompletionContext,
+        completion_item::{CompletionKind, Completions},
+    },
     CompletionItem,
 };
 use rustc_hash::FxHashSet;
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index 38f9c34e7..adefb290e 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -42,10 +42,14 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
 }
 
 fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
-    CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
-        .kind(CompletionItemKind::Keyword)
-        .insert_snippet(snippet)
-        .build()
+    let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
+        .kind(CompletionItemKind::Keyword);
+
+    match ctx.config.snippet_cap {
+        Some(cap) => res.insert_snippet(cap, snippet),
+        _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
+    }
+    .build()
 }
 
 pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 29c2881c6..8d397b0fe 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -6,6 +6,7 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEdit;
 
+use super::completion_config::SnippetCap;
 use crate::{
     completion::{
         completion_context::CompletionContext,
@@ -32,9 +33,15 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         None => return,
     };
 
+    let cap = match ctx.config.snippet_cap {
+        Some(it) => it,
+        None => return,
+    };
+
     if receiver_ty.is_bool() || receiver_ty.is_unknown() {
         postfix_snippet(
             ctx,
+            cap,
             &dot_receiver,
             "if",
             "if expr {}",
@@ -43,6 +50,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         .add_to(acc);
         postfix_snippet(
             ctx,
+            cap,
             &dot_receiver,
             "while",
             "while expr {}",
@@ -52,11 +60,20 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     }
 
     // !&&&42 is a compiler error, ergo process it before considering the references
-    postfix_snippet(ctx, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
+    postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
+        .add_to(acc);
 
-    postfix_snippet(ctx, &dot_receiver, "ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
-    postfix_snippet(ctx, &dot_receiver, "refm", "&mut expr", &format!("&mut {}", receiver_text))
+    postfix_snippet(ctx, cap, &dot_receiver, "ref", "&expr", &format!("&{}", receiver_text))
         .add_to(acc);
+    postfix_snippet(
+        ctx,
+        cap,
+        &dot_receiver,
+        "refm",
+        "&mut expr",
+        &format!("&mut {}", receiver_text),
+    )
+    .add_to(acc);
 
     // The rest of the postfix completions create an expression that moves an argument,
     // so it's better to consider references now to avoid breaking the compilation
@@ -66,6 +83,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
 
     postfix_snippet(
         ctx,
+        cap,
         &dot_receiver,
         "match",
         "match expr {}",
@@ -75,6 +93,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
 
     postfix_snippet(
         ctx,
+        cap,
         &dot_receiver,
         "box",
         "Box::new(expr)",
@@ -82,8 +101,15 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     )
     .add_to(acc);
 
-    postfix_snippet(ctx, &dot_receiver, "dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text))
-        .add_to(acc);
+    postfix_snippet(
+        ctx,
+        cap,
+        &dot_receiver,
+        "dbg",
+        "dbg!(expr)",
+        &format!("dbg!({})", receiver_text),
+    )
+    .add_to(acc);
 }
 
 fn get_receiver_text(receiver: &ast::Expr, receiver_is_ambiguous_float_literal: bool) -> String {
@@ -108,6 +134,7 @@ fn include_references(initial_element: &ast::Expr) -> ast::Expr {
 
 fn postfix_snippet(
     ctx: &CompletionContext,
+    cap: SnippetCap,
     receiver: &ast::Expr,
     label: &str,
     detail: &str,
@@ -121,7 +148,7 @@ fn postfix_snippet(
     };
     CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
         .detail(detail)
-        .snippet_edit(edit)
+        .snippet_edit(cap, edit)
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide/src/completion/complete_snippet.rs b/crates/ra_ide/src/completion/complete_snippet.rs
index f731e9b9a..4bccfbfed 100644
--- a/crates/ra_ide/src/completion/complete_snippet.rs
+++ b/crates/ra_ide/src/completion/complete_snippet.rs
@@ -1,13 +1,13 @@
 //! FIXME: write short doc here
 
 use crate::completion::{
-    completion_item::Builder, CompletionContext, CompletionItem, CompletionItemKind,
-    CompletionKind, Completions,
+    completion_config::SnippetCap, completion_item::Builder, CompletionContext, CompletionItem,
+    CompletionItemKind, CompletionKind, Completions,
 };
 
-fn snippet(ctx: &CompletionContext, label: &str, snippet: &str) -> Builder {
+fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str) -> Builder {
     CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label)
-        .insert_snippet(snippet)
+        .insert_snippet(cap, snippet)
         .kind(CompletionItemKind::Snippet)
 }
 
@@ -15,17 +15,27 @@ pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionConte
     if !(ctx.is_trivial_path && ctx.function_syntax.is_some()) {
         return;
     }
+    let cap = match ctx.config.snippet_cap {
+        Some(it) => it,
+        None => return,
+    };
 
-    snippet(ctx, "pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
-    snippet(ctx, "ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
+    snippet(ctx, cap, "pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
+    snippet(ctx, cap, "ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
 }
 
 pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.is_new_item {
         return;
     }
+    let cap = match ctx.config.snippet_cap {
+        Some(it) => it,
+        None => return,
+    };
+
     snippet(
         ctx,
+        cap,
         "Test function",
         "\
 #[test]
@@ -36,8 +46,8 @@ fn ${1:feature}() {
     .lookup_by("tfn")
     .add_to(acc);
 
-    snippet(ctx, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}").add_to(acc);
-    snippet(ctx, "pub(crate)", "pub(crate) $0").add_to(acc);
+    snippet(ctx, cap, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}").add_to(acc);
+    snippet(ctx, cap, "pub(crate)", "pub(crate) $0").add_to(acc);
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index 2ec0e7ce9..c39943252 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -122,7 +122,7 @@ fn add_function_impl(
     ctx: &CompletionContext,
     func: &hir::Function,
 ) {
-    let display = FunctionSignature::from_hir(ctx.db, *func);
+    let signature = FunctionSignature::from_hir(ctx.db, *func);
 
     let fn_name = func.name(ctx.db).to_string();
 
@@ -141,12 +141,20 @@ fn add_function_impl(
     } else {
         CompletionItemKind::Function
     };
-
-    let snippet = format!("{} {{\n    $0\n}}", display);
-
     let range = TextRange::from_to(fn_def_node.text_range().start(), ctx.source_range().end());
 
-    builder.snippet_edit(TextEdit::replace(range, snippet)).kind(completion_kind).add_to(acc);
+    match ctx.config.snippet_cap {
+        Some(cap) => {
+            let snippet = format!("{} {{\n    $0\n}}", signature);
+            builder.snippet_edit(cap, TextEdit::replace(range, snippet))
+        }
+        None => {
+            let header = format!("{} {{", signature);
+            builder.text_edit(TextEdit::replace(range, header))
+        }
+    }
+    .kind(completion_kind)
+    .add_to(acc);
 }
 
 fn add_type_alias_impl(
diff --git a/crates/ra_ide/src/completion/completion_config.rs b/crates/ra_ide/src/completion/completion_config.rs
new file mode 100644
index 000000000..71b49ace8
--- /dev/null
+++ b/crates/ra_ide/src/completion/completion_config.rs
@@ -0,0 +1,35 @@
+//! Settings for tweaking completion.
+//!
+//! The fun thing here is `SnippetCap` -- this type can only be created in this
+//! module, and we use to statically check that we only produce snippet
+//! completions if we are allowed to.
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CompletionConfig {
+    pub enable_postfix_completions: bool,
+    pub add_call_parenthesis: bool,
+    pub add_call_argument_snippets: bool,
+    pub snippet_cap: Option<SnippetCap>,
+}
+
+impl CompletionConfig {
+    pub fn allow_snippets(&mut self, yes: bool) {
+        self.snippet_cap = if yes { Some(SnippetCap { _private: () }) } else { None }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SnippetCap {
+    _private: (),
+}
+
+impl Default for CompletionConfig {
+    fn default() -> Self {
+        CompletionConfig {
+            enable_postfix_completions: true,
+            add_call_parenthesis: true,
+            add_call_argument_snippets: true,
+            snippet_cap: Some(SnippetCap { _private: () }),
+        }
+    }
+}
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index cfc5c34df..a76d1ce45 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 };
 use ra_text_edit::AtomTextEdit;
 
-use crate::{completion::CompletionConfig, FilePosition};
+use crate::{call_info::ActiveParameter, completion::CompletionConfig, FilePosition};
 
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
@@ -31,7 +31,10 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) use_item_syntax: Option<ast::UseItem>,
     pub(super) record_lit_syntax: Option<ast::RecordLit>,
     pub(super) record_pat_syntax: Option<ast::RecordPat>,
+    pub(super) record_field_syntax: Option<ast::RecordField>,
     pub(super) impl_def: Option<ast::ImplDef>,
+    /// FIXME: `ActiveParameter` is string-based, which is very wrong
+    pub(super) active_parameter: Option<ActiveParameter>,
     pub(super) is_param: bool,
     /// If a name-binding or reference to a const in a pattern.
     /// Irrefutable patterns (like let) are excluded.
@@ -94,7 +97,9 @@ impl<'a> CompletionContext<'a> {
             use_item_syntax: None,
             record_lit_syntax: None,
             record_pat_syntax: None,
+            record_field_syntax: None,
             impl_def: None,
+            active_parameter: ActiveParameter::at(db, position),
             is_param: false,
             is_pat_binding_or_const: false,
             is_trivial_path: false,
@@ -279,6 +284,14 @@ impl<'a> CompletionContext<'a> {
             .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
             .find_map(ast::FnDef::cast);
 
+        self.record_field_syntax = self
+            .sema
+            .ancestors_with_macros(self.token.parent())
+            .take_while(|it| {
+                it.kind() != SOURCE_FILE && it.kind() != MODULE && it.kind() != CALL_EXPR
+            })
+            .find_map(ast::RecordField::cast);
+
         let parent = match name_ref.syntax().parent() {
             Some(it) => it,
             None => return,
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index bc0f1aff5..fb06cc125 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -2,6 +2,7 @@
 
 use std::fmt;
 
+use super::completion_config::SnippetCap;
 use hir::Documentation;
 use ra_syntax::TextRange;
 use ra_text_edit::TextEdit;
@@ -51,6 +52,9 @@ pub struct CompletionItem {
     /// If completing a function call, ask the editor to show parameter popup
     /// after completion.
     trigger_call_info: bool,
+
+    /// Score is useful to pre select or display in better order completion items
+    score: Option<CompletionScore>,
 }
 
 // We use custom debug for CompletionItem to make `insta`'s diffs more readable.
@@ -80,6 +84,9 @@ impl fmt::Debug for CompletionItem {
         if self.deprecated {
             s.field("deprecated", &true);
         }
+        if let Some(score) = &self.score {
+            s.field("score", score);
+        }
         if self.trigger_call_info {
             s.field("trigger_call_info", &true);
         }
@@ -87,6 +94,14 @@ impl fmt::Debug for CompletionItem {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum CompletionScore {
+    /// If only type match
+    TypeMatch,
+    /// If type and name match
+    TypeAndNameMatch,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CompletionItemKind {
     Snippet,
@@ -147,6 +162,7 @@ impl CompletionItem {
             text_edit: None,
             deprecated: None,
             trigger_call_info: None,
+            score: None,
         }
     }
     /// What user sees in pop-up in the UI.
@@ -175,7 +191,7 @@ impl CompletionItem {
     }
     /// What string is used for filtering.
     pub fn lookup(&self) -> &str {
-        self.lookup.as_deref().unwrap_or_else(|| self.label())
+        self.lookup.as_deref().unwrap_or(&self.label)
     }
 
     pub fn kind(&self) -> Option<CompletionItemKind> {
@@ -186,6 +202,10 @@ impl CompletionItem {
         self.deprecated
     }
 
+    pub fn score(&self) -> Option<CompletionScore> {
+        self.score
+    }
+
     pub fn trigger_call_info(&self) -> bool {
         self.trigger_call_info
     }
@@ -206,6 +226,7 @@ pub(crate) struct Builder {
     text_edit: Option<TextEdit>,
     deprecated: Option<bool>,
     trigger_call_info: Option<bool>,
+    score: Option<CompletionScore>,
 }
 
 impl Builder {
@@ -235,6 +256,7 @@ impl Builder {
             completion_kind: self.completion_kind,
             deprecated: self.deprecated.unwrap_or(false),
             trigger_call_info: self.trigger_call_info.unwrap_or(false),
+            score: self.score,
         }
     }
     pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder {
@@ -249,7 +271,11 @@ impl Builder {
         self.insert_text = Some(insert_text.into());
         self
     }
-    pub(crate) fn insert_snippet(mut self, snippet: impl Into<String>) -> Builder {
+    pub(crate) fn insert_snippet(
+        mut self,
+        _cap: SnippetCap,
+        snippet: impl Into<String>,
+    ) -> Builder {
         self.insert_text_format = InsertTextFormat::Snippet;
         self.insert_text(snippet)
     }
@@ -261,7 +287,7 @@ impl Builder {
         self.text_edit = Some(edit);
         self
     }
-    pub(crate) fn snippet_edit(mut self, edit: TextEdit) -> Builder {
+    pub(crate) fn snippet_edit(mut self, _cap: SnippetCap, edit: TextEdit) -> Builder {
         self.insert_text_format = InsertTextFormat::Snippet;
         self.text_edit(edit)
     }
@@ -285,6 +311,10 @@ impl Builder {
         self.deprecated = Some(deprecated);
         self
     }
+    pub(crate) fn set_score(mut self, score: CompletionScore) -> Builder {
+        self.score = Some(score);
+        self
+    }
     pub(crate) fn trigger_call_info(mut self) -> Builder {
         self.trigger_call_info = Some(true);
         self
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 2189cef65..5e2b8b920 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,17 +114,19 @@ 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));
+            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));
+                }
             }
         }
 
@@ -180,13 +186,16 @@ impl Completions {
                 .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)
+        builder = match ctx.config.snippet_cap {
+            Some(cap) if ctx.use_item_syntax.is_none() && !ctx.is_macro_call => {
+                let macro_braces_to_insert =
+                    self.guess_macro_braces(&name, docs.as_ref().map_or("", |s| s.as_str()));
+                builder.insert_snippet(cap, macro_declaration + macro_braces_to_insert)
+            }
+            _ => {
+                tested_by!(dont_insert_macro_call_parens_unncessary);
+                builder.insert_text(name)
+            }
         };
 
         self.add(builder);
@@ -300,6 +309,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),
@@ -326,6 +371,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);
 
@@ -347,7 +396,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)
     }
 }
 
@@ -1031,4 +1080,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,
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index b967a6816..b5e2785fe 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -36,6 +36,8 @@ pub struct FunctionSignature {
     pub parameters: Vec<String>,
     /// Parameter names of the function
     pub parameter_names: Vec<String>,
+    /// Parameter types of the function
+    pub parameter_types: Vec<String>,
     /// Optional return type
     pub ret_type: Option<String>,
     /// Where predicates
@@ -62,14 +64,20 @@ impl FunctionSignature {
             return None;
         };
 
-        let params = st
-            .fields(db)
-            .into_iter()
-            .map(|field: hir::StructField| {
-                let ty = field.signature_ty(db);
-                format!("{}", ty.display(db))
-            })
-            .collect();
+        let mut params = vec![];
+        let mut parameter_types = vec![];
+        for field in st.fields(db).into_iter() {
+            let ty = field.signature_ty(db);
+            let raw_param = format!("{}", ty.display(db));
+
+            if let Some(param_type) = raw_param.split(':').nth(1) {
+                parameter_types.push(param_type[1..].to_string());
+            } else {
+                // useful when you have tuple struct
+                parameter_types.push(raw_param.clone());
+            }
+            params.push(raw_param);
+        }
 
         Some(
             FunctionSignature {
@@ -79,6 +87,7 @@ impl FunctionSignature {
                 ret_type: node.name().map(|n| n.text().to_string()),
                 parameters: params,
                 parameter_names: vec![],
+                parameter_types,
                 generic_parameters: generic_parameters(&node),
                 where_predicates: where_predicates(&node),
                 doc: None,
@@ -99,15 +108,21 @@ impl FunctionSignature {
 
         let name = format!("{}::{}", parent_name, variant.name(db));
 
-        let params = variant
-            .fields(db)
-            .into_iter()
-            .map(|field: hir::StructField| {
-                let name = field.name(db);
-                let ty = field.signature_ty(db);
-                format!("{}: {}", name, ty.display(db))
-            })
-            .collect();
+        let mut params = vec![];
+        let mut parameter_types = vec![];
+        for field in variant.fields(db).into_iter() {
+            let ty = field.signature_ty(db);
+            let raw_param = format!("{}", ty.display(db));
+            if let Some(param_type) = raw_param.split(':').nth(1) {
+                parameter_types.push(param_type[1..].to_string());
+            } else {
+                // The unwrap_or_else is useful when you have tuple
+                parameter_types.push(raw_param);
+            }
+            let name = field.name(db);
+
+            params.push(format!("{}: {}", name, ty.display(db)));
+        }
 
         Some(
             FunctionSignature {
@@ -117,6 +132,7 @@ impl FunctionSignature {
                 ret_type: None,
                 parameters: params,
                 parameter_names: vec![],
+                parameter_types,
                 generic_parameters: vec![],
                 where_predicates: vec![],
                 doc: None,
@@ -139,6 +155,7 @@ impl FunctionSignature {
                 ret_type: None,
                 parameters: params,
                 parameter_names: vec![],
+                parameter_types: vec![],
                 generic_parameters: vec![],
                 where_predicates: vec![],
                 doc: None,
@@ -151,18 +168,27 @@ impl FunctionSignature {
 
 impl From<&'_ ast::FnDef> for FunctionSignature {
     fn from(node: &ast::FnDef) -> FunctionSignature {
-        fn param_list(node: &ast::FnDef) -> (bool, Vec<String>) {
+        fn param_list(node: &ast::FnDef) -> (bool, Vec<String>, Vec<String>) {
             let mut res = vec![];
+            let mut res_types = vec![];
             let mut has_self_param = false;
             if let Some(param_list) = node.param_list() {
                 if let Some(self_param) = param_list.self_param() {
                     has_self_param = true;
-                    res.push(self_param.syntax().text().to_string())
+                    let raw_param = self_param.syntax().text().to_string();
+
+                    res_types.push(
+                        raw_param.split(':').nth(1).unwrap_or_else(|| " Self")[1..].to_string(),
+                    );
+                    res.push(raw_param);
                 }
 
                 res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
+                res_types.extend(param_list.params().map(|param| {
+                    param.syntax().text().to_string().split(':').nth(1).unwrap()[1..].to_string()
+                }));
             }
-            (has_self_param, res)
+            (has_self_param, res, res_types)
         }
 
         fn param_name_list(node: &ast::FnDef) -> Vec<String> {
@@ -192,7 +218,7 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
             res
         }
 
-        let (has_self_param, parameters) = param_list(node);
+        let (has_self_param, parameters, parameter_types) = param_list(node);
 
         FunctionSignature {
             kind: CallableKind::Function,
@@ -204,6 +230,7 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
                 .map(|n| n.syntax().text().to_string()),
             parameters,
             parameter_names: param_name_list(node),
+            parameter_types,
             generic_parameters: generic_parameters(node),
             where_predicates: where_predicates(node),
             // docs are processed separately
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 5599f143f..f692fbaa2 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -67,7 +67,9 @@ use crate::display::ToNav;
 pub use crate::{
     assists::{Assist, AssistId},
     call_hierarchy::CallItem,
-    completion::{CompletionConfig, CompletionItem, CompletionItemKind, InsertTextFormat},
+    completion::{
+        CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat,
+    },
     diagnostics::Severity,
     display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
     expand_macro::ExpandedMacro,
diff --git a/crates/ra_ide/src/marks.rs b/crates/ra_ide/src/marks.rs
index eee44e886..bea30fe2a 100644
--- a/crates/ra_ide/src/marks.rs
+++ b/crates/ra_ide/src/marks.rs
@@ -9,4 +9,6 @@ test_utils::marks!(
     search_filters_by_range
     dont_insert_macro_call_parens_unncessary
     self_fulfilling_completion
+    test_struct_field_completion_in_func_call
+    test_struct_field_completion_in_record_lit
 );
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 93d502875..d9912155b 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -19,7 +19,7 @@ use ra_syntax::{
 };
 use rustc_hash::FxHashMap;
 
-use crate::{call_info::call_info_for_token, Analysis, FileId};
+use crate::{call_info::ActiveParameter, Analysis, FileId};
 
 pub(crate) use html::highlight_as_html;
 pub use tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag};
@@ -364,10 +364,8 @@ fn highlight_injection(
     literal: ast::RawString,
     expanded: SyntaxToken,
 ) -> Option<()> {
-    let call_info = call_info_for_token(&sema, expanded)?;
-    let idx = call_info.active_parameter?;
-    let name = call_info.signature.parameter_names.get(idx)?;
-    if !name.starts_with("ra_fixture") {
+    let active_parameter = ActiveParameter::at_token(&sema, expanded)?;
+    if !active_parameter.name.starts_with("ra_fixture") {
         return None;
     }
     let value = literal.value()?;