53 files changed, 2936 insertions, 929 deletions

diff --git a/crates/ra_ide/src/assists.rs b/crates/ra_ide/src/assists.rs
deleted file mode 100644
index 2b5d11681..000000000
--- a/crates/ra_ide/src/assists.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//! FIXME: write short doc here
-
-use ra_assists::{resolved_assists, AssistAction, AssistLabel};
-use ra_db::{FilePosition, FileRange};
-use ra_ide_db::RootDatabase;
-
-use crate::{FileId, SourceChange, SourceFileEdit};
-
-pub use ra_assists::AssistId;
-
-#[derive(Debug)]
-pub struct Assist {
-    pub id: AssistId,
-    pub label: String,
-    pub group_label: Option<String>,
-    pub source_change: SourceChange,
-}
-
-pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
-    resolved_assists(db, frange)
-        .into_iter()
-        .map(|assist| {
-            let file_id = frange.file_id;
-            let assist_label = &assist.label;
-            Assist {
-                id: assist_label.id,
-                label: assist_label.label.clone(),
-                group_label: assist.group_label.map(|it| it.0),
-                source_change: action_to_edit(assist.action, file_id, assist_label),
-            }
-        })
-        .collect()
-}
-
-fn action_to_edit(
-    action: AssistAction,
-    file_id: FileId,
-    assist_label: &AssistLabel,
-) -> SourceChange {
-    let file_id = match action.file {
-        ra_assists::AssistFile::TargetFile(it) => it,
-        _ => file_id,
-    };
-    let file_edit = SourceFileEdit { file_id, edit: action.edit };
-    SourceChange::source_file_edit(assist_label.label.clone(), file_edit)
-        .with_cursor_opt(action.cursor_position.map(|offset| FilePosition { offset, file_id }))
-}
diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
index 85d1f0cb1..defd8176f 100644
--- a/crates/ra_ide/src/call_hierarchy.rs
+++ b/crates/ra_ide/src/call_hierarchy.rs
@@ -246,6 +246,35 @@ mod tests {
     }
 
     #[test]
+    fn test_call_hierarchy_in_tests_mod() {
+        check_hierarchy(
+            r#"
+            //- /lib.rs cfg:test
+            fn callee() {}
+            fn caller1() {
+                call<|>ee();
+            }
+
+            #[cfg(test)]
+            mod tests {
+                use super::*;
+
+                #[test]
+                fn test_caller() {
+                    callee();
+                }
+            }
+            "#,
+            "callee FN_DEF FileId(1) 0..14 3..9",
+            &[
+                "caller1 FN_DEF FileId(1) 15..45 18..25 : [34..40]",
+                "test_caller FN_DEF FileId(1) 93..147 108..119 : [132..138]",
+            ],
+            &[],
+        );
+    }
+
+    #[test]
     fn test_call_hierarchy_in_different_files() {
         check_hierarchy(
             r#"
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index 780a03c13..aa039e6fc 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
     ast::{self, ArgListOwner},
     match_ast, AstNode, SyntaxNode, SyntaxToken,
 };
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{CallInfo, FilePosition, FunctionSignature};
 
@@ -84,7 +84,7 @@ fn call_info_for_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Op
 
                 let arg_list_range = arg_list.syntax().text_range();
                 if !arg_list_range.contains_inclusive(token.text_range().start()) {
-                    tested_by!(call_info_bad_offset);
+                    mark::hit!(call_info_bad_offset);
                     return None;
                 }
 
@@ -213,7 +213,7 @@ impl CallInfo {
 
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
 
     use crate::mock_analysis::single_file_with_position;
 
@@ -529,7 +529,7 @@ By default this method stops actor's `Context`."#
 
     #[test]
     fn call_info_bad_offset() {
-        covers!(call_info_bad_offset);
+        mark::check!(call_info_bad_offset);
         let (analysis, position) = single_file_with_position(
             r#"fn foo(x: u32, y: u32) -> u32 {x + y}
                fn bar() { foo <|> (3, ); }"#,
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index 4ca0fdf4f..d890b69d2 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -1,5 +1,3 @@
-//! FIXME: write short doc here
-
 mod completion_config;
 mod completion_item;
 mod completion_context;
@@ -35,6 +33,51 @@ pub use crate::completion::{
     completion_item::{CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat},
 };
 
+//FIXME: split the following feature into fine-grained features.
+
+// Feature: Magic Completions
+//
+// In addition to usual reference completion, rust-analyzer provides some ✨magic✨
+// completions as well:
+//
+// Keywords like `if`, `else` `while`, `loop` are completed with braces, and cursor
+// is placed at the appropriate position. Even though `if` is easy to type, you
+// still want to complete it, to get ` { }` for free! `return` is inserted with a
+// space or `;` depending on the return type of the function.
+//
+// When completing a function call, `()` are automatically inserted. If a function
+// takes arguments, the cursor is positioned inside the parenthesis.
+//
+// There are postfix completions, which can be triggered by typing something like
+// `foo().if`. The word after `.` determines postfix completion. Possible variants are:
+//
+// - `expr.if` -> `if expr {}` or `if let ... {}` for `Option` or `Result`
+// - `expr.match` -> `match expr {}`
+// - `expr.while` -> `while expr {}` or `while let ... {}` for `Option` or `Result`
+// - `expr.ref` -> `&expr`
+// - `expr.refm` -> `&mut expr`
+// - `expr.not` -> `!expr`
+// - `expr.dbg` -> `dbg!(expr)`
+//
+// There also snippet completions:
+//
+// .Expressions
+// - `pd` -> `println!("{:?}")`
+// - `ppd` -> `println!("{:#?}")`
+//
+// .Items
+// - `tfn` -> `#[test] fn f(){}`
+// - `tmod` ->
+// ```rust
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+//
+//     #[test]
+//     fn test_fn() {}
+// }
+// ```
+
 /// 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.
@@ -59,13 +102,13 @@ pub use crate::completion::{
 /// with ordering of completions (currently this is done by the client).
 pub(crate) fn completions(
     db: &RootDatabase,
-    position: FilePosition,
     config: &CompletionConfig,
+    position: FilePosition,
 ) -> Option<Completions> {
     let ctx = CompletionContext::new(db, position, config)?;
 
     let mut acc = Completions::default();
-
+    complete_attribute::complete_attribute(&mut acc, &ctx);
     complete_fn_param::complete_fn_param(&mut acc, &ctx);
     complete_keyword::complete_expr_keyword(&mut acc, &ctx);
     complete_keyword::complete_use_tree_keyword(&mut acc, &ctx);
@@ -79,7 +122,6 @@ pub(crate) fn completions(
     complete_postfix::complete_postfix(&mut acc, &ctx);
     complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
     complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
-    complete_attribute::complete_attribute(&mut acc, &ctx);
 
     Some(acc)
 }
diff --git a/crates/ra_ide/src/completion/complete_attribute.rs b/crates/ra_ide/src/completion/complete_attribute.rs
index 8bf952798..fb3f0b743 100644
--- a/crates/ra_ide/src/completion/complete_attribute.rs
+++ b/crates/ra_ide/src/completion/complete_attribute.rs
@@ -3,25 +3,29 @@
 //! This module uses a bit of static metadata to provide completions
 //! for built-in attributes.
 
-use super::completion_context::CompletionContext;
-use super::completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions};
-use ra_syntax::{
-    ast::{Attr, AttrKind},
-    AstNode,
+use ra_syntax::{ast, AstNode, SyntaxKind};
+use rustc_hash::FxHashSet;
+
+use crate::completion::{
+    completion_context::CompletionContext,
+    completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions},
 };
 
-pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_attribute {
-        return;
-    }
+pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+    let attribute = ctx.attribute_under_caret.as_ref()?;
 
-    let is_inner = ctx
-        .original_token
-        .ancestors()
-        .find_map(Attr::cast)
-        .map(|attr| attr.kind() == AttrKind::Inner)
-        .unwrap_or(false);
+    match (attribute.path(), attribute.input()) {
+        (Some(path), Some(ast::AttrInput::TokenTree(token_tree)))
+            if path.to_string() == "derive" =>
+        {
+            complete_derive(acc, ctx, token_tree)
+        }
+        _ => complete_attribute_start(acc, ctx, attribute),
+    }
+    Some(())
+}
 
+fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
     for attr_completion in ATTRIBUTES {
         let mut item = CompletionItem::new(
             CompletionKind::Attribute,
@@ -37,7 +41,7 @@ pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext)
             _ => {}
         }
 
-        if is_inner || !attr_completion.should_be_inner {
+        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.should_be_inner {
             acc.add(item);
         }
     }
@@ -108,7 +112,7 @@ const ATTRIBUTES: &[AttrCompletion] = &[
     AttrCompletion { label: "repr", snippet: Some("repr(${0:C})"), should_be_inner: false },
     AttrCompletion {
         label: "should_panic",
-        snippet: Some(r#"expected = "${0:reason}""#),
+        snippet: Some(r#"should_panic(expected = "${0:reason}")"#),
         should_be_inner: false,
     },
     AttrCompletion {
@@ -126,6 +130,106 @@ const ATTRIBUTES: &[AttrCompletion] = &[
     },
 ];
 
+fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input: ast::TokenTree) {
+    if let Ok(existing_derives) = parse_derive_input(derive_input) {
+        for derive_completion in DEFAULT_DERIVE_COMPLETIONS
+            .into_iter()
+            .filter(|completion| !existing_derives.contains(completion.label))
+        {
+            let mut label = derive_completion.label.to_owned();
+            for dependency in derive_completion
+                .dependencies
+                .into_iter()
+                .filter(|&&dependency| !existing_derives.contains(dependency))
+            {
+                label.push_str(", ");
+                label.push_str(dependency);
+            }
+            acc.add(
+                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label)
+                    .kind(CompletionItemKind::Attribute),
+            );
+        }
+
+        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
+            acc.add(
+                CompletionItem::new(
+                    CompletionKind::Attribute,
+                    ctx.source_range(),
+                    custom_derive_name,
+                )
+                .kind(CompletionItemKind::Attribute),
+            );
+        }
+    }
+}
+
+fn parse_derive_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
+    match (derive_input.left_delimiter_token(), derive_input.right_delimiter_token()) {
+        (Some(left_paren), Some(right_paren))
+            if left_paren.kind() == SyntaxKind::L_PAREN
+                && right_paren.kind() == SyntaxKind::R_PAREN =>
+        {
+            let mut input_derives = FxHashSet::default();
+            let mut current_derive = String::new();
+            for token in derive_input
+                .syntax()
+                .children_with_tokens()
+                .filter_map(|token| token.into_token())
+                .skip_while(|token| token != &left_paren)
+                .skip(1)
+                .take_while(|token| token != &right_paren)
+            {
+                if SyntaxKind::COMMA == token.kind() {
+                    if !current_derive.is_empty() {
+                        input_derives.insert(current_derive);
+                        current_derive = String::new();
+                    }
+                } else {
+                    current_derive.push_str(token.to_string().trim());
+                }
+            }
+
+            if !current_derive.is_empty() {
+                input_derives.insert(current_derive);
+            }
+            Ok(input_derives)
+        }
+        _ => Err(()),
+    }
+}
+
+fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
+    let mut result = FxHashSet::default();
+    ctx.scope().process_all_names(&mut |name, scope_def| {
+        if let hir::ScopeDef::MacroDef(mac) = scope_def {
+            if mac.is_derive_macro() {
+                result.insert(name.to_string());
+            }
+        }
+    });
+    result
+}
+
+struct DeriveCompletion {
+    label: &'static str,
+    dependencies: &'static [&'static str],
+}
+
+/// Standard Rust derives and the information about their dependencies
+/// (the dependencies are needed so that the main derive don't break the compilation when added)
+const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
+    DeriveCompletion { label: "Clone", dependencies: &[] },
+    DeriveCompletion { label: "Copy", dependencies: &["Clone"] },
+    DeriveCompletion { label: "Debug", dependencies: &[] },
+    DeriveCompletion { label: "Default", dependencies: &[] },
+    DeriveCompletion { label: "Hash", dependencies: &[] },
+    DeriveCompletion { label: "PartialEq", dependencies: &[] },
+    DeriveCompletion { label: "Eq", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "PartialOrd", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
+];
+
 #[cfg(test)]
 mod tests {
     use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
@@ -136,6 +240,170 @@ mod tests {
     }
 
     #[test]
+    fn empty_derive_completion() {
+        assert_debug_snapshot!(
+            do_attr_completion(
+                    r"
+                    #[derive(<|>)]
+                    struct Test {}
+                    ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Clone",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Copy, Clone",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Copy, Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Debug",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Debug",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Default",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Default",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Eq, PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Eq, PartialEq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Hash",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Hash",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Ord, PartialOrd, Eq, PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Ord, PartialOrd, Eq, PartialEq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "PartialEq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "PartialOrd, PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "PartialOrd, PartialEq",
+                kind: Attribute,
+            },
+        ]
+            "###
+        );
+    }
+
+    #[test]
+    fn no_completion_for_incorrect_derive() {
+        assert_debug_snapshot!(
+            do_attr_completion(
+                r"
+                    #[derive{<|>)]
+                    struct Test {}
+                    ",
+            ),
+            @"[]"
+        );
+    }
+
+    #[test]
+    fn derive_with_input_completion() {
+        assert_debug_snapshot!(
+            do_attr_completion(
+                    r"
+                    #[derive(serde::Serialize, PartialEq, <|>)]
+                    struct Test {}
+                    ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Clone",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Copy, Clone",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Copy, Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Debug",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Debug",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Default",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Default",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Eq",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Eq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Hash",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Hash",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Ord, PartialOrd, Eq",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Ord, PartialOrd, Eq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "PartialOrd",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "PartialOrd",
+                kind: Attribute,
+            },
+        ]
+            "###
+        );
+    }
+
+    #[test]
     fn test_attribute_completion() {
         assert_debug_snapshot!(
         do_attr_completion(
@@ -303,7 +571,7 @@ mod tests {
                 label: "should_panic",
                 source_range: 19..19,
                 delete: 19..19,
-                insert: "expected = \"${0:reason}\"",
+                insert: "should_panic(expected = \"${0:reason}\")",
                 kind: Attribute,
             },
             CompletionItem {
@@ -542,7 +810,7 @@ mod tests {
                 label: "should_panic",
                 source_range: 20..20,
                 delete: 20..20,
-                insert: "expected = \"${0:reason}\"",
+                insert: "should_panic(expected = \"${0:reason}\")",
                 kind: Attribute,
             },
             CompletionItem {
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 6a0f0c72e..59b58bf98 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -1,12 +1,11 @@
 //! FIXME: write short doc here
-
+use ra_assists::utils::TryEnum;
 use ra_syntax::{
     ast::{self, AstNode},
     TextRange, TextSize,
 };
 use ra_text_edit::TextEdit;
 
-use super::completion_config::SnippetCap;
 use crate::{
     completion::{
         completion_context::CompletionContext,
@@ -15,6 +14,8 @@ use crate::{
     CompletionItem,
 };
 
+use super::completion_config::SnippetCap;
+
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.config.enable_postfix_completions {
         return;
@@ -37,8 +38,53 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         Some(it) => it,
         None => return,
     };
+    let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty);
+    if let Some(try_enum) = &try_enum {
+        match try_enum {
+            TryEnum::Result => {
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "ifl",
+                    "if let Ok {}",
+                    &format!("if let Ok($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
+
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "while",
+                    "while let Ok {}",
+                    &format!("while let Ok($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
+            }
+            TryEnum::Option => {
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "ifl",
+                    "if let Some {}",
+                    &format!("if let Some($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
 
-    if receiver_ty.is_bool() || receiver_ty.is_unknown() {
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "while",
+                    "while let Some {}",
+                    &format!("while let Some($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
+            }
+        }
+    } else if receiver_ty.is_bool() || receiver_ty.is_unknown() {
         postfix_snippet(
             ctx,
             cap,
@@ -58,7 +104,6 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         )
         .add_to(acc);
     }
-
     // !&&&42 is a compiler error, ergo process it before considering the references
     postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
         .add_to(acc);
@@ -80,14 +125,53 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     let dot_receiver = include_references(dot_receiver);
     let receiver_text =
         get_receiver_text(&dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
+    match try_enum {
+        Some(try_enum) => {
+            match try_enum {
+                TryEnum::Result => {
+                    postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "match",
+                    "match expr {}",
+                    &format!("match {} {{\n    Ok(${{1:_}}) => {{$2\\}},\n    Err(${{3:_}}) => {{$0\\}},\n}}", receiver_text),
+                )
+                .add_to(acc);
+                }
+                TryEnum::Option => {
+                    postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "match",
+                    "match expr {}",
+                    &format!("match {} {{\n    Some(${{1:_}}) => {{$2\\}},\n    None => {{$0\\}},\n}}", receiver_text),
+                )
+                .add_to(acc);
+                }
+            }
+        }
+        None => {
+            postfix_snippet(
+                ctx,
+                cap,
+                &dot_receiver,
+                "match",
+                "match expr {}",
+                &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
+            )
+            .add_to(acc);
+        }
+    }
 
     postfix_snippet(
         ctx,
         cap,
         &dot_receiver,
-        "match",
-        "match expr {}",
-        &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
+        "box",
+        "Box::new(expr)",
+        &format!("Box::new({})", receiver_text),
     )
     .add_to(acc);
 
@@ -95,9 +179,9 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         ctx,
         cap,
         &dot_receiver,
-        "box",
-        "Box::new(expr)",
-        &format!("Box::new({})", receiver_text),
+        "dbg",
+        "dbg!(expr)",
+        &format!("dbg!({})", receiver_text),
     )
     .add_to(acc);
 
@@ -105,9 +189,9 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         ctx,
         cap,
         &dot_receiver,
-        "dbg",
-        "dbg!(expr)",
-        &format!("dbg!({})", receiver_text),
+        "call",
+        "function(expr)",
+        &format!("${{1}}({})", receiver_text),
     )
     .add_to(acc);
 }
@@ -182,6 +266,13 @@ mod tests {
                 detail: "Box::new(expr)",
             },
             CompletionItem {
+                label: "call",
+                source_range: 89..89,
+                delete: 85..89,
+                insert: "${1}(bar)",
+                detail: "function(expr)",
+            },
+            CompletionItem {
                 label: "dbg",
                 source_range: 89..89,
                 delete: 85..89,
@@ -236,6 +327,178 @@ mod tests {
     }
 
     #[test]
+    fn postfix_completion_works_for_option() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                enum Option<T> {
+                    Some(T),
+                    None,
+                }
+
+                fn main() {
+                    let bar = Option::Some(true);
+                    bar.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "call",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "${1}(bar)",
+                detail: "function(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "ifl",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "if let Some($1) = bar {\n    $0\n}",
+                detail: "if let Some {}",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "match bar {\n    Some(${1:_}) => {$2\\},\n    None => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+            CompletionItem {
+                label: "while",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "while let Some($1) = bar {\n    $0\n}",
+                detail: "while let Some {}",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn postfix_completion_works_for_result() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                enum Result<T, E> {
+                    Ok(T),
+                    Err(E),
+                }
+
+                fn main() {
+                    let bar = Result::Ok(true);
+                    bar.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "call",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "${1}(bar)",
+                detail: "function(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "ifl",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "if let Ok($1) = bar {\n    $0\n}",
+                detail: "if let Ok {}",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "match bar {\n    Ok(${1:_}) => {$2\\},\n    Err(${3:_}) => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+            CompletionItem {
+                label: "while",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "while let Ok($1) = bar {\n    $0\n}",
+                detail: "while let Ok {}",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
     fn some_postfix_completions_ignored() {
         assert_debug_snapshot!(
             do_postfix_completion(
@@ -256,6 +519,13 @@ mod tests {
                 detail: "Box::new(expr)",
             },
             CompletionItem {
+                label: "call",
+                source_range: 91..91,
+                delete: 87..91,
+                insert: "${1}(bar)",
+                detail: "function(expr)",
+            },
+            CompletionItem {
                 label: "dbg",
                 source_range: 91..91,
                 delete: 87..91,
@@ -315,6 +585,13 @@ mod tests {
                 detail: "Box::new(expr)",
             },
             CompletionItem {
+                label: "call",
+                source_range: 52..52,
+                delete: 49..52,
+                insert: "${1}(42)",
+                detail: "function(expr)",
+            },
+            CompletionItem {
                 label: "dbg",
                 source_range: 52..52,
                 delete: 49..52,
@@ -376,6 +653,13 @@ mod tests {
                 detail: "Box::new(expr)",
             },
             CompletionItem {
+                label: "call",
+                source_range: 149..150,
+                delete: 145..150,
+                insert: "${1}(bar)",
+                detail: "function(expr)",
+            },
+            CompletionItem {
                 label: "dbg",
                 source_range: 149..150,
                 delete: 145..150,
@@ -435,6 +719,13 @@ mod tests {
                 detail: "Box::new(expr)",
             },
             CompletionItem {
+                label: "call",
+                source_range: 56..56,
+                delete: 49..56,
+                insert: "${1}(&&&&42)",
+                detail: "function(expr)",
+            },
+            CompletionItem {
                 label: "dbg",
                 source_range: 56..56,
                 delete: 49..56,
diff --git a/crates/ra_ide/src/completion/complete_qualified_path.rs b/crates/ra_ide/src/completion/complete_qualified_path.rs
index aa56a5cd8..02ac0166b 100644
--- a/crates/ra_ide/src/completion/complete_qualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_qualified_path.rs
@@ -2,20 +2,25 @@
 
 use hir::{Adt, HasVisibility, PathResolution, ScopeDef};
 use ra_syntax::AstNode;
-use test_utils::tested_by;
+use rustc_hash::FxHashSet;
+use test_utils::mark;
 
 use crate::completion::{CompletionContext, Completions};
-use rustc_hash::FxHashSet;
 
 pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     let path = match &ctx.path_prefix {
         Some(path) => path.clone(),
-        _ => return,
+        None => return,
     };
+
+    if ctx.attribute_under_caret.is_some() {
+        return;
+    }
+
     let scope = ctx.scope();
     let context_module = scope.module();
 
-    let res = match scope.resolve_hir_path(&path) {
+    let res = match scope.resolve_hir_path_qualifier(&path) {
         Some(res) => res,
         None => return,
     };
@@ -35,7 +40,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                         if let Some(name_ref) = ctx.name_ref_syntax.as_ref() {
                             if name_ref.syntax().text() == name.to_string().as_str() {
                                 // for `use self::foo<|>`, don't suggest `foo` as a completion
-                                tested_by!(dont_complete_current_use);
+                                mark::hit!(dont_complete_current_use);
                                 continue;
                             }
                         }
@@ -79,7 +84,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                 });
 
                 // Iterate assoc types separately
-                ty.iterate_impl_items(ctx.db, krate, |item| {
+                ty.iterate_assoc_items(ctx.db, krate, |item| {
                     if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
                         return None;
                     }
@@ -142,7 +147,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
 
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
 
     use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
     use insta::assert_debug_snapshot;
@@ -153,7 +158,7 @@ mod tests {
 
     #[test]
     fn dont_complete_current_use() {
-        covers!(dont_complete_current_use);
+        mark::check!(dont_complete_current_use);
         let completions = do_completion(r"use self::foo<|>;", CompletionKind::Reference);
         assert!(completions.is_empty());
     }
@@ -221,6 +226,34 @@ mod tests {
     }
 
     #[test]
+    fn completes_mod_with_same_name_as_function() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                use self::my::<|>;
+
+                mod my {
+                    pub struct Bar;
+                }
+
+                fn my() {}
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Bar",
+                source_range: 31..31,
+                delete: 31..31,
+                insert: "Bar",
+                kind: Struct,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
     fn path_visibility() {
         assert_debug_snapshot!(
             do_reference_completion(
@@ -1325,4 +1358,18 @@ mod tests {
         "###
         );
     }
+
+    #[test]
+    fn dont_complete_attr() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                mod foo { pub struct Foo; }
+                #[foo::<|>]
+                fn f() {}
+                "
+            ),
+            @r###"[]"###
+        )
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_snippet.rs b/crates/ra_ide/src/completion/complete_snippet.rs
index a3f5d1b6a..0568d9ccf 100644
--- a/crates/ra_ide/src/completion/complete_snippet.rs
+++ b/crates/ra_ide/src/completion/complete_snippet.rs
@@ -36,6 +36,24 @@ pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionConte
     snippet(
         ctx,
         cap,
+        "Test module",
+        "\
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ${1:test_name}() {
+        $0
+    }
+}",
+    )
+    .lookup_by("tmod")
+    .add_to(acc);
+
+    snippet(
+        ctx,
+        cap,
         "Test function",
         "\
 #[test]
@@ -118,6 +136,14 @@ mod tests {
                 lookup: "tfn",
             },
             CompletionItem {
+                label: "Test module",
+                source_range: 78..78,
+                delete: 78..78,
+                insert: "#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn ${1:test_name}() {\n        $0\n    }\n}",
+                kind: Snippet,
+                lookup: "tmod",
+            },
+            CompletionItem {
                 label: "macro_rules",
                 source_range: 78..78,
                 delete: 78..78,
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index ee32d1ff6..21c9316e6 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -32,7 +32,7 @@
 //! ```
 
 use hir::{self, Docs, HasSource};
-use ra_assists::utils::get_missing_impl_items;
+use ra_assists::utils::get_missing_assoc_items;
 use ra_syntax::{
     ast::{self, edit, ImplDef},
     AstNode, SyntaxKind, SyntaxNode, TextRange, T,
@@ -49,50 +49,53 @@ use crate::{
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
     if let Some((trigger, impl_def)) = completion_match(ctx) {
         match trigger.kind() {
-            SyntaxKind::NAME_REF => {
-                get_missing_impl_items(&ctx.sema, &impl_def).iter().for_each(|item| match item {
+            SyntaxKind::NAME_REF => get_missing_assoc_items(&ctx.sema, &impl_def)
+                .into_iter()
+                .for_each(|item| match item {
                     hir::AssocItem::Function(fn_item) => {
-                        add_function_impl(&trigger, acc, ctx, &fn_item)
+                        add_function_impl(&trigger, acc, ctx, fn_item)
                     }
                     hir::AssocItem::TypeAlias(type_item) => {
-                        add_type_alias_impl(&trigger, acc, ctx, &type_item)
+                        add_type_alias_impl(&trigger, acc, ctx, type_item)
                     }
                     hir::AssocItem::Const(const_item) => {
-                        add_const_impl(&trigger, acc, ctx, &const_item)
+                        add_const_impl(&trigger, acc, ctx, const_item)
                     }
-                })
-            }
+                }),
 
             SyntaxKind::FN_DEF => {
-                for missing_fn in get_missing_impl_items(&ctx.sema, &impl_def).iter().filter_map(
-                    |item| match item {
+                for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
+                    .into_iter()
+                    .filter_map(|item| match item {
                         hir::AssocItem::Function(fn_item) => Some(fn_item),
                         _ => None,
-                    },
-                ) {
-                    add_function_impl(&trigger, acc, ctx, &missing_fn);
+                    })
+                {
+                    add_function_impl(&trigger, acc, ctx, missing_fn);
                 }
             }
 
             SyntaxKind::TYPE_ALIAS_DEF => {
-                for missing_fn in get_missing_impl_items(&ctx.sema, &impl_def).iter().filter_map(
-                    |item| match item {
+                for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
+                    .into_iter()
+                    .filter_map(|item| match item {
                         hir::AssocItem::TypeAlias(type_item) => Some(type_item),
                         _ => None,
-                    },
-                ) {
-                    add_type_alias_impl(&trigger, acc, ctx, &missing_fn);
+                    })
+                {
+                    add_type_alias_impl(&trigger, acc, ctx, missing_fn);
                 }
             }
 
             SyntaxKind::CONST_DEF => {
-                for missing_fn in get_missing_impl_items(&ctx.sema, &impl_def).iter().filter_map(
-                    |item| match item {
+                for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
+                    .into_iter()
+                    .filter_map(|item| match item {
                         hir::AssocItem::Const(const_item) => Some(const_item),
                         _ => None,
-                    },
-                ) {
-                    add_const_impl(&trigger, acc, ctx, &missing_fn);
+                    })
+                {
+                    add_const_impl(&trigger, acc, ctx, missing_fn);
                 }
             }
 
@@ -120,9 +123,9 @@ fn add_function_impl(
     fn_def_node: &SyntaxNode,
     acc: &mut Completions,
     ctx: &CompletionContext,
-    func: &hir::Function,
+    func: hir::Function,
 ) {
-    let signature = FunctionSignature::from_hir(ctx.db, *func);
+    let signature = FunctionSignature::from_hir(ctx.db, func);
 
     let fn_name = func.name(ctx.db).to_string();
 
@@ -161,7 +164,7 @@ fn add_type_alias_impl(
     type_def_node: &SyntaxNode,
     acc: &mut Completions,
     ctx: &CompletionContext,
-    type_alias: &hir::TypeAlias,
+    type_alias: hir::TypeAlias,
 ) {
     let alias_name = type_alias.name(ctx.db).to_string();
 
@@ -181,7 +184,7 @@ fn add_const_impl(
     const_def_node: &SyntaxNode,
     acc: &mut Completions,
     ctx: &CompletionContext,
-    const_: &hir::Const,
+    const_: hir::Const,
 ) {
     let const_name = const_.name(ctx.db).map(|n| n.to_string());
 
diff --git a/crates/ra_ide/src/completion/complete_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
index a6a5568de..68032c37e 100644
--- a/crates/ra_ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -1,16 +1,19 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 
 use hir::ScopeDef;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::completion::{CompletionContext, Completions};
 use hir::{Adt, ModuleDef, Type};
 use ra_syntax::AstNode;
 
 pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
-    if (!ctx.is_trivial_path && !ctx.is_pat_binding_or_const)
-        || ctx.record_lit_syntax.is_some()
+    if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
+        return;
+    }
+    if ctx.record_lit_syntax.is_some()
         || ctx.record_pat_syntax.is_some()
+        || ctx.attribute_under_caret.is_some()
     {
         return;
     }
@@ -27,7 +30,7 @@ pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         if ctx.use_item_syntax.is_some() {
             if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
                 if name_ref.syntax().text() == name.to_string().as_str() {
-                    tested_by!(self_fulfilling_completion);
+                    mark::hit!(self_fulfilling_completion);
                     return;
                 }
             }
@@ -63,7 +66,7 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
 #[cfg(test)]
 mod tests {
     use insta::assert_debug_snapshot;
-    use test_utils::covers;
+    use test_utils::mark;
 
     use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
 
@@ -73,7 +76,7 @@ mod tests {
 
     #[test]
     fn self_fulfilling_completion() {
-        covers!(self_fulfilling_completion);
+        mark::check!(self_fulfilling_completion);
         assert_debug_snapshot!(
             do_reference_completion(
                 r#"
@@ -295,6 +298,42 @@ mod tests {
     }
 
     #[test]
+    fn completes_bindings_from_for_with_in_prefix() {
+        mark::check!(completes_bindings_from_for_with_in_prefix);
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn test() {
+                    for index in &[1, 2, 3] {
+                        let t = in<|>
+                    }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "index",
+                source_range: 107..107,
+                delete: 107..107,
+                insert: "index",
+                kind: Binding,
+            },
+            CompletionItem {
+                label: "test()",
+                source_range: 107..107,
+                delete: 107..107,
+                insert: "test()$0",
+                kind: Function,
+                lookup: "test",
+                detail: "fn test()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
     fn completes_generic_params() {
         assert_debug_snapshot!(
             do_reference_completion(
@@ -1369,4 +1408,18 @@ mod tests {
         "###
         )
     }
+
+    #[test]
+    fn dont_complete_attr() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Foo;
+                #[<|>]
+                fn f() {}
+                "
+            ),
+            @r###"[]"###
+        )
+    }
 }
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 118fceb2e..c4646b727 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -9,9 +9,10 @@ use ra_syntax::{
     SyntaxKind::*,
     SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
-use ra_text_edit::AtomTextEdit;
+use ra_text_edit::Indel;
 
 use crate::{call_info::ActiveParameter, completion::CompletionConfig, FilePosition};
+use test_utils::mark;
 
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
@@ -34,7 +35,7 @@ pub(crate) struct CompletionContext<'a> {
     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
+    /// FIXME: `ActiveParameter` is string-based, which is very 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.
@@ -58,7 +59,7 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) is_macro_call: bool,
     pub(super) is_path_type: bool,
     pub(super) has_type_args: bool,
-    pub(super) is_attribute: bool,
+    pub(super) attribute_under_caret: Option<ast::Attr>,
 }
 
 impl<'a> CompletionContext<'a> {
@@ -76,7 +77,7 @@ impl<'a> CompletionContext<'a> {
         // actual completion.
         let file_with_fake_ident = {
             let parse = db.parse(position.file_id);
-            let edit = AtomTextEdit::insert(position.offset, "intellijRulezz".to_string());
+            let edit = Indel::insert(position.offset, "intellijRulezz".to_string());
             parse.reparse(&edit).tree()
         };
         let fake_ident_token =
@@ -116,7 +117,7 @@ impl<'a> CompletionContext<'a> {
             is_path_type: false,
             has_type_args: false,
             dot_receiver_is_ambiguous_float_literal: false,
-            is_attribute: false,
+            attribute_under_caret: None,
         };
 
         let mut original_file = original_file.syntax().clone();
@@ -169,7 +170,17 @@ impl<'a> CompletionContext<'a> {
         match self.token.kind() {
             // workaroud when completion is triggered by trigger characters.
             IDENT => self.original_token.text_range(),
-            _ => TextRange::empty(self.offset),
+            _ => {
+                // If we haven't characters between keyword and our cursor we take the keyword start range to edit
+                if self.token.kind().is_keyword()
+                    && self.offset == self.original_token.text_range().end()
+                {
+                    mark::hit!(completes_bindings_from_for_with_in_prefix);
+                    TextRange::empty(self.original_token.text_range().start())
+                } else {
+                    TextRange::empty(self.offset)
+                }
+            }
         }
     }
 
@@ -200,6 +211,7 @@ impl<'a> CompletionContext<'a> {
                 Some(ty)
             })
             .flatten();
+        self.attribute_under_caret = find_node_at_offset(&file_with_fake_ident, offset);
 
         // First, let's try to complete a reference to some declaration.
         if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&file_with_fake_ident, offset) {
@@ -318,7 +330,6 @@ impl<'a> CompletionContext<'a> {
                 .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_attribute = path.syntax().parent().and_then(ast::Attr::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();
@@ -344,7 +355,7 @@ impl<'a> CompletionContext<'a> {
                                 stmt.syntax().text_range() == name_ref.syntax().text_range(),
                             );
                         }
-                        if let Some(block) = ast::Block::cast(node) {
+                        if let Some(block) = ast::BlockExpr::cast(node) {
                             return Some(
                                 block.expr().map(|e| e.syntax().text_range())
                                     == Some(name_ref.syntax().text_range()),
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index 5936fb8f7..cfb7c1e38 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -2,11 +2,12 @@
 
 use std::fmt;
 
-use super::completion_config::SnippetCap;
 use hir::Documentation;
 use ra_syntax::TextRange;
 use ra_text_edit::TextEdit;
 
+use crate::completion::completion_config::SnippetCap;
+
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
 /// It is basically a POD with various properties. To construct a
 /// `CompletionItem`, use `new` method and the `Builder` struct.
@@ -62,8 +63,8 @@ impl fmt::Debug for CompletionItem {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut s = f.debug_struct("CompletionItem");
         s.field("label", &self.label()).field("source_range", &self.source_range());
-        if self.text_edit().as_atoms().len() == 1 {
-            let atom = &self.text_edit().as_atoms()[0];
+        if self.text_edit().len() == 1 {
+            let atom = &self.text_edit().iter().next().unwrap();
             s.field("delete", &atom.delete);
             s.field("insert", &atom.insert);
         } else {
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 2edb130cf..61565c84f 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -3,7 +3,7 @@
 use hir::{Docs, HasAttrs, HasSource, HirDisplay, ModPath, ScopeDef, StructKind, Type};
 use ra_syntax::ast::NameOwner;
 use stdx::SepBy;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     completion::{
@@ -17,12 +17,11 @@ use crate::{
 impl Completions {
     pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &Type) {
         let is_deprecated = is_deprecated(field, ctx.db);
-        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())
+                .detail(ty.display(ctx.db).to_string())
                 .set_documentation(field.docs(ctx.db))
                 .set_deprecated(is_deprecated);
 
@@ -107,6 +106,12 @@ impl Completions {
             }
         };
 
+        if let ScopeDef::Local(local) = resolution {
+            if let Some(score) = compute_score(ctx, &local.ty(ctx.db), &local_name) {
+                completion_item = completion_item.set_score(score);
+            }
+        }
+
         // Add `<>` for generic types
         if ctx.is_path_type && !ctx.has_type_args && ctx.config.add_call_parenthesis {
             if let Some(cap) = ctx.config.snippet_cap {
@@ -116,7 +121,7 @@ impl Completions {
                     _ => false,
                 };
                 if has_non_default_type_params {
-                    tested_by!(inserts_angle_brackets_for_generics);
+                    mark::hit!(inserts_angle_brackets_for_generics);
                     completion_item = completion_item
                         .lookup_by(local_name.clone())
                         .label(format!("{}<…>", local_name))
@@ -171,7 +176,7 @@ impl Completions {
             }
             None if needs_bang => builder.insert_text(format!("{}!", name)),
             _ => {
-                tested_by!(dont_insert_macro_call_parens_unncessary);
+                mark::hit!(dont_insert_macro_call_parens_unncessary);
                 builder.insert_text(name)
             }
         };
@@ -206,7 +211,7 @@ impl Completions {
             .parameter_names
             .iter()
             .skip(if function_signature.has_self_param { 1 } else { 0 })
-            .cloned()
+            .map(|name| name.trim_start_matches('_').into())
             .collect();
 
         builder = builder.add_call_parens(ctx, name, Params::Named(params));
@@ -319,19 +324,20 @@ impl Completions {
 
 pub(crate) fn compute_score(
     ctx: &CompletionContext,
-    // FIXME: this definitely should be a `Type`
-    ty: &str,
+    ty: &Type,
     name: &str,
 ) -> Option<CompletionScore> {
+    // FIXME: this should not fall back to string equality.
+    let ty = &ty.display(ctx.db).to_string();
     let (active_name, active_type) = if let Some(record_field) = &ctx.record_field_syntax {
-        tested_by!(test_struct_field_completion_in_record_lit);
+        mark::hit!(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);
+        mark::hit!(test_struct_field_completion_in_func_call);
         (active_parameter.name.clone(), active_parameter.ty.clone())
     } else {
         return None;
@@ -392,7 +398,7 @@ impl Builder {
             None => return self,
         };
         // If not an import, add parenthesis automatically.
-        tested_by!(inserts_parens_for_function_calls);
+        mark::hit!(inserts_parens_for_function_calls);
 
         let (snippet, label) = if params.is_empty() {
             (format!("{}()$0", name), format!("{}()", name))
@@ -451,7 +457,7 @@ fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static s
 #[cfg(test)]
 mod tests {
     use insta::assert_debug_snapshot;
-    use test_utils::covers;
+    use test_utils::mark;
 
     use crate::completion::{
         test_utils::{do_completion, do_completion_with_options},
@@ -601,7 +607,7 @@ mod tests {
 
     #[test]
     fn inserts_parens_for_function_calls() {
-        covers!(inserts_parens_for_function_calls);
+        mark::check!(inserts_parens_for_function_calls);
         assert_debug_snapshot!(
             do_reference_completion(
                 r"
@@ -666,6 +672,37 @@ mod tests {
         assert_debug_snapshot!(
             do_reference_completion(
                 r"
+                fn with_ignored_args(_foo: i32, ___bar: bool, ho_ge_: String) {}
+                fn main() { with_<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "main()",
+                source_range: 110..115,
+                delete: 110..115,
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+            CompletionItem {
+                label: "with_ignored_args(…)",
+                source_range: 110..115,
+                delete: 110..115,
+                insert: "with_ignored_args(${1:foo}, ${2:bar}, ${3:ho_ge_})$0",
+                kind: Function,
+                lookup: "with_ignored_args",
+                detail: "fn with_ignored_args(_foo: i32, ___bar: bool, ho_ge_: String)",
+                trigger_call_info: true,
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
                 struct S {}
                 impl S {
                     fn foo(&self) {}
@@ -689,6 +726,33 @@ mod tests {
         ]
         "###
         );
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct S {}
+                impl S {
+                    fn foo_ignored_args(&self, _a: bool, b: i32) {}
+                }
+                fn bar(s: &S) {
+                    s.f<|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo_ignored_args(…)",
+                source_range: 194..195,
+                delete: 194..195,
+                insert: "foo_ignored_args(${1:a}, ${2:b})$0",
+                kind: Method,
+                lookup: "foo_ignored_args",
+                detail: "fn foo_ignored_args(&self, _a: bool, b: i32)",
+                trigger_call_info: true,
+            },
+        ]
+        "###
+        );
     }
 
     #[test]
@@ -986,7 +1050,7 @@ mod tests {
 
     #[test]
     fn inserts_angle_brackets_for_generics() {
-        covers!(inserts_angle_brackets_for_generics);
+        mark::check!(inserts_angle_brackets_for_generics);
         assert_debug_snapshot!(
             do_reference_completion(
                 r"
@@ -1109,7 +1173,7 @@ mod tests {
 
     #[test]
     fn dont_insert_macro_call_parens_unncessary() {
-        covers!(dont_insert_macro_call_parens_unncessary);
+        mark::check!(dont_insert_macro_call_parens_unncessary);
         assert_debug_snapshot!(
             do_reference_completion(
                 r"
@@ -1175,7 +1239,7 @@ mod tests {
 
     #[test]
     fn test_struct_field_completion_in_func_call() {
-        covers!(test_struct_field_completion_in_func_call);
+        mark::check!(test_struct_field_completion_in_func_call);
         assert_debug_snapshot!(
         do_reference_completion(
                 r"
@@ -1265,7 +1329,7 @@ mod tests {
 
     #[test]
     fn test_struct_field_completion_in_record_lit() {
-        covers!(test_struct_field_completion_in_record_lit);
+        mark::check!(test_struct_field_completion_in_record_lit);
         assert_debug_snapshot!(
         do_reference_completion(
                 r"
@@ -1405,4 +1469,48 @@ mod tests {
         "###
         );
     }
+
+    #[test]
+    fn prioritize_exact_ref_match() {
+        assert_debug_snapshot!(
+        do_reference_completion(
+                r"
+                    struct WorldSnapshot { _f: () };
+                    fn go(world: &WorldSnapshot) {
+                        go(w<|>)
+                    }
+                    ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "WorldSnapshot",
+                source_range: 132..133,
+                delete: 132..133,
+                insert: "WorldSnapshot",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "go(…)",
+                source_range: 132..133,
+                delete: 132..133,
+                insert: "go(${1:world})$0",
+                kind: Function,
+                lookup: "go",
+                detail: "fn go(world: &WorldSnapshot)",
+                trigger_call_info: true,
+            },
+            CompletionItem {
+                label: "world",
+                source_range: 132..133,
+                delete: 132..133,
+                insert: "world",
+                kind: Binding,
+                detail: "&WorldSnapshot",
+                score: TypeAndNameMatch,
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index eb90b5279..bf22452a2 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -20,7 +20,7 @@ pub(crate) fn do_completion_with_options(
     } else {
         single_file_with_position(code)
     };
-    let completions = analysis.completions(position, options).unwrap().unwrap();
+    let completions = analysis.completions(options, position).unwrap().unwrap();
     let completion_items: Vec<CompletionItem> = completions.into();
     let mut kind_completions: Vec<CompletionItem> =
         completion_items.into_iter().filter(|c| c.completion_kind == kind).collect();
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index a6b4c2c28..15dc50cf1 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -21,7 +21,7 @@ use ra_syntax::{
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
 
-use crate::{Diagnostic, FileId, FileSystemEdit, SourceChange, SourceFileEdit};
+use crate::{Diagnostic, FileId, FileSystemEdit, Fix, SourceChange, SourceFileEdit};
 
 #[derive(Debug, Copy, Clone)]
 pub enum Severity {
@@ -63,8 +63,8 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
             .parent()
             .unwrap_or_else(|| RelativePath::new(""))
             .join(&d.candidate);
-        let create_file = FileSystemEdit::CreateFile { source_root, path };
-        let fix = SourceChange::file_system_edit("create module", create_file);
+        let fix =
+            Fix::new("Create module", FileSystemEdit::CreateFile { source_root, path }.into());
         res.borrow_mut().push(Diagnostic {
             range: sema.diagnostics_range(d).range,
             message: d.message(),
@@ -88,14 +88,12 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
                 field_list = field_list.append_field(&field);
             }
 
-            let mut builder = TextEditBuilder::default();
-            algo::diff(&d.ast(db).syntax(), &field_list.syntax()).into_text_edit(&mut builder);
-
-            Some(SourceChange::source_file_edit_from(
-                "fill struct fields",
-                file_id,
-                builder.finish(),
-            ))
+            let edit = {
+                let mut builder = TextEditBuilder::default();
+                algo::diff(&d.ast(db).syntax(), &field_list.syntax()).into_text_edit(&mut builder);
+                builder.finish()
+            };
+            Some(Fix::new("Fill struct fields", SourceFileEdit { file_id, edit }.into()))
         };
 
         res.borrow_mut().push(Diagnostic {
@@ -117,7 +115,8 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
         let node = d.ast(db);
         let replacement = format!("Ok({})", node.syntax());
         let edit = TextEdit::replace(node.syntax().text_range(), replacement);
-        let fix = SourceChange::source_file_edit_from("wrap with ok", file_id, edit);
+        let source_change = SourceChange::source_file_edit_from(file_id, edit);
+        let fix = Fix::new("Wrap with ok", source_change);
         res.borrow_mut().push(Diagnostic {
             range: sema.diagnostics_range(d).range,
             message: d.message(),
@@ -154,9 +153,9 @@ fn check_unnecessary_braces_in_use_statement(
             range,
             message: "Unnecessary braces in use statement".to_string(),
             severity: Severity::WeakWarning,
-            fix: Some(SourceChange::source_file_edit(
+            fix: Some(Fix::new(
                 "Remove unnecessary braces",
-                SourceFileEdit { file_id, edit },
+                SourceFileEdit { file_id, edit }.into(),
             )),
         });
     }
@@ -198,9 +197,9 @@ fn check_struct_shorthand_initialization(
                     range: record_field.syntax().text_range(),
                     message: "Shorthand struct initialization".to_string(),
                     severity: Severity::WeakWarning,
-                    fix: Some(SourceChange::source_file_edit(
-                        "use struct shorthand initialization",
-                        SourceFileEdit { file_id, edit },
+                    fix: Some(Fix::new(
+                        "Use struct shorthand initialization",
+                        SourceFileEdit { file_id, edit }.into(),
                     )),
                 });
             }
@@ -240,8 +239,12 @@ mod tests {
         let diagnostic =
             diagnostics.pop().unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
         let mut fix = diagnostic.fix.unwrap();
-        let edit = fix.source_file_edits.pop().unwrap().edit;
-        let actual = edit.apply(&before);
+        let edit = fix.source_change.source_file_edits.pop().unwrap().edit;
+        let actual = {
+            let mut actual = before.to_string();
+            edit.apply(&mut actual);
+            actual
+        };
         assert_eq_text!(after, &actual);
     }
 
@@ -254,9 +257,13 @@ mod tests {
         let (analysis, file_position) = analysis_and_position(fixture);
         let diagnostic = analysis.diagnostics(file_position.file_id).unwrap().pop().unwrap();
         let mut fix = diagnostic.fix.unwrap();
-        let edit = fix.source_file_edits.pop().unwrap().edit;
+        let edit = fix.source_change.source_file_edits.pop().unwrap().edit;
         let target_file_contents = analysis.file_text(file_position.file_id).unwrap();
-        let actual = edit.apply(&target_file_contents);
+        let actual = {
+            let mut actual = target_file_contents.to_string();
+            edit.apply(&mut actual);
+            actual
+        };
 
         // Strip indent and empty lines from `after`, to match the behaviour of
         // `parse_fixture` called from `analysis_and_position`.
@@ -287,8 +294,12 @@ mod tests {
         let (analysis, file_id) = single_file(before);
         let diagnostic = analysis.diagnostics(file_id).unwrap().pop().unwrap();
         let mut fix = diagnostic.fix.unwrap();
-        let edit = fix.source_file_edits.pop().unwrap().edit;
-        let actual = edit.apply(&before);
+        let edit = fix.source_change.source_file_edits.pop().unwrap().edit;
+        let actual = {
+            let mut actual = before.to_string();
+            edit.apply(&mut actual);
+            actual
+        };
         assert_eq_text!(after, &actual);
     }
 
@@ -604,22 +615,24 @@ mod tests {
             Diagnostic {
                 message: "unresolved module",
                 range: 0..8,
+                severity: Error,
                 fix: Some(
-                    SourceChange {
-                        label: "create module",
-                        source_file_edits: [],
-                        file_system_edits: [
-                            CreateFile {
-                                source_root: SourceRootId(
-                                    0,
-                                ),
-                                path: "foo.rs",
-                            },
-                        ],
-                        cursor_position: None,
+                    Fix {
+                        label: "Create module",
+                        source_change: SourceChange {
+                            source_file_edits: [],
+                            file_system_edits: [
+                                CreateFile {
+                                    source_root: SourceRootId(
+                                        0,
+                                    ),
+                                    path: "foo.rs",
+                                },
+                            ],
+                            is_snippet: false,
+                        },
                     },
                 ),
-                severity: Error,
             },
         ]
         "###);
@@ -651,31 +664,33 @@ mod tests {
         assert_debug_snapshot!(diagnostics, @r###"
         [
             Diagnostic {
-                message: "Missing structure fields:\n- b",
+                message: "Missing structure fields:\n- b\n",
                 range: 224..233,
+                severity: Error,
                 fix: Some(
-                    SourceChange {
-                        label: "fill struct fields",
-                        source_file_edits: [
-                            SourceFileEdit {
-                                file_id: FileId(
-                                    1,
-                                ),
-                                edit: TextEdit {
-                                    atoms: [
-                                        AtomTextEdit {
-                                            delete: 3..9,
-                                            insert: "{a:42, b: ()}",
-                                        },
-                                    ],
+                    Fix {
+                        label: "Fill struct fields",
+                        source_change: SourceChange {
+                            source_file_edits: [
+                                SourceFileEdit {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    edit: TextEdit {
+                                        indels: [
+                                            Indel {
+                                                insert: "{a:42, b: ()}",
+                                                delete: 3..9,
+                                            },
+                                        ],
+                                    },
                                 },
-                            },
-                        ],
-                        file_system_edits: [],
-                        cursor_position: None,
+                            ],
+                            file_system_edits: [],
+                            is_snippet: false,
+                        },
                     },
                 ),
-                severity: Error,
             },
         ]
         "###);
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index 722092de9..827c094e7 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -79,16 +79,17 @@ pub(crate) fn rust_code_markup_with_doc(
     doc: Option<&str>,
     mod_path: Option<&str>,
 ) -> String {
-    let mut buf = "```rust\n".to_owned();
+    let mut buf = String::new();
 
     if let Some(mod_path) = mod_path {
         if !mod_path.is_empty() {
-            format_to!(buf, "{}\n", mod_path);
+            format_to!(buf, "```rust\n{}\n```\n\n", mod_path);
         }
     }
-    format_to!(buf, "{}\n```", code);
+    format_to!(buf, "```rust\n{}\n```", code);
 
     if let Some(doc) = doc {
+        format_to!(buf, "\n___");
         format_to!(buf, "\n\n{}", doc);
     }
 
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index db3907fe6..9572debd8 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -1,5 +1,7 @@
 //! FIXME: write short doc here
 
+// FIXME: this modules relies on strings and AST way too much, and it should be
+// rewritten (matklad 2020-05-07)
 use std::{
     convert::From,
     fmt::{self, Display},
@@ -82,8 +84,8 @@ impl FunctionSignature {
             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());
+            if let Some(param_type) = raw_param.split(':').nth(1).and_then(|it| it.get(1..)) {
+                parameter_types.push(param_type.to_string());
             } else {
                 // useful when you have tuple struct
                 parameter_types.push(raw_param.clone());
@@ -127,8 +129,8 @@ impl FunctionSignature {
         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());
+            if let Some(param_type) = raw_param.split(':').nth(1).and_then(|it| it.get(1..)) {
+                parameter_types.push(param_type.to_string());
             } else {
                 // The unwrap_or_else is useful when you have tuple
                 parameter_types.push(raw_param);
@@ -195,14 +197,23 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
                     let raw_param = self_param.syntax().text().to_string();
 
                     res_types.push(
-                        raw_param.split(':').nth(1).unwrap_or_else(|| " Self")[1..].to_string(),
+                        raw_param
+                            .split(':')
+                            .nth(1)
+                            .and_then(|it| it.get(1..))
+                            .unwrap_or_else(|| "Self")
+                            .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()
+                    let param_text = param.syntax().text().to_string();
+                    match param_text.split(':').nth(1).and_then(|it| it.get(1..)) {
+                        Some(it) => it.to_string(),
+                        None => param_text,
+                    }
                 }));
             }
             (has_self_param, res, res_types)
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 914a8b471..c7bb1e69f 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
     TextRange,
 };
 
-use crate::FileSymbol;
+use crate::{FileRange, FileSymbol};
 
 use super::short_label::ShortLabel;
 
@@ -22,10 +22,11 @@ use super::short_label::ShortLabel;
 /// code, like a function or a struct, but this is not strictly required.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NavigationTarget {
+    // FIXME: use FileRange?
     file_id: FileId,
+    full_range: TextRange,
     name: SmolStr,
     kind: SyntaxKind,
-    full_range: TextRange,
     focus_range: Option<TextRange>,
     container_name: Option<SmolStr>,
     description: Option<String>,
@@ -63,6 +64,10 @@ impl NavigationTarget {
         self.file_id
     }
 
+    pub fn file_range(&self) -> FileRange {
+        FileRange { file_id: self.file_id, range: self.full_range }
+    }
+
     pub fn full_range(&self) -> TextRange {
         self.full_range
     }
@@ -87,15 +92,16 @@ impl NavigationTarget {
         let name = module.name(db).map(|it| it.to_string().into()).unwrap_or_default();
         if let Some(src) = module.declaration_source(db) {
             let frange = original_range(db, src.as_ref().map(|it| it.syntax()));
-            return NavigationTarget::from_syntax(
+            let mut res = NavigationTarget::from_syntax(
                 frange.file_id,
                 name,
                 None,
                 frange.range,
                 src.value.syntax().kind(),
-                src.value.doc_comment_text(),
-                src.value.short_label(),
             );
+            res.docs = src.value.doc_comment_text();
+            res.description = src.value.short_label();
+            return res;
         }
         module.to_nav(db)
     }
@@ -125,11 +131,9 @@ impl NavigationTarget {
     }
 
     /// Allows `NavigationTarget` to be created from a `NameOwner`
-    fn from_named(
+    pub(crate) fn from_named(
         db: &RootDatabase,
         node: InFile<&dyn ast::NameOwner>,
-        docs: Option<String>,
-        description: Option<String>,
     ) -> NavigationTarget {
         //FIXME: use `_` instead of empty string
         let name = node.value.name().map(|it| it.text().clone()).unwrap_or_default();
@@ -143,8 +147,6 @@ impl NavigationTarget {
             focus_range,
             frange.range,
             node.value.syntax().kind(),
-            docs,
-            description,
         )
     }
 
@@ -154,8 +156,6 @@ impl NavigationTarget {
         focus_range: Option<TextRange>,
         full_range: TextRange,
         kind: SyntaxKind,
-        docs: Option<String>,
-        description: Option<String>,
     ) -> NavigationTarget {
         NavigationTarget {
             file_id,
@@ -164,8 +164,8 @@ impl NavigationTarget {
             full_range,
             focus_range,
             container_name: None,
-            description,
-            docs,
+            description: None,
+            docs: None,
         }
     }
 }
@@ -233,12 +233,11 @@ where
 {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
-        NavigationTarget::from_named(
-            db,
-            src.as_ref().map(|it| it as &dyn ast::NameOwner),
-            src.value.doc_comment_text(),
-            src.value.short_label(),
-        )
+        let mut res =
+            NavigationTarget::from_named(db, src.as_ref().map(|it| it as &dyn ast::NameOwner));
+        res.docs = src.value.doc_comment_text();
+        res.description = src.value.short_label();
+        res
     }
 }
 
@@ -253,15 +252,7 @@ impl ToNav for hir::Module {
             }
         };
         let frange = original_range(db, src.with_value(syntax));
-        NavigationTarget::from_syntax(
-            frange.file_id,
-            name,
-            focus,
-            frange.range,
-            syntax.kind(),
-            None,
-            None,
-        )
+        NavigationTarget::from_syntax(frange.file_id, name, focus, frange.range, syntax.kind())
     }
 }
 
@@ -280,8 +271,6 @@ impl ToNav for hir::ImplDef {
             None,
             frange.range,
             src.value.syntax().kind(),
-            None,
-            None,
         )
     }
 }
@@ -291,12 +280,12 @@ impl ToNav for hir::Field {
         let src = self.source(db);
 
         match &src.value {
-            FieldSource::Named(it) => NavigationTarget::from_named(
-                db,
-                src.with_value(it),
-                it.doc_comment_text(),
-                it.short_label(),
-            ),
+            FieldSource::Named(it) => {
+                let mut res = NavigationTarget::from_named(db, src.with_value(it));
+                res.docs = it.doc_comment_text();
+                res.description = it.short_label();
+                res
+            }
             FieldSource::Pos(it) => {
                 let frange = original_range(db, src.with_value(it.syntax()));
                 NavigationTarget::from_syntax(
@@ -305,8 +294,6 @@ impl ToNav for hir::Field {
                     None,
                     frange.range,
                     it.syntax().kind(),
-                    None,
-                    None,
                 )
             }
         }
@@ -317,12 +304,10 @@ impl ToNav for hir::MacroDef {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
         log::debug!("nav target {:#?}", src.value.syntax());
-        NavigationTarget::from_named(
-            db,
-            src.as_ref().map(|it| it as &dyn ast::NameOwner),
-            src.value.doc_comment_text(),
-            None,
-        )
+        let mut res =
+            NavigationTarget::from_named(db, src.as_ref().map(|it| it as &dyn ast::NameOwner));
+        res.docs = src.value.doc_comment_text();
+        res
     }
 }
 
@@ -376,16 +361,20 @@ impl ToNav for hir::Local {
 impl ToNav for hir::TypeParam {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
-        let range = match src.value {
+        let full_range = match &src.value {
             Either::Left(it) => it.syntax().text_range(),
             Either::Right(it) => it.syntax().text_range(),
         };
+        let focus_range = match &src.value {
+            Either::Left(_) => None,
+            Either::Right(it) => it.name().map(|it| it.syntax().text_range()),
+        };
         NavigationTarget {
             file_id: src.file_id.original_file(db),
             name: self.name(db).to_string().into(),
             kind: TYPE_PARAM,
-            full_range: range,
-            focus_range: None,
+            full_range,
+            focus_range,
             container_name: None,
             description: None,
             docs: None,
diff --git a/crates/ra_ide/src/display/short_label.rs b/crates/ra_ide/src/display/short_label.rs
index 4b081bf6c..d37260e96 100644
--- a/crates/ra_ide/src/display/short_label.rs
+++ b/crates/ra_ide/src/display/short_label.rs
@@ -33,7 +33,11 @@ impl ShortLabel for ast::EnumDef {
 
 impl ShortLabel for ast::TraitDef {
     fn short_label(&self) -> Option<String> {
-        short_label_from_node(self, "trait ")
+        if self.unsafe_token().is_some() {
+            short_label_from_node(self, "unsafe trait ")
+        } else {
+            short_label_from_node(self, "trait ")
+        }
     }
 }
 
diff --git a/crates/ra_ide/src/display/structure.rs b/crates/ra_ide/src/display/structure.rs
index 967eee5d2..aad5a8e4d 100644
--- a/crates/ra_ide/src/display/structure.rs
+++ b/crates/ra_ide/src/display/structure.rs
@@ -1,10 +1,6 @@
-//! FIXME: write short doc here
-
-use crate::TextRange;
-
 use ra_syntax::{
     ast::{self, AttrsOwner, NameOwner, TypeAscriptionOwner, TypeParamsOwner},
-    match_ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, WalkEvent,
+    match_ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, TextRange, WalkEvent,
 };
 
 #[derive(Debug, Clone)]
@@ -18,6 +14,19 @@ pub struct StructureNode {
     pub deprecated: bool,
 }
 
+// Feature: File Structure
+//
+// Provides a tree of the symbols defined in the file. Can be used to
+//
+// * fuzzy search symbol in a file (super useful)
+// * draw breadcrumbs to describe the context around the cursor
+// * draw outline of the file
+//
+// |===
+// | Editor  | Shortcut
+//
+// | VS Code | kbd:[Ctrl+Shift+O]
+// |===
 pub fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
     let mut res = Vec::new();
     let mut stack = Vec::new();
diff --git a/crates/ra_ide/src/expand_macro.rs b/crates/ra_ide/src/expand_macro.rs
index f536ba3e7..54a47aac0 100644
--- a/crates/ra_ide/src/expand_macro.rs
+++ b/crates/ra_ide/src/expand_macro.rs
@@ -1,5 +1,3 @@
-//! This modules implements "expand macro" functionality in the IDE
-
 use hir::Semantics;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
@@ -14,6 +12,15 @@ pub struct ExpandedMacro {
     pub expansion: String,
 }
 
+// Feature: Expand Macro Recursively
+//
+// Shows the full macro expansion of the macro at current cursor.
+//
+// |===
+// | Editor  | Action Name
+//
+// | VS Code | **Rust Analyzer: Expand macro recursively**
+// |===
 pub(crate) fn expand_macro(db: &RootDatabase, position: FilePosition) -> Option<ExpandedMacro> {
     let sema = Semantics::new(db);
     let file = sema.parse(position.file_id);
diff --git a/crates/ra_ide/src/extend_selection.rs b/crates/ra_ide/src/extend_selection.rs
index 554594a43..a4bc93cdb 100644
--- a/crates/ra_ide/src/extend_selection.rs
+++ b/crates/ra_ide/src/extend_selection.rs
@@ -1,5 +1,3 @@
-//! FIXME: write short doc here
-
 use std::iter::successors;
 
 use hir::Semantics;
@@ -14,6 +12,16 @@ use ra_syntax::{
 
 use crate::FileRange;
 
+// Feature: Extend Selection
+//
+// Extends the current selection to the encompassing syntactic construct
+// (expression, statement, item, module, etc). It works with multiple cursors.
+//
+// |===
+// | Editor  | Shortcut
+//
+// | VS Code | kbd:[Ctrl+Shift+→]
+// |===
 pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
     let sema = Semantics::new(db);
     let src = sema.parse(frange.file_id);
diff --git a/crates/ra_ide/src/folding_ranges.rs b/crates/ra_ide/src/folding_ranges.rs
index 4379005aa..8657377de 100644
--- a/crates/ra_ide/src/folding_ranges.rs
+++ b/crates/ra_ide/src/folding_ranges.rs
@@ -88,7 +88,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
         | ITEM_LIST
         | EXTERN_ITEM_LIST
         | USE_TREE_LIST
-        | BLOCK
+        | BLOCK_EXPR
         | MATCH_ARM_LIST
         | ENUM_VARIANT_LIST
         | TOKEN_TREE => Some(FoldKind::Block),
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index 1dfca819d..a6c86e99c 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -1,5 +1,3 @@
-//! FIXME: write short doc here
-
 use hir::Semantics;
 use ra_ide_db::{
     defs::{classify_name, classify_name_ref},
@@ -17,6 +15,15 @@ use crate::{
     FilePosition, NavigationTarget, RangeInfo,
 };
 
+// Feature: Go to Definition
+//
+// Navigates to the definition of an identifier.
+//
+// |===
+// | Editor  | Shortcut
+//
+// | VS Code | kbd:[F12]
+// |===
 pub(crate) fn goto_definition(
     db: &RootDatabase,
     position: FilePosition,
@@ -93,7 +100,7 @@ pub(crate) fn reference_definition(
 
 #[cfg(test)]
 mod tests {
-    use test_utils::{assert_eq_text, covers};
+    use test_utils::assert_eq_text;
 
     use crate::mock_analysis::analysis_and_position;
 
@@ -208,7 +215,6 @@ mod tests {
 
     #[test]
     fn goto_def_for_macros() {
-        covers!(ra_ide_db::goto_def_for_macros);
         check_goto(
             "
             //- /lib.rs
@@ -225,7 +231,6 @@ mod tests {
 
     #[test]
     fn goto_def_for_macros_from_other_crates() {
-        covers!(ra_ide_db::goto_def_for_macros);
         check_goto(
             "
             //- /lib.rs
@@ -244,6 +249,38 @@ mod tests {
     }
 
     #[test]
+    fn goto_def_for_use_alias() {
+        check_goto(
+            "
+            //- /lib.rs
+            use foo as bar<|>;
+
+
+            //- /foo/lib.rs
+            #[macro_export]
+            macro_rules! foo { () => { () } }",
+            "SOURCE_FILE FileId(2) 0..50",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }\n",
+        );
+    }
+
+    #[test]
+    fn goto_def_for_use_alias_foo_macro() {
+        check_goto(
+            "
+            //- /lib.rs
+            use foo::foo as bar<|>;
+
+            //- /foo/lib.rs
+            #[macro_export]
+            macro_rules! foo { () => { () } }
+            ",
+            "foo MACRO_CALL FileId(2) 0..49 29..32",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
+        );
+    }
+
+    #[test]
     fn goto_def_for_macros_in_use_tree() {
         check_goto(
             "
@@ -337,7 +374,6 @@ mod tests {
 
     #[test]
     fn goto_def_for_methods() {
-        covers!(ra_ide_db::goto_def_for_methods);
         check_goto(
             "
             //- /lib.rs
@@ -357,7 +393,6 @@ mod tests {
 
     #[test]
     fn goto_def_for_fields() {
-        covers!(ra_ide_db::goto_def_for_fields);
         check_goto(
             r"
             //- /lib.rs
@@ -376,7 +411,6 @@ mod tests {
 
     #[test]
     fn goto_def_for_record_fields() {
-        covers!(ra_ide_db::goto_def_for_record_fields);
         check_goto(
             r"
             //- /lib.rs
@@ -397,7 +431,6 @@ mod tests {
 
     #[test]
     fn goto_def_for_record_pat_fields() {
-        covers!(ra_ide_db::goto_def_for_record_field_pats);
         check_goto(
             r"
             //- /lib.rs
@@ -754,14 +787,14 @@ mod tests {
     #[test]
     fn goto_for_type_param() {
         check_goto(
-            "
+            r#"
             //- /lib.rs
-            struct Foo<T> {
+            struct Foo<T: Clone> {
                 t: <|>T,
             }
-            ",
-            "T TYPE_PARAM FileId(1) 11..12",
-            "T",
+            "#,
+            "T TYPE_PARAM FileId(1) 11..19 11..12",
+            "T: Clone|T",
         );
     }
 
@@ -840,7 +873,6 @@ mod tests {
 
     #[test]
     fn goto_def_for_field_init_shorthand() {
-        covers!(ra_ide_db::goto_def_for_field_init_shorthand);
         check_goto(
             "
             //- /lib.rs
diff --git a/crates/ra_ide/src/impls.rs b/crates/ra_ide/src/goto_implementation.rs
index ea2225f70..0cec0657e 100644
--- a/crates/ra_ide/src/impls.rs
+++ b/crates/ra_ide/src/goto_implementation.rs
@@ -1,11 +1,18 @@
-//! FIXME: write short doc here
-
 use hir::{Crate, ImplDef, Semantics};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
 
 use crate::{display::ToNav, FilePosition, NavigationTarget, RangeInfo};
 
+// Feature: Go to Implementation
+//
+// Navigates to the impl block of structs, enums or traits. Also implemented as a code lens.
+//
+// |===
+// | Editor  | Shortcut
+//
+// | VS Code | kbd:[Ctrl+F12]
+// |===
 pub(crate) fn goto_implementation(
     db: &RootDatabase,
     position: FilePosition,
diff --git a/crates/ra_ide/src/goto_type_definition.rs b/crates/ra_ide/src/goto_type_definition.rs
index a84637489..91a3097fb 100644
--- a/crates/ra_ide/src/goto_type_definition.rs
+++ b/crates/ra_ide/src/goto_type_definition.rs
@@ -1,10 +1,17 @@
-//! FIXME: write short doc here
-
 use ra_ide_db::RootDatabase;
 use ra_syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
 
 use crate::{display::ToNav, FilePosition, NavigationTarget, RangeInfo};
 
+// Feature: Go to Type Definition
+//
+// Navigates to the type of an identifier.
+//
+// |===
+// | Editor  | Action Name
+//
+// | VS Code | **Go to Type Definition*
+// |===
 pub(crate) fn goto_type_definition(
     db: &RootDatabase,
     position: FilePosition,
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index a62f598f0..d96cb5596 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -1,10 +1,10 @@
-//! Logic for computing info that is displayed when the user hovers over any
-//! source code items (e.g. function call, struct field, variable symbol...)
+use std::iter::once;
 
 use hir::{
     Adt, AsAssocItem, AssocItemContainer, FieldSource, HasSource, HirDisplay, ModuleDef,
     ModuleSource, Semantics,
 };
+use itertools::Itertools;
 use ra_db::SourceDatabase;
 use ra_ide_db::{
     defs::{classify_name, classify_name_ref, Definition},
@@ -21,8 +21,6 @@ use crate::{
     display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel},
     FilePosition, RangeInfo,
 };
-use itertools::Itertools;
-use std::iter::once;
 
 /// Contains the results when hovering over an item
 #[derive(Debug, Default)]
@@ -62,6 +60,63 @@ impl HoverResult {
     }
 }
 
+// Feature: Hover
+//
+// Shows additional information, like type of an expression or documentation for definition when "focusing" code.
+// Focusing is usually hovering with a mouse, but can also be triggered with a shortcut.
+pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<HoverResult>> {
+    let sema = Semantics::new(db);
+    let file = sema.parse(position.file_id).syntax().clone();
+    let token = pick_best(file.token_at_offset(position.offset))?;
+    let token = sema.descend_into_macros(token);
+
+    let mut res = HoverResult::new();
+
+    if let Some((node, name_kind)) = match_ast! {
+        match (token.parent()) {
+            ast::NameRef(name_ref) => {
+                classify_name_ref(&sema, &name_ref).map(|d| (name_ref.syntax().clone(), d.definition()))
+            },
+            ast::Name(name) => {
+                classify_name(&sema, &name).map(|d| (name.syntax().clone(), d.definition()))
+            },
+            _ => None,
+        }
+    } {
+        let range = sema.original_range(&node).range;
+        res.extend(hover_text_from_name_kind(db, name_kind));
+
+        if !res.is_empty() {
+            return Some(RangeInfo::new(range, res));
+        }
+    }
+
+    let node = token
+        .ancestors()
+        .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
+
+    let ty = match_ast! {
+        match node {
+            ast::MacroCall(_it) => {
+                // If this node is a MACRO_CALL, it means that `descend_into_macros` failed to resolve.
+                // (e.g expanding a builtin macro). So we give up here.
+                return None;
+            },
+            ast::Expr(it) => {
+                sema.type_of_expr(&it)
+            },
+            ast::Pat(it) => {
+                sema.type_of_pat(&it)
+            },
+            _ => None,
+        }
+    }?;
+
+    res.extend(Some(rust_code_markup(&ty.display(db))));
+    let range = sema.original_range(&node).range;
+    Some(RangeInfo::new(range, res))
+}
+
 fn hover_text(
     docs: Option<String>,
     desc: Option<String>,
@@ -143,7 +198,7 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<Strin
             ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path),
             ModuleDef::BuiltinType(it) => Some(it.to_string()),
         },
-        Definition::Local(it) => Some(rust_code_markup(&it.ty(db).display_truncated(db, None))),
+        Definition::Local(it) => Some(rust_code_markup(&it.ty(db).display(db))),
         Definition::TypeParam(_) | Definition::SelfType(_) => {
             // FIXME: Hover for generic param
             None
@@ -160,59 +215,6 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<Strin
     }
 }
 
-pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<HoverResult>> {
-    let sema = Semantics::new(db);
-    let file = sema.parse(position.file_id).syntax().clone();
-    let token = pick_best(file.token_at_offset(position.offset))?;
-    let token = sema.descend_into_macros(token);
-
-    let mut res = HoverResult::new();
-
-    if let Some((node, name_kind)) = match_ast! {
-        match (token.parent()) {
-            ast::NameRef(name_ref) => {
-                classify_name_ref(&sema, &name_ref).map(|d| (name_ref.syntax().clone(), d.definition()))
-            },
-            ast::Name(name) => {
-                classify_name(&sema, &name).map(|d| (name.syntax().clone(), d.definition()))
-            },
-            _ => None,
-        }
-    } {
-        let range = sema.original_range(&node).range;
-        res.extend(hover_text_from_name_kind(db, name_kind));
-
-        if !res.is_empty() {
-            return Some(RangeInfo::new(range, res));
-        }
-    }
-
-    let node = token
-        .ancestors()
-        .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
-
-    let ty = match_ast! {
-        match node {
-            ast::MacroCall(_it) => {
-                // If this node is a MACRO_CALL, it means that `descend_into_macros` failed to resolve.
-                // (e.g expanding a builtin macro). So we give up here.
-                return None;
-            },
-            ast::Expr(it) => {
-                sema.type_of_expr(&it)
-            },
-            ast::Pat(it) => {
-                sema.type_of_pat(&it)
-            },
-            _ => None,
-        }
-    }?;
-
-    res.extend(Some(rust_code_markup(&ty.display_truncated(db, None))));
-    let range = sema.original_range(&node).range;
-    Some(RangeInfo::new(range, res))
-}
-
 fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
     return tokens.max_by_key(priority);
     fn priority(n: &SyntaxToken) -> usize {
@@ -280,6 +282,47 @@ mod tests {
     }
 
     #[test]
+    fn hover_shows_long_type_of_an_expression() {
+        check_hover_result(
+            r#"
+            //- /main.rs
+            struct Scan<A, B, C> {
+                a: A,
+                b: B,
+                c: C,
+            }
+
+            struct FakeIter<I> {
+                inner: I,
+            }
+
+            struct OtherStruct<T> {
+                i: T,
+            }
+
+            enum FakeOption<T> {
+                Some(T),
+                None,
+            }
+
+            fn scan<A, B, C>(a: A, b: B, c: C) -> FakeIter<Scan<OtherStruct<A>, B, C>> {
+                FakeIter { inner: Scan { a, b, c } }
+            }
+
+            fn main() {
+                let num: i32 = 55;
+                let closure = |memo: &mut u32, value: &u32, _another: &mut u32| -> FakeOption<u32> {
+                    FakeOption::Some(*memo + value)
+                };
+                let number = 5u32;
+                let mut iter<|> = scan(OtherStruct { i: num }, closure, number);
+            }
+            "#,
+            &["FakeIter<Scan<OtherStruct<OtherStruct<i32>>, |&mut u32, &u32, &mut u32| -> FakeOption<u32>, u32>>"],
+        );
+    }
+
+    #[test]
     fn hover_shows_fn_signature() {
         // Single file with result
         check_hover_result(
@@ -364,7 +407,7 @@ mod tests {
                 };
             }
         "#,
-            &["Foo\nfield_a: u32"],
+            &["Foo\n```\n\n```rust\nfield_a: u32"],
         );
 
         // Hovering over the field in the definition
@@ -381,7 +424,7 @@ mod tests {
                 };
             }
         "#,
-            &["Foo\nfield_a: u32"],
+            &["Foo\n```\n\n```rust\nfield_a: u32"],
         );
     }
 
@@ -405,7 +448,7 @@ mod tests {
     }
 
     #[test]
-    fn hover_omits_default_generic_types() {
+    fn hover_default_generic_types() {
         check_hover_result(
             r#"
 //- /main.rs
@@ -417,7 +460,7 @@ struct Test<K, T = u8> {
 fn main() {
     let zz<|> = Test { t: 23, k: 33 };
 }"#,
-            &["Test<i32>"],
+            &["Test<i32, u8>"],
         );
     }
 
@@ -434,7 +477,7 @@ fn main() {
             ",
         );
         let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("Option\nSome"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("Option\n```\n\n```rust\nSome"));
 
         let (analysis, position) = single_file_with_position(
             "
@@ -462,8 +505,12 @@ fn main() {
         "#,
             &["
 Option
+```
+
+```rust
 None
 ```
+___
 
 The None variant
             "
@@ -483,8 +530,12 @@ The None variant
         "#,
             &["
 Option
+```
+
+```rust
 Some
 ```
+___
 
 The Some variant
             "
@@ -565,7 +616,10 @@ fn func(foo: i32) { if true { <|>foo; }; }
             ",
         );
         let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("wrapper::Thing\nfn new() -> Thing"));
+        assert_eq!(
+            trim_markup_opt(hover.info.first()),
+            Some("wrapper::Thing\n```\n\n```rust\nfn new() -> Thing")
+        );
     }
 
     #[test]
@@ -841,7 +895,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
                 fo<|>o();
             }
             ",
-            &["fn foo()\n```\n\n<- `\u{3000}` here"],
+            &["fn foo()\n```\n___\n\n<- `\u{3000}` here"],
         );
     }
 
@@ -869,4 +923,32 @@ fn func(foo: i32) { if true { <|>foo; }; }
             &[r#"pub(crate) async unsafe extern "C" fn foo()"#],
         );
     }
+
+    #[test]
+    fn test_hover_trait_show_qualifiers() {
+        check_hover_result(
+            "
+            //- /lib.rs
+            unsafe trait foo<|>() {}
+            ",
+            &["unsafe trait foo"],
+        );
+    }
+
+    #[test]
+    fn test_hover_mod_with_same_name_as_function() {
+        check_hover_result(
+            "
+            //- /lib.rs
+            use self::m<|>y::Bar;
+
+            mod my {
+                pub struct Bar;
+            }
+
+            fn my() {}
+            ",
+            &["mod my"],
+        );
+    }
 }
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 98483df32..75bd3c96b 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -1,5 +1,3 @@
-//! This module defines multiple types of inlay hints and their visibility
-
 use hir::{Adt, HirDisplay, Semantics, Type};
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
@@ -9,6 +7,7 @@ use ra_syntax::{
 };
 
 use crate::{FileId, FunctionSignature};
+use stdx::to_lower_snake_case;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct InlayHintsConfig {
@@ -38,6 +37,26 @@ pub struct InlayHint {
     pub label: SmolStr,
 }
 
+// Feature: Inlay Hints
+//
+// rust-analyzer shows additional information inline with the source code.
+// Editors usually render this using read-only virtual text snippets interspersed with code.
+//
+// rust-analyzer shows hits for
+//
+// * types of local variables
+// * names of function arguments
+// * types of chained expressions
+//
+// **Note:** VS Code does not have native support for inlay hints https://github.com/microsoft/vscode/issues/16221[yet] and the hints are implemented using decorations.
+// This approach has limitations, the caret movement and bracket highlighting near the edges of the hint may be weird:
+// https://github.com/rust-analyzer/rust-analyzer/issues/1623[1], https://github.com/rust-analyzer/rust-analyzer/issues/3453[2].
+//
+// |===
+// | Editor  | Action Name
+//
+// | VS Code | **Rust Analyzer: Toggle inlay hints*
+// |===
 pub(crate) fn inlay_hints(
     db: &RootDatabase,
     file_id: FileId,
@@ -144,7 +163,7 @@ fn get_param_name_hints(
         .iter()
         .skip(n_params_to_skip)
         .zip(args)
-        .filter(|(param, arg)| should_show_param_hint(&fn_signature, param, &arg))
+        .filter(|(param, arg)| should_show_param_name_hint(sema, &fn_signature, param, &arg))
         .map(|(param_name, arg)| InlayHint {
             range: arg.syntax().text_range(),
             kind: InlayKind::ParameterHint,
@@ -181,7 +200,7 @@ fn get_bind_pat_hints(
 
 fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool {
     if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() {
-        let pat_text = bind_pat.syntax().to_string();
+        let pat_text = bind_pat.to_string();
         enum_data
             .variants(db)
             .into_iter()
@@ -198,7 +217,7 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
     }
 
     if let Some(Adt::Struct(s)) = pat_ty.as_adt() {
-        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.syntax().to_string() {
+        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.to_string() {
             return true;
         }
     }
@@ -230,15 +249,16 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
     false
 }
 
-fn should_show_param_hint(
+fn should_show_param_name_hint(
+    sema: &Semantics<RootDatabase>,
     fn_signature: &FunctionSignature,