57 files changed, 10368 insertions, 12652 deletions

diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
index defd8176f..cb7e62cd6 100644
--- a/crates/ra_ide/src/call_hierarchy.rs
+++ b/crates/ra_ide/src/call_hierarchy.rs
@@ -39,10 +39,11 @@ pub(crate) fn call_hierarchy(
 
 pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
     let sema = Semantics::new(db);
+
     // 1. Find all refs
     // 2. Loop through refs and determine unique fndef. This will become our `from: CallHierarchyItem,` in the reply.
     // 3. Add ranges relative to the start of the fndef.
-    let refs = references::find_all_refs(db, position, None)?;
+    let refs = references::find_all_refs(&sema, position, None)?;
 
     let mut calls = CallLocations::default();
 
@@ -96,7 +97,7 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
                     //FIXME: Type::as_callable is broken
                     let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
                     match callable_def {
-                        hir::CallableDef::FunctionId(it) => {
+                        hir::CallableDefId::FunctionId(it) => {
                             let fn_def: hir::Function = it.into();
                             let nav = fn_def.to_nav(db);
                             Some(nav)
@@ -145,12 +146,12 @@ mod tests {
     use crate::mock_analysis::analysis_and_position;
 
     fn check_hierarchy(
-        fixture: &str,
+        ra_fixture: &str,
         expected: &str,
         expected_incoming: &[&str],
         expected_outgoing: &[&str],
     ) {
-        let (analysis, pos) = analysis_and_position(fixture);
+        let (analysis, pos) = analysis_and_position(ra_fixture);
 
         let mut navs = analysis.call_hierarchy(pos).unwrap().unwrap().info;
         assert_eq!(navs.len(), 1);
@@ -177,12 +178,12 @@ mod tests {
     fn test_call_hierarchy_on_ref() {
         check_hierarchy(
             r#"
-            //- /lib.rs
-            fn callee() {}
-            fn caller() {
-                call<|>ee();
-            }
-            "#,
+//- /lib.rs
+fn callee() {}
+fn caller() {
+    call<|>ee();
+}
+"#,
             "callee FN_DEF FileId(1) 0..14 3..9",
             &["caller FN_DEF FileId(1) 15..44 18..24 : [33..39]"],
             &[],
@@ -193,12 +194,12 @@ mod tests {
     fn test_call_hierarchy_on_def() {
         check_hierarchy(
             r#"
-            //- /lib.rs
-            fn call<|>ee() {}
-            fn caller() {
-                callee();
-            }
-            "#,
+//- /lib.rs
+fn call<|>ee() {}
+fn caller() {
+    callee();
+}
+"#,
             "callee FN_DEF FileId(1) 0..14 3..9",
             &["caller FN_DEF FileId(1) 15..44 18..24 : [33..39]"],
             &[],
@@ -209,13 +210,13 @@ mod tests {
     fn test_call_hierarchy_in_same_fn() {
         check_hierarchy(
             r#"
-            //- /lib.rs
-            fn callee() {}
-            fn caller() {
-                call<|>ee();
-                callee();
-            }
-            "#,
+//- /lib.rs
+fn callee() {}
+fn caller() {
+    call<|>ee();
+    callee();
+}
+"#,
             "callee FN_DEF FileId(1) 0..14 3..9",
             &["caller FN_DEF FileId(1) 15..58 18..24 : [33..39, 47..53]"],
             &[],
@@ -226,20 +227,20 @@ mod tests {
     fn test_call_hierarchy_in_different_fn() {
         check_hierarchy(
             r#"
-            //- /lib.rs
-            fn callee() {}
-            fn caller1() {
-                call<|>ee();
-            }
+//- /lib.rs
+fn callee() {}
+fn caller1() {
+    call<|>ee();
+}
 
-            fn caller2() {
-                callee();
-            }
-            "#,
+fn caller2() {
+    callee();
+}
+"#,
             "callee FN_DEF FileId(1) 0..14 3..9",
             &[
                 "caller1 FN_DEF FileId(1) 15..45 18..25 : [34..40]",
-                "caller2 FN_DEF FileId(1) 46..76 49..56 : [65..71]",
+                "caller2 FN_DEF FileId(1) 47..77 50..57 : [66..72]",
             ],
             &[],
         );
@@ -249,26 +250,26 @@ mod tests {
     fn test_call_hierarchy_in_tests_mod() {
         check_hierarchy(
             r#"
-            //- /lib.rs cfg:test
-            fn callee() {}
-            fn caller1() {
-                call<|>ee();
-            }
+//- /lib.rs cfg:test
+fn callee() {}
+fn caller1() {
+    call<|>ee();
+}
 
-            #[cfg(test)]
-            mod tests {
-                use super::*;
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-                #[test]
-                fn test_caller() {
-                    callee();
-                }
-            }
-            "#,
+    #[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_caller FN_DEF FileId(1) 95..149 110..121 : [134..140]",
             ],
             &[],
         );
@@ -278,19 +279,19 @@ mod tests {
     fn test_call_hierarchy_in_different_files() {
         check_hierarchy(
             r#"
-            //- /lib.rs
-            mod foo;
-            use foo::callee;
+//- /lib.rs
+mod foo;
+use foo::callee;
 
-            fn caller() {
-                call<|>ee();
-            }
+fn caller() {
+    call<|>ee();
+}
 
-            //- /foo/mod.rs
-            pub fn callee() {}
-            "#,
+//- /foo/mod.rs
+pub fn callee() {}
+"#,
             "callee FN_DEF FileId(2) 0..18 7..13",
-            &["caller FN_DEF FileId(1) 26..55 29..35 : [44..50]"],
+            &["caller FN_DEF FileId(1) 27..56 30..36 : [45..51]"],
             &[],
         );
     }
@@ -299,13 +300,13 @@ mod tests {
     fn test_call_hierarchy_outgoing() {
         check_hierarchy(
             r#"
-            //- /lib.rs
-            fn callee() {}
-            fn call<|>er() {
-                callee();
-                callee();
-            }
-            "#,
+//- /lib.rs
+fn callee() {}
+fn call<|>er() {
+    callee();
+    callee();
+}
+"#,
             "caller FN_DEF FileId(1) 15..58 18..24",
             &[],
             &["callee FN_DEF FileId(1) 0..14 3..9 : [33..39, 47..53]"],
@@ -316,20 +317,20 @@ mod tests {
     fn test_call_hierarchy_outgoing_in_different_files() {
         check_hierarchy(
             r#"
-            //- /lib.rs
-            mod foo;
-            use foo::callee;
+//- /lib.rs
+mod foo;
+use foo::callee;
 
-            fn call<|>er() {
-                callee();
-            }
+fn call<|>er() {
+    callee();
+}
 
-            //- /foo/mod.rs
-            pub fn callee() {}
-            "#,
-            "caller FN_DEF FileId(1) 26..55 29..35",
+//- /foo/mod.rs
+pub fn callee() {}
+"#,
+            "caller FN_DEF FileId(1) 27..56 30..36",
             &[],
-            &["callee FN_DEF FileId(2) 0..18 7..13 : [44..50]"],
+            &["callee FN_DEF FileId(2) 0..18 7..13 : [45..51]"],
         );
     }
 
@@ -337,22 +338,59 @@ mod tests {
     fn test_call_hierarchy_incoming_outgoing() {
         check_hierarchy(
             r#"
-            //- /lib.rs
-            fn caller1() {
-                call<|>er2();
-            }
+//- /lib.rs
+fn caller1() {
+    call<|>er2();
+}
 
-            fn caller2() {
-                caller3();
-            }
+fn caller2() {
+    caller3();
+}
 
-            fn caller3() {
+fn caller3() {
 
-            }
-            "#,
-            "caller2 FN_DEF FileId(1) 32..63 35..42",
+}
+"#,
+            "caller2 FN_DEF FileId(1) 33..64 36..43",
             &["caller1 FN_DEF FileId(1) 0..31 3..10 : [19..26]"],
-            &["caller3 FN_DEF FileId(1) 64..80 67..74 : [51..58]"],
+            &["caller3 FN_DEF FileId(1) 66..83 69..76 : [52..59]"],
+        );
+    }
+
+    #[test]
+    fn test_call_hierarchy_issue_5103() {
+        check_hierarchy(
+            r#"
+fn a() {
+    b()
+}
+
+fn b() {}
+
+fn main() {
+    a<|>()
+}
+"#,
+            "a FN_DEF FileId(1) 0..18 3..4",
+            &["main FN_DEF FileId(1) 31..52 34..38 : [47..48]"],
+            &["b FN_DEF FileId(1) 20..29 23..24 : [13..14]"],
+        );
+
+        check_hierarchy(
+            r#"
+fn a() {
+    b<|>()
+}
+
+fn b() {}
+
+fn main() {
+    a()
+}
+"#,
+            "b FN_DEF FileId(1) 20..29 23..24",
+            &["a FN_DEF FileId(1) 0..18 3..4 : [13..14]"],
+            &[],
         );
     }
 }
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index aa039e6fc..1fe1c21de 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -7,7 +7,15 @@ use ra_syntax::{
 };
 use test_utils::mark;
 
-use crate::{CallInfo, FilePosition, FunctionSignature};
+use crate::{FilePosition, FunctionSignature};
+
+/// Contains information about a call site. Specifically the
+/// `FunctionSignature`and current parameter.
+#[derive(Debug)]
+pub struct CallInfo {
+    pub signature: FunctionSignature,
+    pub active_parameter: Option<usize>,
+}
 
 /// Computes parameter information for the given call expression.
 pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
@@ -40,43 +48,40 @@ fn call_info_for_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Op
     // Find the calling expression and it's NameRef
     let calling_node = FnCallNode::with_node(&token.parent())?;
 
-    let (mut call_info, has_self) = match &calling_node {
+    let signature = match &calling_node {
         FnCallNode::CallExpr(call) => {
             //FIXME: Type::as_callable is broken
             let callable_def = sema.type_of_expr(&call.expr()?)?.as_callable()?;
             match callable_def {
-                hir::CallableDef::FunctionId(it) => {
+                hir::CallableDefId::FunctionId(it) => {
                     let fn_def = it.into();
-                    (CallInfo::with_fn(sema.db, fn_def), fn_def.has_self_param(sema.db))
+                    FunctionSignature::from_hir(sema.db, fn_def)
                 }
-                hir::CallableDef::StructId(it) => {
-                    (CallInfo::with_struct(sema.db, it.into())?, false)
+                hir::CallableDefId::StructId(it) => {
+                    FunctionSignature::from_struct(sema.db, it.into())?
                 }
-                hir::CallableDef::EnumVariantId(it) => {
-                    (CallInfo::with_enum_variant(sema.db, it.into())?, false)
+                hir::CallableDefId::EnumVariantId(it) => {
+                    FunctionSignature::from_enum_variant(sema.db, it.into())?
                 }
             }
         }
         FnCallNode::MethodCallExpr(method_call) => {
             let function = sema.resolve_method_call(&method_call)?;
-            (CallInfo::with_fn(sema.db, function), function.has_self_param(sema.db))
+            FunctionSignature::from_hir(sema.db, function)
         }
         FnCallNode::MacroCallExpr(macro_call) => {
             let macro_def = sema.resolve_macro_call(&macro_call)?;
-            (CallInfo::with_macro(sema.db, macro_def)?, false)
+            FunctionSignature::from_macro(sema.db, macro_def)?
         }
     };
 
     // If we have a calling expression let's find which argument we are on
-    let num_params = call_info.parameters().len();
+    let num_params = signature.parameters.len();
 
-    match num_params {
-        0 => (),
-        1 => {
-            if !has_self {
-                call_info.active_parameter = Some(0);
-            }
-        }
+    let active_parameter = match num_params {
+        0 => None,
+        1 if signature.has_self_param => None,
+        1 => Some(0),
         _ => {
             if let Some(arg_list) = calling_node.arg_list() {
                 // Number of arguments specified at the call site
@@ -93,22 +98,24 @@ fn call_info_for_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Op
                     arg_list
                         .args()
                         .take_while(|arg| {
-                            arg.syntax().text_range().end() < token.text_range().start()
+                            arg.syntax().text_range().end() <= token.text_range().start()
                         })
                         .count(),
                 );
 
                 // If we are in a method account for `self`
-                if has_self {
+                if signature.has_self_param {
                     param += 1;
                 }
 
-                call_info.active_parameter = Some(param);
+                Some(param)
+            } else {
+                None
             }
         }
-    }
+    };
 
-    Some(call_info)
+    Some(CallInfo { signature, active_parameter })
 }
 
 #[derive(Debug)]
@@ -181,201 +188,192 @@ impl CallInfo {
         let res = ActiveParameter { ty, name };
         Some(res)
     }
-
-    fn with_fn(db: &RootDatabase, function: hir::Function) -> Self {
-        let signature = FunctionSignature::from_hir(db, function);
-
-        CallInfo { signature, active_parameter: None }
-    }
-
-    fn with_struct(db: &RootDatabase, st: hir::Struct) -> Option<Self> {
-        let signature = FunctionSignature::from_struct(db, st)?;
-
-        Some(CallInfo { signature, active_parameter: None })
-    }
-
-    fn with_enum_variant(db: &RootDatabase, variant: hir::EnumVariant) -> Option<Self> {
-        let signature = FunctionSignature::from_enum_variant(db, variant)?;
-
-        Some(CallInfo { signature, active_parameter: None })
-    }
-
-    fn with_macro(db: &RootDatabase, macro_def: hir::MacroDef) -> Option<Self> {
-        let signature = FunctionSignature::from_macro(db, macro_def)?;
-
-        Some(CallInfo { signature, active_parameter: None })
-    }
-
-    fn parameters(&self) -> &[String] {
-        &self.signature.parameters
-    }
 }
 
 #[cfg(test)]
 mod tests {
+    use expect::{expect, Expect};
     use test_utils::mark;
 
-    use crate::mock_analysis::single_file_with_position;
-
-    use super::*;
-
-    // These are only used when testing
-    impl CallInfo {
-        fn doc(&self) -> Option<hir::Documentation> {
-            self.signature.doc.clone()
-        }
-
-        fn label(&self) -> String {
-            self.signature.to_string()
-        }
-    }
-
-    fn call_info_helper(text: &str) -> Option<CallInfo> {
-        let (analysis, position) = single_file_with_position(text);
-        analysis.call_info(position).unwrap()
-    }
-
-    fn call_info(text: &str) -> CallInfo {
-        let info = call_info_helper(text);
-        assert!(info.is_some());
-        info.unwrap()
-    }
+    use crate::mock_analysis::analysis_and_position;
 
-    fn no_call_info(text: &str) {
-        let info = call_info_helper(text);
-        assert!(info.is_none());
+    fn check(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
+        let call_info = analysis.call_info(position).unwrap();
+        let actual = match call_info {
+            Some(call_info) => {
+                let docs = match &call_info.signature.doc {
+                    None => "".to_string(),
+                    Some(docs) => format!("{}\n------\n", docs.as_str()),
+                };
+                let params = call_info
+                    .signature
+                    .parameters
+                    .iter()
+                    .enumerate()
+                    .map(|(i, param)| {
+                        if Some(i) == call_info.active_parameter {
+                            format!("<{}>", param)
+                        } else {
+                            param.clone()
+                        }
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("{}{}\n({})\n", docs, call_info.signature, params)
+            }
+            None => String::new(),
+        };
+        expect.assert_eq(&actual);
     }
 
     #[test]
-    fn test_fn_signature_two_args_firstx() {
-        let info = call_info(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
-fn bar() { foo(<|>3, ); }"#,
+    fn test_fn_signature_two_args() {
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(<|>3, ); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (<x: u32>, y: u32)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
-        assert_eq!(info.active_parameter, Some(0));
-    }
-
-    #[test]
-    fn test_fn_signature_two_args_second() {
-        let info = call_info(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
-fn bar() { foo(3, <|>); }"#,
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3<|>, ); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (<x: u32>, y: u32)
+            "#]],
+        );
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3,<|> ); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (x: u32, <y: u32>)
+            "#]],
+        );
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3, <|>); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (x: u32, <y: u32>)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
-        assert_eq!(info.active_parameter, Some(1));
     }
 
     #[test]
     fn test_fn_signature_two_args_empty() {
-        let info = call_info(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
-fn bar() { foo(<|>); }"#,
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(<|>); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (<x: u32>, y: u32)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
-        assert_eq!(info.active_parameter, Some(0));
     }
 
     #[test]
     fn test_fn_signature_two_args_first_generics() {
-        let info = call_info(
-            r#"fn foo<T, U: Copy + Display>(x: T, y: U) -> u32 where T: Copy + Display, U: Debug {x + y}
-fn bar() { foo(<|>3, ); }"#,
-        );
-
-        assert_eq!(info.parameters(), ["x: T", "y: U"]);
-        assert_eq!(
-            info.label(),
+        check(
             r#"
 fn foo<T, U: Copy + Display>(x: T, y: U) -> u32
-where T: Copy + Display,
-      U: Debug
-    "#
-            .trim()
+    where T: Copy + Display, U: Debug
+{ x + y }
+
+fn bar() { foo(<|>3, ); }
+"#,
+            expect![[r#"
+                fn foo<T, U: Copy + Display>(x: T, y: U) -> u32
+                where T: Copy + Display,
+                      U: Debug
+                (<x: T>, y: U)
+            "#]],
         );
-        assert_eq!(info.active_parameter, Some(0));
     }
 
     #[test]
     fn test_fn_signature_no_params() {
-        let info = call_info(
-            r#"fn foo<T>() -> T where T: Copy + Display {}
-fn bar() { foo(<|>); }"#,
-        );
-
-        assert!(info.parameters().is_empty());
-        assert_eq!(
-            info.label(),
+        check(
             r#"
-fn foo<T>() -> T
-where T: Copy + Display
-    "#
-            .trim()
+fn foo<T>() -> T where T: Copy + Display {}
+fn bar() { foo(<|>); }
+"#,
+            expect![[r#"
+                fn foo<T>() -> T
+                where T: Copy + Display
+                ()
+            "#]],
         );
-        assert!(info.active_parameter.is_none());
     }
 
     #[test]
     fn test_fn_signature_for_impl() {
-        let info = call_info(
-            r#"struct F; impl F { pub fn new() { F{}} }
-fn bar() {let _ : F = F::new(<|>);}"#,
+        check(
+            r#"
+struct F; impl F { pub fn new() { F{}} }
+fn bar() {let _ : F = F::new(<|>);}
+"#,
+            expect![[r#"
+                pub fn new()
+                ()
+            "#]],
         );
-
-        assert!(info.parameters().is_empty());
-        assert_eq!(info.active_parameter, None);
     }
 
     #[test]
     fn test_fn_signature_for_method_self() {
-        let info = call_info(
-            r#"struct F;
-impl F {
-    pub fn new() -> F{
-        F{}
-    }
-
-    pub fn do_it(&self) {}
-}
+        check(
+            r#"
+struct S;
+impl S { pub fn do_it(&self) {} }
 
 fn bar() {
-    let f : F = F::new();
-    f.do_it(<|>);
-}"#,
+    let s: S = S;
+    s.do_it(<|>);
+}
+"#,
+            expect![[r#"
+                pub fn do_it(&self)
+                (&self)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["&self"]);
-        assert_eq!(info.active_parameter, None);
     }
 
     #[test]
     fn test_fn_signature_for_method_with_arg() {
-        let info = call_info(
-            r#"struct F;
-impl F {
-    pub fn new() -> F{
-        F{}
-    }
-
-    pub fn do_it(&self, x: i32) {}
-}
+        check(
+            r#"
+struct S;
+impl S { pub fn do_it(&self, x: i32) {} }
 
 fn bar() {
-    let f : F = F::new();
-    f.do_it(<|>);
-}"#,
+    let s: S = S;
+    s.do_it(<|>);
+}
+"#,
+            expect![[r#"
+                pub fn do_it(&self, x: i32)
+                (&self, <x: i32>)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["&self", "x: i32"]);
-        assert_eq!(info.active_parameter, Some(1));
     }
 
     #[test]
     fn test_fn_signature_with_docs_simple() {
-        let info = call_info(
+        check(
             r#"
 /// test
 // non-doc-comment
@@ -387,17 +385,18 @@ fn bar() {
     let _ = foo(<|>);
 }
 "#,
+            expect![[r#"
+                test
+                ------
+                fn foo(j: u32) -> u32
+                (<j: u32>)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["j: u32"]);
-        assert_eq!(info.active_parameter, Some(0));
-        assert_eq!(info.label(), "fn foo(j: u32) -> u32");
-        assert_eq!(info.doc().map(|it| it.into()), Some("test".to_string()));
     }
 
     #[test]
     fn test_fn_signature_with_docs() {
-        let info = call_info(
+        check(
             r#"
 /// Adds one to the number given.
 ///
@@ -415,31 +414,26 @@ pub fn add_one(x: i32) -> i32 {
 pub fn do() {
     add_one(<|>
 }"#,
-        );
+            expect![[r##"
+                Adds one to the number given.
 
-        assert_eq!(info.parameters(), ["x: i32"]);
-        assert_eq!(info.active_parameter, Some(0));
-        assert_eq!(info.label(), "pub fn add_one(x: i32) -> i32");
-        assert_eq!(
-            info.doc().map(|it| it.into()),
-            Some(
-                r#"Adds one to the number given.
+                # Examples
 
-# Examples
+                ```
+                let five = 5;
 
-```
-let five = 5;
-
-assert_eq!(6, my_crate::add_one(5));
-```"#
-                    .to_string()
-            )
+                assert_eq!(6, my_crate::add_one(5));
+                ```
+                ------
+                pub fn add_one(x: i32) -> i32
+                (<x: i32>)
+            "##]],
         );
     }
 
     #[test]
     fn test_fn_signature_with_docs_impl() {
-        let info = call_info(
+        check(
             r#"
 struct addr;
 impl addr {
@@ -460,32 +454,28 @@ impl addr {
 pub fn do_it() {
     addr {};
     addr::add_one(<|>);
-}"#,
-        );
-
-        assert_eq!(info.parameters(), ["x: i32"]);
-        assert_eq!(info.active_parameter, Some(0));
-        assert_eq!(info.label(), "pub fn add_one(x: i32) -> i32");
-        assert_eq!(
-            info.doc().map(|it| it.into()),
-            Some(
-                r#"Adds one to the number given.
+}
+"#,
+            expect![[r##"
+                Adds one to the number given.
 
-# Examples
+                # Examples
 
-```
-let five = 5;
+                ```
+                let five = 5;
 
-assert_eq!(6, my_crate::add_one(5));
-```"#
-                    .to_string()
-            )
+                assert_eq!(6, my_crate::add_one(5));
+                ```
+                ------
+                pub fn add_one(x: i32) -> i32
+                (<x: i32>)
+            "##]],
         );
     }
 
     #[test]
     fn test_fn_signature_with_docs_from_actix() {
-        let info = call_info(
+        check(
             r#"
 struct WriteHandler<E>;
 
@@ -509,101 +499,102 @@ impl<E> WriteHandler<E> {
 pub fn foo(mut r: WriteHandler<()>) {
     r.finished(<|>);
 }
-
 "#,
-        );
-
-        assert_eq!(info.label(), "fn finished(&mut self, ctx: &mut Self::Context)".to_string());
-        assert_eq!(info.parameters(), ["&mut self", "ctx: &mut Self::Context"]);
-        assert_eq!(info.active_parameter, Some(1));
-        assert_eq!(
-            info.doc().map(|it| it.into()),
-            Some(
-                r#"Method is called when writer finishes.
-
-By default this method stops actor's `Context`."#
-                    .to_string()
-            )
+            expect![[r#"
+                Method is called when writer finishes.
+
+                By default this method stops actor's `Context`.
+                ------
+                fn finished(&mut self, ctx: &mut Self::Context)
+                (&mut self, <ctx: &mut Self::Context>)
+            "#]],
         );
     }
 
     #[test]
     fn 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, ); }"#,
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo <|> (3, ); }
+"#,
+            expect![[""]],
         );
-        let call_info = analysis.call_info(position).unwrap();
-        assert!(call_info.is_none());
     }
 
     #[test]
-    fn test_nested_method_in_lamba() {
-        let info = call_info(
-            r#"struct Foo;
-
-impl Foo {
-    fn bar(&self, _: u32) { }
-}
+    fn test_nested_method_in_lambda() {
+        check(
+            r#"
+struct Foo;
+impl Foo { fn bar(&self, _: u32) { } }
 
 fn bar(_: u32) { }
 
 fn main() {
     let foo = Foo;
     std::thread::spawn(move || foo.bar(<|>));
-}"#,
+}
+"#,
+            expect![[r#"
+                fn bar(&self, _: u32)
+                (&self, <_: u32>)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["&self", "_: u32"]);
-        assert_eq!(info.active_parameter, Some(1));
-        assert_eq!(info.label(), "fn bar(&self, _: u32)");
     }
 
     #[test]
     fn works_for_tuple_structs() {
-        let info = call_info(
+        check(
             r#"
 /// A cool tuple struct
 struct TS(u32, i32);
 fn main() {
     let s = TS(0, <|>);
-}"#,
+}
+"#,
+            expect![[r#"
+                A cool tuple struct
+                ------
+                struct TS(u32, i32) -> TS
+                (u32, <i32>)
+            "#]],
         );
-
-        assert_eq!(info.label(), "struct TS(u32, i32) -> TS");
-        assert_eq!(info.doc().map(|it| it.into()), Some("A cool tuple struct".to_string()));
-        assert_eq!(info.active_parameter, Some(1));
     }
 
     #[test]
     fn generic_struct() {
-        let info = call_info(
+        check(
             r#"
 struct TS<T>(T);
 fn main() {
     let s = TS(<|>);
-}"#,
+}
+"#,
+            expect![[r#"
+                struct TS<T>(T) -> TS
+                (<T>)
+            "#]],
         );
-
-        assert_eq!(info.label(), "struct TS<T>(T) -> TS");
-        assert_eq!(info.active_parameter, Some(0));
     }
 
     #[test]
     fn cant_call_named_structs() {
-        no_call_info(
+        check(
             r#"
 struct TS { x: u32, y: i32 }
 fn main() {
     let s = TS(<|>);
-}"#,
+}
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
     fn works_for_enum_variants() {
-        let info = call_info(
+        check(
             r#"
 enum E {
     /// A Variant
@@ -617,17 +608,19 @@ enum E {
 fn main() {
     let a = E::A(<|>);
 }
-            "#,
+"#,
+            expect![[r#"
+                A Variant
+                ------
+                E::A(0: i32)
+                (<0: i32>)
+            "#]],
         );
-
-        assert_eq!(info.label(), "E::A(0: i32)");
-        assert_eq!(info.doc().map(|it| it.into()), Some("A Variant".to_string()));
-        assert_eq!(info.active_parameter, Some(0));
     }
 
     #[test]
     fn cant_call_enum_records() {
-        no_call_info(
+        check(
             r#"
 enum E {
     /// A Variant
@@ -641,13 +634,14 @@ enum E {
 fn main() {
     let a = E::C(<|>);
 }
-            "#,
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
     fn fn_signature_for_macro() {
-        let info = call_info(
+        check(
             r#"
 /// empty macro
 macro_rules! foo {
@@ -657,31 +651,30 @@ macro_rules! foo {
 fn f() {
     foo!(<|>);
 }
-        "#,
+"#,
+            expect![[r#"
+                empty macro
+                ------
+                foo!()
+                ()
+            "#]],
         );
-
-        assert_eq!(info.label(), "foo!()");
-        assert_eq!(info.doc().map(|it| it.into()), Some("empty macro".to_string()));
     }
 
     #[test]
     fn fn_signature_for_call_in_macro() {
-        let info = call_info(
+        check(
             r#"
-            macro_rules! id {
-                ($($tt:tt)*) => { $($tt)* }
-            }
-            fn foo() {
-
-            }
-            id! {
-                fn bar() {
-                    foo(<|>);
-                }
-            }
-            "#,
+macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
+fn foo() { }
+id! {
+    fn bar() { foo(<|>); }
+}
+"#,
+            expect![[r#"
+                fn foo()
+                ()
+            "#]],
         );
-
-        assert_eq!(info.label(), "fn foo()");
     }
 }
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index d890b69d2..f3a5e9573 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -2,6 +2,9 @@ mod completion_config;
 mod completion_item;
 mod completion_context;
 mod presentation;
+mod patterns;
+#[cfg(test)]
+mod test_utils;
 
 mod complete_attribute;
 mod complete_dot;
@@ -15,8 +18,6 @@ mod complete_unqualified_path;
 mod complete_postfix;
 mod complete_macro_in_item_position;
 mod complete_trait_impl;
-#[cfg(test)]
-mod test_utils;
 
 use ra_ide_db::RootDatabase;
 
@@ -62,11 +63,11 @@ pub use crate::completion::{
 // There also snippet completions:
 //
 // .Expressions
-// - `pd` -> `println!("{:?}")`
-// - `ppd` -> `println!("{:#?}")`
+// - `pd` -> `eprintln!(" = {:?}", );")`
+// - `ppd` -> `eprintln!(" = {:#?}", );`
 //
 // .Items
-// - `tfn` -> `#[test] fn f(){}`
+// - `tfn` -> `#[test] fn feature(){}`
 // - `tmod` ->
 // ```rust
 // #[cfg(test)]
@@ -74,7 +75,7 @@ pub use crate::completion::{
 //     use super::*;
 //
 //     #[test]
-//     fn test_fn() {}
+//     fn test_name() {}
 // }
 // ```
 
@@ -125,3 +126,81 @@ pub(crate) fn completions(
 
     Some(acc)
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::completion_config::CompletionConfig;
+    use crate::mock_analysis::analysis_and_position;
+
+    struct DetailAndDocumentation<'a> {
+        detail: &'a str,
+        documentation: &'a str,
+    }
+
+    fn check_detail_and_documentation(ra_fixture: &str, expected: DetailAndDocumentation) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
+        let config = CompletionConfig::default();
+        let completions = analysis.completions(&config, position).unwrap().unwrap();
+        for item in completions {
+            if item.detail() == Some(expected.detail) {
+                let opt = item.documentation();
+                let doc = opt.as_ref().map(|it| it.as_str());
+                assert_eq!(doc, Some(expected.documentation));
+                return;
+            }
+        }
+        panic!("completion detail not found: {}", expected.detail)
+    }
+
+    #[test]
+    fn test_completion_detail_from_macro_generated_struct_fn_doc_attr() {
+        check_detail_and_documentation(
+            r#"
+            //- /lib.rs
+            macro_rules! bar {
+                () => {
+                    struct Bar;
+                    impl Bar {
+                        #[doc = "Do the foo"]
+                        fn foo(&self) {}
+                    }
+                }
+            }
+
+            bar!();
+
+            fn foo() {
+                let bar = Bar;
+                bar.fo<|>;
+            }
+            "#,
+            DetailAndDocumentation { detail: "fn foo(&self)", documentation: "Do the foo" },
+        );
+    }
+
+    #[test]
+    fn test_completion_detail_from_macro_generated_struct_fn_doc_comment() {
+        check_detail_and_documentation(
+            r#"
+            //- /lib.rs
+            macro_rules! bar {
+                () => {
+                    struct Bar;
+                    impl Bar {
+                        /// Do the foo
+                        fn foo(&self) {}
+                    }
+                }
+            }
+
+            bar!();
+
+            fn foo() {
+                let bar = Bar;
+                bar.fo<|>;
+            }
+            "#,
+            DetailAndDocumentation { detail: "fn foo(&self)", documentation: " Do the foo" },
+        );
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_attribute.rs b/crates/ra_ide/src/completion/complete_attribute.rs
index fb3f0b743..d268c92be 100644
--- a/crates/ra_ide/src/completion/complete_attribute.rs
+++ b/crates/ra_ide/src/completion/complete_attribute.rs
@@ -20,6 +20,7 @@ pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext)
         {
             complete_derive(acc, ctx, token_tree)
         }
+        (_, Some(ast::AttrInput::TokenTree(_token_tree))) => {}
         _ => complete_attribute_start(acc, ctx, attribute),
     }
     Some(())
@@ -34,6 +35,10 @@ fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attr
         )
         .kind(CompletionItemKind::Attribute);
 
+        if let Some(lookup) = attr_completion.lookup {
+            item = item.lookup_by(lookup);
+        }
+
         match (attr_completion.snippet, ctx.config.snippet_cap) {
             (Some(snippet), Some(cap)) => {
                 item = item.insert_snippet(cap, snippet);
@@ -41,7 +46,7 @@ fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attr
             _ => {}
         }
 
-        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.should_be_inner {
+        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.prefer_inner {
             acc.add(item);
         }
     }
@@ -49,85 +54,74 @@ fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attr
 
 struct AttrCompletion {
     label: &'static str,
+    lookup: Option<&'static str>,
+    snippet: Option<&'static str>,
+    prefer_inner: bool,
+}
+
+impl AttrCompletion {
+    const fn prefer_inner(self) -> AttrCompletion {
+        AttrCompletion { prefer_inner: true, ..self }
+    }
+}
+
+const fn attr(
+    label: &'static str,
+    lookup: Option<&'static str>,
     snippet: Option<&'static str>,
-    should_be_inner: bool,
+) -> AttrCompletion {
+    AttrCompletion { label, lookup, snippet, prefer_inner: false }
 }
 
 const ATTRIBUTES: &[AttrCompletion] = &[
-    AttrCompletion { label: "allow", snippet: Some("allow(${0:lint})"), should_be_inner: false },
-    AttrCompletion {
-        label: "cfg_attr",
-        snippet: Some("cfg_attr(${1:predicate}, ${0:attr})"),
-        should_be_inner: false,
-    },
-    AttrCompletion { label: "cfg", snippet: Some("cfg(${0:predicate})"), should_be_inner: false },
-    AttrCompletion { label: "deny", snippet: Some("deny(${0:lint})"), should_be_inner: false },
-    AttrCompletion {
-        label: "deprecated",
-        snippet: Some(r#"deprecated = "${0:reason}""#),
-        should_be_inner: false,
-    },
-    AttrCompletion {
-        label: "derive",
-        snippet: Some(r#"derive(${0:Debug})"#),
-        should_be_inner: false,
-    },
-    AttrCompletion { label: "doc", snippet: Some(r#"doc = "${0:docs}""#), should_be_inner: false },
-    AttrCompletion { label: "feature", snippet: Some("feature(${0:flag})"), should_be_inner: true },
-    AttrCompletion { label: "forbid", snippet: Some("forbid(${0:lint})"), should_be_inner: false },
+    attr("allow(…)", Some("allow"), Some("allow(${0:lint})")),
+    attr("cfg_attr(…)", Some("cfg_attr"), Some("cfg_attr(${1:predicate}, ${0:attr})")),
+    attr("cfg(…)", Some("cfg"), Some("cfg(${0:predicate})")),
+    attr("deny(…)", Some("deny"), Some("deny(${0:lint})")),
+    attr(r#"deprecated = "…""#, Some("deprecated"), Some(r#"deprecated = "${0:reason}""#)),
+    attr("derive(…)", Some("derive"), Some(r#"derive(${0:Debug})"#)),
+    attr(r#"doc = "…""#, Some("doc"), Some(r#"doc = "${0:docs}""#)),
+    attr("feature(…)", Some("feature"), Some("feature(${0:flag})")).prefer_inner(),
+    attr("forbid(…)", Some("forbid"), Some("forbid(${0:lint})")),
     // FIXME: resolve through macro resolution?
-    AttrCompletion { label: "global_allocator", snippet: None, should_be_inner: true },
-    AttrCompletion { label: "ignore", snippet: Some("ignore(${0:lint})"), should_be_inner: false },
-    AttrCompletion { label: "inline", snippet: Some("inline(${0:lint})"), should_be_inner: false },
-    AttrCompletion {
-        label: "link_name",
-        snippet: Some(r#"link_name = "${0:symbol_name}""#),
-        should_be_inner: false,
-    },
-    AttrCompletion { label: "link", snippet: None, should_be_inner: false },
-    AttrCompletion { label: "macro_export", snippet: None, should_be_inner: false },
-    AttrCompletion { label: "macro_use", snippet: None, should_be_inner: false },
-    AttrCompletion {
-        label: "must_use",
-        snippet: Some(r#"must_use = "${0:reason}""#),
-        should_be_inner: false,
-    },
-    AttrCompletion { label: "no_mangle", snippet: None, should_be_inner: false },
-    AttrCompletion { label: "no_std", snippet: None, should_be_inner: true },
-    AttrCompletion { label: "non_exhaustive", snippet: None, should_be_inner: false },
-    AttrCompletion { label: "panic_handler", snippet: None, should_be_inner: true },
-    AttrCompletion { label: "path", snippet: Some("path =\"${0:path}\""), should_be_inner: false },
-    AttrCompletion { label: "proc_macro", snippet: None, should_be_inner: false },
-    AttrCompletion { label: "proc_macro_attribute", snippet: None, should_be_inner: false },
-    AttrCompletion {
-        label: "proc_macro_derive",
-        snippet: Some("proc_macro_derive(${0:Trait})"),
-        should_be_inner: false,
-    },
-    AttrCompletion {
-        label: "recursion_limit",
-        snippet: Some("recursion_limit = ${0:128}"),
-        should_be_inner: true,
-    },
-    AttrCompletion { label: "repr", snippet: Some("repr(${0:C})"), should_be_inner: false },
-    AttrCompletion {
-        label: "should_panic",
-        snippet: Some(r#"should_panic(expected = "${0:reason}")"#),
-        should_be_inner: false,
-    },
-    AttrCompletion {
-        label: "target_feature",
-        snippet: Some("target_feature = \"${0:feature}\""),
-        should_be_inner: false,
-    },
-    AttrCompletion { label: "test", snippet: None, should_be_inner: false },
-    AttrCompletion { label: "used", snippet: None, should_be_inner: false },
-    AttrCompletion { label: "warn", snippet: Some("warn(${0:lint})"), should_be_inner: false },
-    AttrCompletion {
-        label: "windows_subsystem",
-        snippet: Some(r#"windows_subsystem = "${0:subsystem}""#),
-        should_be_inner: true,
-    },
+    attr("global_allocator", None, None).prefer_inner(),
+    attr(r#"ignore = "…""#, Some("ignore"), Some(r#"ignore = "${0:reason}""#)),
+    attr("inline(…)", Some("inline"), Some("inline(${0:lint})")),
+    attr(r#"link_name = "…""#, Some("link_name"), Some(r#"link_name = "${0:symbol_name}""#)),
+    attr("link", None, None),
+    attr("macro_export", None, None),
+    attr("macro_use", None, None),
+    attr(r#"must_use = "…""#, Some("must_use"), Some(r#"must_use = "${0:reason}""#)),
+    attr("no_mangle", None, None),
+    attr("no_std", None, None).prefer_inner(),
+    attr("non_exhaustive", None, None),
+    attr("panic_handler", None, None).prefer_inner(),
+    attr("path = \"…\"", Some("path"), Some("path =\"${0:path}\"")),
+    attr("proc_macro", None, None),
+    attr("proc_macro_attribute", None, None),
+    attr("proc_macro_derive(…)", Some("proc_macro_derive"), Some("proc_macro_derive(${0:Trait})")),
+    attr("recursion_limit = …", Some("recursion_limit"), Some("recursion_limit = ${0:128}"))
+        .prefer_inner(),
+    attr("repr(…)", Some("repr"), Some("repr(${0:C})")),
+    attr(
+        "should_panic(…)",
+        Some("should_panic"),
+        Some(r#"should_panic(expected = "${0:reason}")"#),
+    ),
+    attr(
+        r#"target_feature = "…""#,
+        Some("target_feature"),
+        Some("target_feature = \"${0:feature}\""),
+    ),
+    attr("test", None, None),
+    attr("used", None, None),
+    attr("warn(…)", Some("warn"), Some("warn(${0:lint})")),
+    attr(
+        r#"windows_subsystem = "…""#,
+        Some("windows_subsystem"),
+        Some(r#"windows_subsystem = "${0:subsystem}""#),
+    )
+    .prefer_inner(),
 ];
 
 fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input: ast::TokenTree) {
@@ -201,7 +195,7 @@ fn parse_derive_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>,
 
 fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
     let mut result = FxHashSet::default();
-    ctx.scope().process_all_names(&mut |name, scope_def| {
+    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());
@@ -232,624 +226,147 @@ const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
+
+    use crate::completion::{test_utils::completion_list, CompletionKind};
 
-    fn do_attr_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Attribute)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Attribute);
+        expect.assert_eq(&actual);
     }
 
     #[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,
-            },
-        ]
-            "###
+        check(
+            r#"
+#[derive(<|>)]
+struct Test {}
+        "#,
+            expect![[r#"
+                at Clone
+                at Copy, Clone
+                at Debug
+                at Default
+                at Eq, PartialEq
+                at Hash
+                at Ord, PartialOrd, Eq, PartialEq
+                at PartialEq
+                at PartialOrd, PartialEq
+            "#]],
         );
     }
 
     #[test]
     fn no_completion_for_incorrect_derive() {
-        assert_debug_snapshot!(
-            do_attr_completion(
-                r"
-                    #[derive{<|>)]
-                    struct Test {}
-                    ",
-            ),
-            @"[]"
-        );
+        check(
+            r#"
+#[derive{<|>)]
+struct Test {}
+"#,
+            expect![[r#""#]],
+        )
     }
 
     #[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,
-            },
-        ]
-            "###
-        );
+        check(
+            r#"
+#[derive(serde::Serialize, PartialEq, <|>)]
+struct Test {}
+"#,
+            expect![[r#"
+                at Clone
+                at Copy, Clone
+                at Debug
+                at Default
+                at Eq
+                at Hash
+                at Ord, PartialOrd, Eq
+                at PartialOrd
+            "#]],
+        )
     }
 
     #[test]
     fn test_attribute_completion() {
-        assert_debug_snapshot!(
-        do_attr_completion(
-                r"
-                #[<|>]
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "allow",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "allow(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "cfg",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "cfg(${0:predicate})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "cfg_attr",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "cfg_attr(${1:predicate}, ${0:attr})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "deny",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "deny(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "deprecated",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "deprecated = \"${0:reason}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "derive",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "derive(${0:Debug})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "doc",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "doc = \"${0:docs}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "forbid",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "forbid(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "ignore",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "ignore(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "inline",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "inline(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "link",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "link",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "link_name",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "link_name = \"${0:symbol_name}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "macro_export",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "macro_export",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "macro_use",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "macro_use",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "must_use",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "must_use = \"${0:reason}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "no_mangle",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "no_mangle",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "non_exhaustive",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "non_exhaustive",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "path",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "path =\"${0:path}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "proc_macro",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro_attribute",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "proc_macro_attribute",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro_derive",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "proc_macro_derive(${0:Trait})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "repr",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "repr(${0:C})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "should_panic",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "should_panic(expected = \"${0:reason}\")",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "target_feature",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "target_feature = \"${0:feature}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "test",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "test",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "used",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "used",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "warn",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "warn(${0:lint})",
-                kind: Attribute,
-            },
-        ]
-        "###
-        );
+        check(
+            r#"#[<|>]"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at deprecated = "…"
+                at derive(…)
+                at doc = "…"
+                at forbid(…)
+                at ignore = "…"
+                at inline(…)
+                at link
+                at link_name = "…"
+                at macro_export
+                at macro_use
+                at must_use = "…"
+                at no_mangle
+                at non_exhaustive
+                at path = "…"
+                at proc_macro
+                at proc_macro_attribute
+                at proc_macro_derive(…)
+                at repr(…)
+                at should_panic(…)
+                at target_feature = "…"
+                at test
+                at used
+                at warn(…)
+            "#]],
+        )
+    }
+
+    #[test]
+    fn test_attribute_completion_inside_nested_attr() {
+        check(r#"#[allow(<|>)]"#, expect![[]])
     }
 
     #[test]
     fn test_inner_attribute_completion() {
-        assert_debug_snapshot!(
-        do_attr_completion(
-                r"
-                #![<|>]
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "allow",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "allow(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "cfg",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "cfg(${0:predicate})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "cfg_attr",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "cfg_attr(${1:predicate}, ${0:attr})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "deny",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "deny(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "deprecated",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "deprecated = \"${0:reason}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "derive",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "derive(${0:Debug})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "doc",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "doc = \"${0:docs}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "feature",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "feature(${0:flag})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "forbid",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "forbid(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "global_allocator",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "global_allocator",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "ignore",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "ignore(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "inline",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "inline(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "link",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "link",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "link_name",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "link_name = \"${0:symbol_name}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "macro_export",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "macro_export",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "macro_use",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "macro_use",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "must_use",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "must_use = \"${0:reason}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "no_mangle",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "no_mangle",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "no_std",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "no_std",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "non_exhaustive",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "non_exhaustive",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "panic_handler",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "panic_handler",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "path",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "path =\"${0:path}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "proc_macro",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro_attribute",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "proc_macro_attribute",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro_derive",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "proc_macro_derive(${0:Trait})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "recursion_limit",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "recursion_limit = ${0:128}",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "repr",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "repr(${0:C})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "should_panic",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "should_panic(expected = \"${0:reason}\")",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "target_feature",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "target_feature = \"${0:feature}\"",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "test",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "test",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "used",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "used",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "warn",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "warn(${0:lint})",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "windows_subsystem",
-                source_range: 20..20,
-                delete: 20..20,
-                insert: "windows_subsystem = \"${0:subsystem}\"",
-                kind: Attribute,
-            },
-        ]
-        "###
+        check(
+            r"#![<|>]",
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at deprecated = "…"
+                at derive(…)
+                at doc = "…"
+                at feature(…)
+                at forbid(…)
+                at global_allocator
+                at ignore = "…"
+                at inline(…)
+                at link
+                at link_name = "…"
+                at macro_export
+                at macro_use
+                at must_use = "…"
+                at no_mangle
+                at no_std
+                at non_exhaustive
+                at panic_handler
+                at path = "…"
+                at proc_macro
+                at proc_macro_attribute
+                at proc_macro_derive(…)
+                at recursion_limit = …
+                at repr(…)
+                at should_panic(…)
+                at target_feature = "…"
+                at test
+                at used
+                at warn(…)
+                at windows_subsystem = "…"
+            "#]],
         );
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 05f825c6f..532665285 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -1,17 +1,12 @@
-//! FIXME: write short doc here
+//! Completes references after dot (fields and method calls).
 
 use hir::{HasVisibility, Type};
-
-use crate::{
-    completion::{
-        completion_context::CompletionContext,
-        completion_item::{CompletionKind, Completions},
-    },
-    CompletionItem,
-};
 use rustc_hash::FxHashSet;
+use test_utils::mark;
 
-/// Complete dot accesses, i.e. fields or methods (and .await syntax).
+use crate::completion::{completion_context::CompletionContext, completion_item::Completions};
+
+/// Complete dot accesses, i.e. fields or methods.
 pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
     let dot_receiver = match &ctx.dot_receiver {
         Some(expr) => expr,
@@ -23,24 +18,18 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
         _ => return,
     };
 
-    if !ctx.is_call {
+    if ctx.is_call {
+        mark::hit!(test_no_struct_field_completion_for_method_call);
+    } else {
         complete_fields(acc, ctx, &receiver_ty);
     }
     complete_methods(acc, ctx, &receiver_ty);
-
-    // Suggest .await syntax for types that implement Future trait
-    if receiver_ty.impls_future(ctx.db) {
-        CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
-            .detail("expr.await")
-            .insert_text("await")
-            .add_to(acc);
-    }
 }
 
 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
     for receiver in receiver.autoderef(ctx.db) {
         for (field, ty) in receiver.fields(ctx.db) {
-            if ctx.scope().module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
+            if ctx.scope.module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
                 // Skip private field. FIXME: If the definition location of the
                 // field is editable, we should show the completion
                 continue;
@@ -57,10 +46,10 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Ty
 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
     if let Some(krate) = ctx.krate {
         let mut seen_methods = FxHashSet::default();
-        let traits_in_scope = ctx.scope().traits_in_scope();
+        let traits_in_scope = ctx.scope.traits_in_scope();
         receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
             if func.has_self_param(ctx.db)
-                && ctx.scope().module().map_or(true, |m| func.is_visible_from(ctx.db, m))
+                && ctx.scope.module().map_or(true, |m| func.is_visible_from(ctx.db, m))
                 && seen_methods.insert(func.name(ctx.db))
             {
                 acc.add_function(ctx, func, None);
@@ -72,801 +61,356 @@ fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &T
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
+    use test_utils::mark;
+
+    use crate::completion::{test_utils::completion_list, CompletionKind};
 
-    fn do_ref_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual);
     }
 
     #[test]
-    fn test_struct_field_completion() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-                r"
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                a.<|>
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 94..94,
-                delete: 94..94,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+    fn test_struct_field_and_method_completion() {
+        check(
+            r#"
+struct S { foo: u32 }
+impl S {
+    fn bar(&self) {}
+}
+fn foo(s: S) { s.<|> }
+"#,
+            expect![[r#"
+                me bar() fn bar(&self)
+                fd foo   u32
+            "#]],
         );
     }
 
     #[test]
     fn test_struct_field_completion_self() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A {
-                /// This is the_field
-                the_field: (u32,)
-            }
-            impl A {
-                fn foo(self) {
-                    self.<|>
-                }
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "foo()",
-                source_range: 187..187,
-                delete: 187..187,
-                insert: "foo()$0",
-                kind: Method,
-                lookup: "foo",
-                detail: "fn foo(self)",
-            },
-            CompletionItem {
-                label: "the_field",
-                source_range: 187..187,
-                delete: 187..187,
-                insert: "the_field",
-                kind: Field,
-                detail: "(u32,)",
-                documentation: Documentation(
-                    "This is the_field",
-                ),
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+struct S { the_field: (u32,) }
+impl S {
+    fn foo(self) { self.<|> }
+}
+"#,
+            expect![[r#"
+                me foo()     fn foo(self)
+                fd the_field (u32,)
+            "#]],
+        )
     }
 
     #[test]
     fn test_struct_field_completion_autoderef() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A { the_field: (u32, i32) }
-            impl A {
-                fn foo(&self) {
-                    self.<|>
-                }
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "foo()",
-                source_range: 126..126,
-                delete: 126..126,
-                insert: "foo()$0",
-                kind: Method,
-                lookup: "foo",
-                detail: "fn foo(&self)",
-            },
-            CompletionItem {
-                label: "the_field",
-                source_range: 126..126,
-                delete: 126..126,
-                insert: "the_field",
-                kind: Field,
-                detail: "(u32, i32)",
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+struct A { the_field: (u32, i32) }
+impl A {
+    fn foo(&self) { self.<|> }
+}
+"#,
+            expect![[r#"
+                me foo()     fn foo(&self)
+                fd the_field (u32, i32)
+            "#]],
+        )
     }
 
     #[test]
     fn test_no_struct_field_completion_for_method_call() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A { the_field: u32 }
-            fn foo(a: A) {
-               a.<|>()
-            }
-            ",
-        ),
-        @"[]"
+        mark::check!(test_no_struct_field_completion_for_method_call);
+        check(
+            r#"
+struct A { the_field: u32 }
+fn foo(a: A) { a.<|>() }
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
-    fn test_struct_field_visibility_private() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            mod inner {
-                struct A {
-                    private_field: u32,
-                    pub pub_field: u32,
-                    pub(crate) crate_field: u32,
-                    pub(super) super_field: u32,
-                }
-            }
-            fn foo(a: inner::A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "crate_field",
-                source_range: 313..313,
-                delete: 313..313,
-                insert: "crate_field",
-                kind: Field,
-                detail: "u32",
-            },
-            CompletionItem {
-                label: "pub_field",
-                source_range: 313..313,
-                delete: 313..313,
-                insert: "pub_field",
-                kind: Field,
-                detail: "u32",
-            },
-            CompletionItem {
-                label: "super_field",
-                source_range: 313..313,
-                delete: 313..313,
-                insert: "super_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
-        );
+    fn test_visibility_filtering() {
+        check(
+            r#"
+mod inner {
+    pub struct A {
+        private_field: u32,
+        pub pub_field: u32,
+        pub(crate) crate_field: u32,
+        pub(super) super_field: u32,
     }
-
-    #[test]
-    fn test_union_field_completion() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            union Un {
-                field: u8,
-                other: u16,
-            }
-
-            fn foo(u: Un) {
-                u.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "field",
-                source_range: 140..140,
-                delete: 140..140,
-                insert: "field",
-                kind: Field,
-                detail: "u8",
-            },
-            CompletionItem {
-                label: "other",
-                source_range: 140..140,
-                delete: 140..140,
-                insert: "other",
-                kind: Field,
-                detail: "u16",
-            },
-        ]
-        "###
+}
+fn foo(a: inner::A) { a.<|> }
+"#,
+            expect![[r#"
+                fd crate_field u32
+                fd pub_field   u32
+                fd super_field u32
+            "#]],
         );
-    }
 
-    #[test]
-    fn test_method_completion() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A {}
-            impl A {
-                fn the_method(&self) {}
-            }
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 144..144,
-                delete: 144..144,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct A {}
+mod m {
+    impl super::A {
+        fn private_method(&self) {}
+        pub(super) fn the_method(&self) {}
+    }
+}
+fn foo(a: A) { a.<|> }
+"#,
+            expect![[r#"
+                me the_method() pub(super) fn the_method(&self)
+            "#]],
         );
     }
 
     #[test]
-    fn test_method_completion_only_fitting_impls() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A<T> {}
-            impl A<u32> {
-                fn the_method(&self) {}
-            }
-            impl A<i32> {
-                fn the_other_method(&self) {}
-            }
-            fn foo(a: A<u32>) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 243..243,
-                delete: 243..243,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+    fn test_union_field_completion() {
+        check(
+            r#"
+union U { field: u8, other: u16 }
+fn foo(u: U) { u.<|> }
+"#,
+            expect![[r#"
+                fd field u8
+                fd other u16
+            "#]],
         );
     }
 
     #[test]
-    fn test_method_completion_private() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A {}
-            mod m {
-                impl super::A {
-                    fn private_method(&self) {}
-                    pub(super) fn the_method(&self) {}
-                }
-            }
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 256..256,
-                delete: 256..256,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "pub(super) fn the_method(&self)",
-            },
-        ]
-        "###
-        );
+    fn test_method_completion_only_fitting_impls() {
+        check(
+            r#"
+struct A<T> {}
+impl A<u32> {
+    fn the_method(&self) {}
+}
+impl A<i32> {
+    fn the_other_method(&self) {}
+}
+fn foo(a: A<u32>) { a.<|> }
+"#,
+            expect![[r#"
+                me the_method() fn the_method(&self)
+            "#]],
+        )
     }
 
     #[test]
     fn test_trait_method_completion() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A {}
-            trait Trait { fn the_method(&self); }
-            impl Trait for A {}
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 151..151,
-                delete: 151..151,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct A {}
+trait Trait { fn the_method(&self); }
+impl Trait for A {}
+fn foo(a: A) { a.<|> }
+"#,
+            expect![[r#"
+                me the_method() fn the_method(&self)
+            "#]],
         );
     }
 
     #[test]
     fn test_trait_method_completion_deduplicated() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A {}
-            trait Trait { fn the_method(&self); }
-            impl<T> Trait for T {}
-            fn foo(a: &A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 155..155,
-                delete: 155..155,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+        check(
+            r"
+struct A {}
+trait Trait { fn the_method(&self); }
+impl<T> Trait for T {}
+fn foo(a: &A) { a.<|> }
+",
+            expect![[r#"
+                me the_method() fn the_method(&self)
+            "#]],
         );
     }
 
     #[test]
     fn completes_trait_method_from_other_module() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A {}
-            mod m {
-                pub trait Trait { fn the_method(&self); }
-            }
-            use m::Trait;
-            impl Trait for A {}
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 219..219,
-                delete: 219..219,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn test_no_non_self_method() {
-        assert_debug_snapshot!(
-        do_ref_completion(
+        check(
             r"
-            struct A {}
-            impl A {
-                fn the_method() {}
-            }
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-        ),
-        @"[]"
+struct A {}
+mod m {
+    pub trait Trait { fn the_method(&self); }
+}
+use m::Trait;
+impl Trait for A {}
+fn foo(a: A) { a.<|> }
+",
+            expect![[r#"
+                me the_method() fn the_method(&self)
+            "#]],
         );
     }
 
     #[test]
-    fn test_method_attr_filtering() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A {}
-            impl A {
-                #[inline]
-                fn the_method(&self) {
-                    let x = 1;
-                    let y = 2;
-                }
-            }
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 249..249,
-                delete: 249..249,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+    fn test_no_non_self_method() {
+        check(
+            r#"
+struct A {}
+impl A {
+    fn the_method() {}
+}
+fn foo(a: A) {
+   a.<|>
+}
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
     fn test_tuple_field_completion() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            fn foo() {
-               let b = (0, 3.14);
-               b.<|>
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "0",
-                source_range: 75..75,
-                delete: 75..75,
-                insert: "0",
-                kind: Field,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "1",
-                source_range: 75..75,
-                delete: 75..75,
-                insert: "1",
-                kind: Field,
-                detail: "f64",
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+fn foo() {
+   let b = (0, 3.14);
+   b.<|>
+}
+"#,
+            expect![[r#"
+                fd 0 i32
+                fd 1 f64
+            "#]],
+        )
     }
 
     #[test]
     fn test_tuple_field_inference() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            pub struct S;
-            impl S {
-                pub fn blah(&self) {}
-            }
+        check(
+            r#"
+pub struct S;
+impl S { pub fn blah(&self) {} }
 
-            struct T(S);
+struct T(S);
 
-            impl T {
-                fn foo(&self) {
-                    // FIXME: This doesn't work without the trailing `a` as `0.` is a float
-                    self.0.a<|>
-                }
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "blah()",
-                source_range: 299..300,
-                delete: 299..300,
-                insert: "blah()$0",
-                kind: Method,
-                lookup: "blah",
-                detail: "pub fn blah(&self)",
-            },
-        ]
-        "###
-        );
+impl T {
+    fn foo(&self) {
+        // FIXME: This doesn't work without the trailing `a` as `0.` is a float
+        self.0.a<|>
     }
-
-    #[test]
-    fn test_completion_works_in_consts() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A { the_field: u32 }
-            const X: u32 = {
-                A { the_field: 92 }.<|>
-            };
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 106..106,
-                delete: 106..106,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+}
+"#,
+            expect![[r#"
+                me blah() pub fn blah(&self)
+            "#]],
         );
     }
 
     #[test]
-    fn test_completion_await_impls_future() {
-        assert_debug_snapshot!(
-        do_completion(
-            r###"
-            //- /main.rs
-            use std::future::*;
-            struct A {}
-            impl Future for A {}
-            fn foo(a: A) {
-                a.<|>
-            }
-
-            //- /std/lib.rs
-            pub mod future {
-                #[lang = "future_trait"]
-                pub trait Future {}
-            }
-            "###, CompletionKind::Keyword),
-        @r###"
-        [
-            CompletionItem {
-                label: "await",
-                source_range: 74..74,
-                delete: 74..74,
-                insert: "await",
-                detail: "expr.await",
-            },
-        ]
-        "###
-        )
-    }
-
-    #[test]
-    fn test_super_super_completion() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-                r"
-                mod a {
-                    const A: usize = 0;
-
-                    mod b {
-                        const B: usize = 0;
-
-                        mod c {
-                            use super::super::<|>
-                        }
-                    }
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "A",
-                source_range: 217..217,
-                delete: 217..217,
-                insert: "A",
-                kind: Const,
-            },
-            CompletionItem {
-                label: "b",
-                source_range: 217..217,
-                delete: 217..217,
-                insert: "b",
-                kind: Module,
-            },
-        ]
-        "###
+    fn test_completion_works_in_consts() {
+        check(
+            r#"
+struct A { the_field: u32 }
+const X: u32 = {
+    A { the_field: 92 }.<|>
+};
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
     fn works_in_simple_macro_1() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    m!(a.x<|>)
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 156..157,
-                delete: 156..157,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn works_in_simple_macro_recursive() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    m!(a.x<|>)
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 156..157,
-                delete: 156..157,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+struct A { the_field: u32 }
+fn foo(a: A) {
+    m!(a.x<|>)
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
     fn works_in_simple_macro_2() {
         // this doesn't work yet because the macro doesn't expand without the token -- maybe it can be fixed with better recovery
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    m!(a.<|>)
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 156..156,
-                delete: 156..156,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+struct A { the_field: u32 }
+fn foo(a: A) {
+    m!(a.<|>)
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
     fn works_in_simple_macro_recursive_1() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    m!(m!(m!(a.x<|>)))
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 162..163,
-                delete: 162..163,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+struct A { the_field: u32 }
+fn foo(a: A) {
+    m!(m!(m!(a.x<|>)))
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
     fn macro_expansion_resilient() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! dbg {
-                    () => {};
-                    ($val:expr) => {
-                        match $val { tmp => { tmp } }
-                    };
-                    // Trailing comma with single argument is ignored
-                    ($val:expr,) => { $crate::dbg!($val) };
-                    ($($val:expr),+ $(,)?) => {
-                        ($($crate::dbg!($val)),+,)
-                    };
-                }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    dbg!(a.<|>)
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 552..552,
-                delete: 552..552,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! dbg {
+    () => {};
+    ($val:expr) => {
+        match $val { tmp => { tmp } }
+    };
+    // Trailing comma with single argument is ignored
+    ($val:expr,) => { $crate::dbg!($val) };
+    ($($val:expr),+ $(,)?) => {
+        ($($crate::dbg!($val)),+,)
+    };
+}
+struct A { the_field: u32 }
+fn foo(a: A) {
+    dbg!(a.<|>)
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
-    fn test_method_completion_3547() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct HashSet<T> {}
-            impl<T> HashSet<T> {
-                pub fn the_method(&self) {}
-            }
-            fn foo() {
-                let s: HashSet<_>;
-                s.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 201..201,
-                delete: 201..201,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "pub fn the_method(&self)",
-            },
-        ]
-        "###
+    fn test_method_completion_issue_3547() {
+        check(
+            r#"
+struct HashSet<T> {}
+impl<T> HashSet<T> {
+    pub fn the_method(&self) {}
+}
+fn foo() {
+    let s: HashSet<_>;
+    s.<|>
+}
+"#,
+            expect![[r#"
+                me the_method() pub fn the_method(&self)
+            "#]],
         );
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_fn_param.rs b/crates/ra_ide/src/completion/complete_fn_param.rs
index a661932a3..db2abb4f1 100644
--- a/crates/ra_ide/src/completion/complete_fn_param.rs
+++ b/crates/ra_ide/src/completion/complete_fn_param.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! See `complete_fn_param`.
 
 use ra_syntax::{
     ast::{self, ModuleItemOwner},
@@ -18,6 +18,7 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
     }
 
     let mut params = FxHashMap::default();
+    let me = ctx.token.ancestors().find_map(ast::FnDef::cast);
     for node in ctx.token.parent().ancestors() {
         let items = match_ast! {
             match node {
@@ -28,25 +29,26 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
         };
         for item in items {
             if let ast::ModuleItem::FnDef(func) = item {
+                if Some(&func) == me.as_ref() {
+                    continue;
+                }
                 func.param_list().into_iter().flat_map(|it| it.params()).for_each(|param| {
                     let text = param.syntax().text().to_string();
-                    params.entry(text).or_insert((0, param)).0 += 1;
+                    params.entry(text).or_insert(param);
                 })
             }
         }
     }
+
     params
         .into_iter()
-        .filter_map(|(label, (count, param))| {
+        .filter_map(|(label, param)| {
             let lookup = param.pat()?.syntax().text().to_string();
-            if count < 2 {
-                None
-            } else {
-                Some((label, lookup))
-            }
+            Some((label, lookup))
         })
         .for_each(|(label, lookup)| {
             CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
+                .kind(crate::CompletionItemKind::Binding)
                 .lookup_by(lookup)
                 .add_to(acc)
         });
@@ -54,85 +56,70 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    fn do_magic_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Magic)
+    use crate::completion::{test_utils::completion_list, CompletionKind};
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Magic);
+        expect.assert_eq(&actual);
     }
 
     #[test]
     fn test_param_completion_last_param() {
-        assert_debug_snapshot!(
-        do_magic_completion(
-                r"
-                fn foo(file_id: FileId) {}
-                fn bar(file_id: FileId) {}
-                fn baz(file<|>) {}
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "file_id: FileId",
-                source_range: 110..114,
-                delete: 110..114,
-                insert: "file_id: FileId",
-                lookup: "file_id",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn foo(file_id: FileId) {}
+fn bar(file_id: FileId) {}
+fn baz(file<|>) {}
+"#,
+            expect![[r#"
+                bn file_id: FileId
+            "#]],
         );
     }
 
     #[test]
     fn test_param_completion_nth_param() {
-        assert_debug_snapshot!(
-        do_magic_completion(
-                r"
-                fn foo(file_id: FileId) {}
-                fn bar(file_id: FileId) {}
-                fn baz(file<|>, x: i32) {}
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "file_id: FileId",
-                source_range: 110..114,
-                delete: 110..114,
-                insert: "file_id: FileId",
-                lookup: "file_id",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn foo(file_id: FileId) {}
+fn baz(file<|>, x: i32) {}
+"#,
+            expect![[r#"
+                bn file_id: FileId
+            "#]],
         );
     }
 
     #[test]
     fn test_param_completion_trait_param() {
-        assert_debug_snapshot!(
-        do_magic_completion(
-                r"
-                pub(crate) trait SourceRoot {
-                    pub fn contains(&self, file_id: FileId) -> bool;
-                    pub fn module_map(&self) -> &ModuleMap;
-                    pub fn lines(&self, file_id: FileId) -> &LineIndex;
-                    pub fn syntax(&self, file<|>)
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "file_id: FileId",
-                source_range: 289..293,
-                delete: 289..293,
-                insert: "file_id: FileId",
-                lookup: "file_id",
-            },
-        ]
-        "###
+        check(
+            r#"
+pub(crate) trait SourceRoot {
+    pub fn contains(&self, file_id: FileId) -> bool;
+    pub fn module_map(&self) -> &ModuleMap;
+    pub fn lines(&self, file_id: FileId) -> &LineIndex;
+    pub fn syntax(&self, file<|>)
+}
+"#,
+            expect![[r#"
+                bn file_id: FileId
+            "#]],
         );
     }
+
+    #[test]
+    fn completes_param_in_inner_function() {
+        check(
+            r#"
+fn outer(text: String) {
+    fn inner(<|>)
+}
+"#,
+            expect![[r#"
+                bn text: String
+            "#]],
+        )
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index fd95bc410..fcdaeef49 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -1,11 +1,7 @@
 //! FIXME: write short doc here
 
-use ra_syntax::{
-    ast::{self, LoopBodyOwner},
-    match_ast, AstNode,
-    SyntaxKind::*,
-    SyntaxToken,
-};
+use ra_syntax::{ast, SyntaxKind};
+use test_utils::mark;
 
 use crate::completion::{
     CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
@@ -16,14 +12,14 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
     let source_range = ctx.source_range();
     match (ctx.use_item_syntax.as_ref(), ctx.path_prefix.as_ref()) {
         (Some(_), None) => {
-            CompletionItem::new(CompletionKind::Keyword, source_range, "crate")
+            CompletionItem::new(CompletionKind::Keyword, source_range, "crate::")
                 .kind(CompletionItemKind::Keyword)
                 .insert_text("crate::")
                 .add_to(acc);
             CompletionItem::new(CompletionKind::Keyword, source_range, "self")
                 .kind(CompletionItemKind::Keyword)
                 .add_to(acc);
-            CompletionItem::new(CompletionKind::Keyword, source_range, "super")
+            CompletionItem::new(CompletionKind::Keyword, source_range, "super::")
                 .kind(CompletionItemKind::Keyword)
                 .insert_text("super::")
                 .add_to(acc);
@@ -32,77 +28,147 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
             CompletionItem::new(CompletionKind::Keyword, source_range, "self")
                 .kind(CompletionItemKind::Keyword)
                 .add_to(acc);
-            CompletionItem::new(CompletionKind::Keyword, source_range, "super")
+            CompletionItem::new(CompletionKind::Keyword, source_range, "super::")
                 .kind(CompletionItemKind::Keyword)
                 .insert_text("super::")
                 .add_to(acc);
         }
         _ => {}
     }
-}
 
-fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
-    let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
-        .kind(CompletionItemKind::Keyword);
-
-    match ctx.config.snippet_cap {
-        Some(cap) => res.insert_snippet(cap, snippet),
-        _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
+    // Suggest .await syntax for types that implement Future trait
+    if let Some(receiver) = &ctx.dot_receiver {
+        if let Some(ty) = ctx.sema.type_of_expr(receiver) {
+            if ty.impls_future(ctx.db) {
+                CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
+                    .kind(CompletionItemKind::Keyword)
+                    .detail("expr.await")
+                    .insert_text("await")
+                    .add_to(acc);
+            }
+        };
     }
-    .build()
 }
 
 pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_trivial_path {
+    if ctx.token.kind() == SyntaxKind::COMMENT {
+        mark::hit!(no_keyword_completion_in_comments);
         return;
     }
 
-    let fn_def = match &ctx.function_syntax {
-        Some(it) => it,
-        None => return,
-    };
-    acc.add(keyword(ctx, "if", "if $0 {}"));
-    acc.add(keyword(ctx, "match", "match $0 {}"));
-    acc.add(keyword(ctx, "while", "while $0 {}"));
-    acc.add(keyword(ctx, "loop", "loop {$0}"));
+    let has_trait_or_impl_parent = ctx.has_impl_parent || ctx.has_trait_parent;
+    if ctx.trait_as_prev_sibling || ctx.impl_as_prev_sibling {
+        add_keyword(ctx, acc, "where", "where ");
+        return;
+    }
+    if ctx.unsafe_is_prev {
+        if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+            add_keyword(ctx, acc, "fn", "fn $0() {}")
+        }
+
+        if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+            || ctx.block_expr_parent
+        {
+            add_keyword(ctx, acc, "trait", "trait $0 {}");
+            add_keyword(ctx, acc, "impl", "impl $0 {}");
+        }
+
+        return;
+    }
+    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+        add_keyword(ctx, acc, "fn", "fn $0() {}");
+    }
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "use", "use ");
+        add_keyword(ctx, acc, "impl", "impl $0 {}");
+        add_keyword(ctx, acc, "trait", "trait $0 {}");
+    }
+
+    if ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent {
+        add_keyword(ctx, acc, "enum", "enum $0 {}");
+        add_keyword(ctx, acc, "struct", "struct $0");
+        add_keyword(ctx, acc, "union", "union $0 {}");
+    }
+
+    if ctx.is_expr {
+        add_keyword(ctx, acc, "match", "match $0 {}");
+        add_keyword(ctx, acc, "while", "while $0 {}");
+        add_keyword(ctx, acc, "loop", "loop {$0}");
+        add_keyword(ctx, acc, "if", "if ");
+        add_keyword(ctx, acc, "if let", "if let ");
+    }
+
+    if ctx.if_is_prev || ctx.block_expr_parent {
+        add_keyword(ctx, acc, "let", "let ");
+    }
 
     if ctx.after_if {
-        acc.add(keyword(ctx, "else", "else {$0}"));
-        acc.add(keyword(ctx, "else if", "else if $0 {}"));
+        add_keyword(ctx, acc, "else", "else {$0}");
+        add_keyword(ctx, acc, "else if", "else if $0 {}");
+    }
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "mod", "mod $0 {}");
+    }
+    if ctx.bind_pat_parent || ctx.ref_pat_parent {
+        add_keyword(ctx, acc, "mut", "mut ");
+    }
+    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+        add_keyword(ctx, acc, "const", "const ");
+        add_keyword(ctx, acc, "type", "type ");
+    }
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "static", "static ");
+    };
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "extern", "extern ");
+    }
+    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent || ctx.is_match_arm {
+        add_keyword(ctx, acc, "unsafe", "unsafe ");
     }
-    if is_in_loop_body(&ctx.token) {
+    if ctx.in_loop_body {
         if ctx.can_be_stmt {
-            acc.add(keyword(ctx, "continue", "continue;"));
-            acc.add(keyword(ctx, "break", "break;"));
+            add_keyword(ctx, acc, "continue", "continue;");
+            add_keyword(ctx, acc, "break", "break;");
         } else {
-            acc.add(keyword(ctx, "continue", "continue"));
-            acc.add(keyword(ctx, "break", "break"));
+            add_keyword(ctx, acc, "continue", "continue");
+            add_keyword(ctx, acc, "break", "break");
         }
     }
+    if ctx.has_item_list_or_source_file_parent && !ctx.has_trait_parent {
+        add_keyword(ctx, acc, "pub", "pub ")
+    }
+
+    if !ctx.is_trivial_path {
+        return;
+    }
+    let fn_def = match &ctx.function_syntax {
+        Some(it) => it,
+        None => return,
+    };
     acc.add_all(complete_return(ctx, &fn_def, ctx.can_be_stmt));
 }
 
-fn is_in_loop_body(leaf: &SyntaxToken) -> bool {
-    // FIXME move this to CompletionContext and make it handle macros
-    for node in leaf.parent().ancestors() {
-        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
-            break;
-        }
-        let loop_body = match_ast! {
-            match node {
-                ast::ForExpr(it) => it.loop_body(),
-                ast::WhileExpr(it) => it.loop_body(),
-                ast::LoopExpr(it) => it.loop_body(),
-                _ => None,
-            }
-        };
-        if let Some(body) = loop_body {
-            if body.syntax().text_range().contains_range(leaf.text_range()) {
-                return true;
-            }
-        }
+fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
+    let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
+        .kind(CompletionItemKind::Keyword);
+
+    match ctx.config.snippet_cap {
+        Some(cap) => res.insert_snippet(cap, snippet),
+        _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
     }
-    false
+    .build()
+}
+
+fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
+    acc.add(keyword(ctx, kw, snippet));
 }
 
 fn complete_return(
@@ -121,666 +187,354 @@ fn complete_return(
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
+
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
+    use test_utils::mark;
 
-    fn do_keyword_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Keyword)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Keyword);
+        expect.assert_eq(&actual)
     }
 
     #[test]
-    fn completes_keywords_in_use_stmt() {
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                use <|>
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "crate",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "crate::",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "self",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "super::",
-                kind: Keyword,
-            },
-        ]
-        "###
+    fn test_keywords_in_use_stmt() {
+        check(
+            r"use <|>",
+            expect![[r#"
+                kw crate::
+                kw self
+                kw super::
+            "#]],
         );
 
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                use a::<|>
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "self",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "super::",
-                kind: Keyword,
-            },
-        ]
-        "###
+        check(
+            r"use a::<|>",
+            expect![[r#"
+                kw self
+                kw super::
+            "#]],
         );
 
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                use a::{b, <|>}
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "self",
-                source_range: 28..28,
-                delete: 28..28,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 28..28,
-                delete: 28..28,
-                insert: "super::",
-                kind: Keyword,
-            },
-        ]
-        "###
+        check(
+            r"use a::{b, <|>}",
+            expect![[r#"
+                kw self
+                kw super::
+            "#]],
         );
     }
 
     #[test]
-    fn completes_various_keywords_in_function() {
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() {
-                    <|>
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "if",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    fn test_keywords_at_source_file_level() {
+        check(
+            r"m<|>",
+            expect![[r#"
+                kw const
+                kw enum
+                kw extern
+                kw fn
+                kw impl
+                kw mod
+                kw pub
+                kw static
+                kw struct
+                kw trait
+                kw type
+                kw union
+                kw unsafe
+                kw use
+            "#]],
         );
     }
 
     #[test]
-    fn completes_else_after_if() {
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() {
-                    if true {
-                        ()
-                    } <|>
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "else",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "else {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "else if",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "else if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "if",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    fn test_keywords_in_function() {
+        check(
+            r"fn quux() { <|> }",
+            expect![[r#"
+                kw const
+                kw extern
+                kw fn
+                kw if
+                kw if let
+                kw impl
+                kw let
+                kw loop
+                kw match
+                kw mod
+                kw return
+                kw static
+                kw trait
+                kw type
+                kw unsafe
+                kw use
+                kw while
+            "#]],
         );
     }
 
     #[test]
-    fn test_completion_return_value() {
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() -> i32 {
-                    <|>
-                    92
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "if",
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    fn test_keywords_inside_block() {
+        check(
+            r"fn quux() { if true { <|> } }",
+            expect![[r#"
+                kw const
+                kw extern
+                kw fn
+                kw if
+                kw if let
+                kw impl
+                kw let
+                kw loop
+                kw match
+                kw mod
+                kw return
+                kw static
+                kw trait
+                kw type
+                kw unsafe
+                kw use
+                kw while
+            "#]],
         );
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() {
-                    <|>
-                    92
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "if",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    }
+
+    #[test]
+    fn test_keywords_after_if() {
+        check(
+            r#"fn quux() { if true { () } <|> }"#,
+            expect![[r#"
+                kw const
+                kw else
+                kw else if
+                kw extern
+                kw fn
+                kw if
+                kw if let
+                kw impl
+                kw let
+                kw loop
+                kw match
+                kw mod
+                kw return
+                kw static
+                kw trait
+                kw type
+                kw unsafe
+                kw use
+                kw while
+            "#]],
+        );
+        check_edit(
+            "else",
+            r#"fn quux() { if true { () } <|> }"#,
+            r#"fn quux() { if true { () } else {$0} }"#,
         );
     }
 
     #[test]
-    fn dont_add_semi_after_return_if_not_a_statement() {
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() -> i32 {
-                    match () {
-                        () => <|>
-                    }
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "if",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "return $0",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    fn test_keywords_in_match_arm() {
+        check(
+            r#"
+fn quux() -> i32 {
+    match () { () => <|> }
+}
+"#,
+            expect![[r#"
+                kw if
+                kw if let
+                kw loop
+                kw match
+                kw return
+                kw unsafe
+                kw while
+            "#]],
         );
     }
 
     #[test]
-    fn last_return_in_block_has_semi() {
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() -> i32 {
-                    if condition {
-                        <|>
-                    }
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "if",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    fn test_keywords_in_trait_def() {
+        check(
+            r"trait My { <|> }",
+            expect![[r#"
+                kw const
+                kw fn
+                kw type
+                kw unsafe
+            "#]],
         );
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() -> i32 {
-                    if condition {
-                        <|>
-                    }
-                    let x = 92;
-                    x
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "if",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    }
+
+    #[test]
+    fn test_keywords_in_impl_def() {
+        check(
+            r"impl My { <|> }",
+            expect![[r#"
+                kw const
+                kw fn
+                kw pub
+                kw type
+                kw unsafe
+            "#]],
         );
     }
 
     #[test]
-    fn completes_break_and_continue_in_loops() {
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() -> i32 {
-                    loop { <|> }
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "break",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "break;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "continue",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "continue;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "if",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    fn test_keywords_in_loop() {
+        check(
+            r"fn my() { loop { <|> } }",
+            expect![[r#"
+                kw break
+                kw const
+                kw continue
+                kw extern
+                kw fn
+                kw if
+                kw if let
+                kw impl
+                kw let
+                kw loop
+                kw match
+                kw mod
+                kw return
+                kw static
+                kw trait
+                kw type
+                kw unsafe
+                kw use
+                kw while
+            "#]],
         );
+    }
 
-        // No completion: lambda isolates control flow
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() -> i32 {
-                    loop { || { <|> } }
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "if",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    #[test]
+    fn test_keywords_after_unsafe_in_item_list() {
+        check(
+            r"unsafe <|>",
+            expect![[r#"
+                kw fn
+                kw impl
+                kw trait
+            "#]],
         );
     }
 
     #[test]
-    fn no_semi_after_break_continue_in_expr() {
-        assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn f() {
-                    loop {
-                        match () {
-                            () => br<|>
-                        }
-                    }
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "break",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "break",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "continue",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "continue",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "if",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "return",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
-        "###
+    fn test_keywords_after_unsafe_in_block_expr() {
+        check(
+            r"fn my_fn() { unsafe <|> }",
+            expect![[r#"
+                kw fn
+                kw impl
+                kw trait
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_mut_in_ref_and_in_fn_parameters_list() {
+        check(
+            r"fn my_fn(&<|>) {}",
+            expect![[r#"
+                kw mut
+            "#]],
+        );
+        check(
+            r"fn my_fn(<|>) {}",
+            expect![[r#"
+                kw mut
+            "#]],
+        );
+        check(
+            r"fn my_fn() { let &<|> }",
+            expect![[r#"
+                kw mut
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_where_keyword() {
+        check(
+            r"trait A <|>",
+            expect![[r#"
+                kw where
+            "#]],
+        );
+        check(
+            r"impl A <|>",
+            expect![[r#"
+                kw where
+            "#]],
+        );
+    }
+
+    #[test]
+    fn no_keyword_completion_in_comments() {
+        mark::check!(no_keyword_completion_in_comments);
+        check(
+            r#"
+fn test() {
+    let x = 2; // A comment<|>
+}
+"#,
+            expect![[""]],
+        );
+        check(
+            r#"
+/*
+Some multi-line comment<|>
+*/
+"#,
+            expect![[""]],
+        );
+        check(
+            r#"
+/// Some doc comment
+/// let test<|> = 1
+"#,
+            expect![[""]],
+        );
+    }
+
+    #[test]
+    fn test_completion_await_impls_future() {
+        check(
+            r#"
+//- /main.rs
+use std::future::*;
+struct A {}
+impl Future for A {}
+fn foo(a: A) { a.<|> }
+
+//- /std/lib.rs
+pub mod future {
+    #[lang = "future_trait"]
+    pub trait Future {}
+}
+"#,
+            expect![[r#"
+                kw await expr.await
+            "#]],
+        )
+    }
+
+    #[test]
+    fn after_let() {
+        check(
+            r#"fn main() { let _ = <|> }"#,
+            expect![[r#"
+                kw if
+                kw if let
+                kw loop
+                kw match
+                kw return
+                kw while
+            "#]],
         )
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
index d9bb5fd25..0447f0511 100644
--- a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
+++ b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
@@ -5,7 +5,7 @@ use crate::completion::{CompletionContext, Completions};
 pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
     // Show only macros in top level.
     if ctx.is_new_item {
-        ctx.scope().process_all_names(&mut |name, res| {
+        ctx.scope.process_all_names(&mut |name, res| {
             if let hir::ScopeDef::MacroDef(mac) = res {
                 acc.add_macro(ctx, Some(name.to_string()), mac);
             }
@@ -15,130 +15,27 @@ pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &Compl
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::completion_list, CompletionKind};
 
-    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn completes_macros_as_item() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn foo() {}
-
-                <|>
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 46..46,
-                delete: 46..46,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn completes_vec_macros_with_square_brackets() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                /// Creates a [`Vec`] containing the arguments.
-                ///
-                /// - Create a [`Vec`] containing a given list of elements:
-                ///
-                /// ```
-                /// let v = vec![1, 2, 3];
-                /// assert_eq!(v[0], 1);
-                /// assert_eq!(v[1], 2);
-                /// assert_eq!(v[2], 3);
-                /// ```
-                macro_rules! vec {
-                    () => {}
-                }
-
-                fn foo() {}
-
-                <|>
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "vec![…]",
-                source_range: 280..280,
-                delete: 280..280,
-                insert: "vec![$0]",
-                kind: Macro,
-                detail: "macro_rules! vec",
-                documentation: Documentation(
-                    "Creates a [`Vec`] containing the arguments.\n\n- Create a [`Vec`] containing a given list of elements:\n\n```\nlet v = vec![1, 2, 3];\nassert_eq!(v[0], 1);\nassert_eq!(v[1], 2);\nassert_eq!(v[2], 3);\n```",
-                ),
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn completes_macros_braces_guessing() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                /// Foo
-                ///
-                /// Not call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`.
-                /// Call as `let _=foo!  { hello world };`
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn main() {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo! {…}",
-                source_range: 163..163,
-                delete: 163..163,
-                insert: "foo! {$0}",
-                kind: Macro,
-                detail: "macro_rules! foo",
-                documentation: Documentation(
-                    "Foo\n\nNot call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`.\nCall as `let _=foo!  { hello world };`",
-                ),
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 163..163,
-                delete: 163..163,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+macro_rules! foo { () => {} }
+fn foo() {}
+
+<|>
+"#,
+            expect![[r#"
+                ma foo!(…) macro_rules! foo
+            "#]],
+        )
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_pattern.rs b/crates/ra_ide/src/completion/complete_pattern.rs
index fdd9e928b..aceb77cb5 100644
--- a/crates/ra_ide/src/completion/complete_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_pattern.rs
@@ -13,7 +13,7 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 
     // FIXME: ideally, we should look at the type we are matching against and
     // suggest variants + auto-imports
-    ctx.scope().process_all_names(&mut |name, res| {
+    ctx.scope.process_all_names(&mut |name, res| {
         match &res {
             hir::ScopeDef::ModuleDef(def) => match def {
                 hir::ModuleDef::Adt(hir::Adt::Enum(..))
@@ -33,106 +33,56 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    fn complete(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
+    use crate::completion::{test_utils::completion_list, CompletionKind};
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn completes_enum_variants_and_modules() {
-        let completions = complete(
-            r"
-            enum E { X }
-            use self::E::X;
-            const Z: E = E::X;
-            mod m {}
+        check(
+            r#"
+enum E { X }
+use self::E::X;
+const Z: E = E::X;
+mod m {}
 
-            static FOO: E = E::X;
-            struct Bar { f: u32 }
+static FOO: E = E::X;
+struct Bar { f: u32 }
 
-            fn foo() {
-               match E::X {
-                   <|>
-               }
-            }
-            ",
+fn foo() {
+   match E::X { <|> }
+}
+"#,
+            expect![[r#"
+                st Bar
+                en E
+                ev X   ()
+                ct Z
+                md m
+            "#]],
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "Bar",
-                source_range: 246..246,
-                delete: 246..246,
-                insert: "Bar",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "E",
-                source_range: 246..246,
-                delete: 246..246,
-                insert: "E",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "X",
-                source_range: 246..246,
-                delete: 246..246,
-                insert: "X",
-                kind: EnumVariant,
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Z",
-                source_range: 246..246,
-                delete: 246..246,
-                insert: "Z",
-                kind: Const,
-            },
-            CompletionItem {
-                label: "m",
-                source_range: 246..246,
-                delete: 246..246,
-                insert: "m",
-                kind: Module,
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn completes_in_simple_macro_call() {
-        let completions = complete(
-            r"
-            macro_rules! m { ($e:expr) => { $e } }
-            enum E { X }
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+enum E { X }
 
-            fn foo() {
-               m!(match E::X {
-                   <|>
-               })
-            }
-            ",
+fn foo() {
+   m!(match E::X { <|> })
+}
+"#,
+            expect![[r#"
+                en E
+                ma m!(…) macro_rules! m
+            "#]],
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "E",
-                source_range: 151..151,
-                delete: 151..151,
-                insert: "E",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "m!(…)",
-                source_range: 151..151,
-                delete: 151..151,
-                insert: "m!($0)",
-                kind: Macro,
-                detail: "macro_rules! m",
-            },
-        ]
-        "###);
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 59b58bf98..8735b9010 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -8,14 +8,13 @@ use ra_text_edit::TextEdit;
 
 use crate::{
     completion::{
+        completion_config::SnippetCap,
         completion_context::CompletionContext,
         completion_item::{Builder, CompletionKind, Completions},
     },
-    CompletionItem,
+    CompletionItem, CompletionItemKind,
 };
 
-use super::completion_config::SnippetCap;
-
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.config.enable_postfix_completions {
         return;
@@ -91,7 +90,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
             &dot_receiver,
             "if",
             "if expr {}",
-            &format!("if {} {{$0}}", receiver_text),
+            &format!("if {} {{\n    $0\n}}", receiver_text),
         )
         .add_to(acc);
         postfix_snippet(
@@ -100,13 +99,12 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
             &dot_receiver,
             "while",
             "while expr {}",
-            &format!("while {} {{\n$0\n}}", receiver_text),
+            &format!("while {} {{\n    $0\n}}", receiver_text),
         )
         .add_to(acc);
+        postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
+            .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);
 
     postfix_snippet(ctx, cap, &dot_receiver, "ref", "&expr", &format!("&{}", receiver_text))
         .add_to(acc);
@@ -125,33 +123,35 @@ 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(
+        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),
+                    &format!("match {} {{\n    Ok(${{1:_}}) => {{$2}},\n    Err(${{3:_}}) => {{$0}},\n}}", receiver_text),
                 )
                 .add_to(acc);
-                }
-                TryEnum::Option => {
-                    postfix_snippet(
+            }
+            TryEnum::Option => {
+                postfix_snippet(
                     ctx,
                     cap,
                     &dot_receiver,
                     "match",
                     "match expr {}",
-                    &format!("match {} {{\n    Some(${{1:_}}) => {{$2\\}},\n    None => {{$0\\}},\n}}", receiver_text),
+                    &format!(
+                        "match {} {{\n    Some(${{1:_}}) => {{$2}},\n    None => {{$0}},\n}}",
+                        receiver_text
+                    ),
                 )
                 .add_to(acc);
-                }
             }
-        }
+        },
         None => {
             postfix_snippet(
                 ctx,
@@ -159,7 +159,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
                 &dot_receiver,
                 "match",
                 "match expr {}",
-                &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
+                &format!("match {} {{\n    ${{1:_}} => {{$0}},\n}}", receiver_text),
             )
             .add_to(acc);
         }
@@ -232,536 +232,147 @@ fn postfix_snippet(
     };
     CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
         .detail(detail)
+        .kind(CompletionItemKind::Snippet)
         .snippet_edit(cap, edit)
 }
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
 
-    fn do_postfix_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Postfix)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Postfix);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn postfix_completion_works_for_trivial_path_expression() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                fn main() {
-                    let bar = true;
-                    bar.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 89..89,
-                delete: 85..89,
-                insert: "Box::new(bar)",
-                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,
-                insert: "dbg!(bar)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "if",
-                source_range: 89..89,
-                delete: 85..89,
-                insert: "if bar {$0}",
-                detail: "if expr {}",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 89..89,
-                delete: 85..89,
-                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 89..89,
-                delete: 85..89,
-                insert: "!bar",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 89..89,
-                delete: 85..89,
-                insert: "&bar",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 89..89,
-                delete: 85..89,
-                insert: "&mut bar",
-                detail: "&mut expr",
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 89..89,
-                delete: 85..89,
-                insert: "while bar {\n$0\n}",
-                detail: "while expr {}",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn main() {
+    let bar = true;
+    bar.<|>
+}
+"#,
+            expect![[r#"
+                sn box   Box::new(expr)
+                sn call  function(expr)
+                sn dbg   dbg!(expr)
+                sn if    if expr {}
+                sn match match expr {}
+                sn not   !expr
+                sn ref   &expr
+                sn refm  &mut expr
+                sn while while expr {}
+            "#]],
         );
     }
 
     #[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 {}",
-            },
-        ]
-        "###
-        );
+    fn postfix_type_filtering() {
+        check(
+            r#"
+fn main() {
+    let bar: u8 = 12;
+    bar.<|>
+}
+"#,
+            expect![[r#"
+                sn box   Box::new(expr)
+                sn call  function(expr)
+                sn dbg   dbg!(expr)
+                sn match match expr {}
+                sn ref   &expr
+                sn refm  &mut expr
+            "#]],
+        )
     }
 
     #[test]
-    fn postfix_completion_works_for_result() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                enum Result<T, E> {
-                    Ok(T),
-                    Err(E),
-                }
+    fn option_iflet() {
+        check_edit(
+            "ifl",
+            r#"
+enum Option<T> { Some(T), None }
+
+fn main() {
+    let bar = Option::Some(true);
+    bar.<|>
+}
+"#,
+            r#"
+enum Option<T> { Some(T), None }
 
-                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 {}",
-            },
-        ]
-        "###
+fn main() {
+    let bar = Option::Some(true);
+    if let Some($1) = bar {
+    $0
+}
+}
+"#,
         );
     }
 
     #[test]
-    fn some_postfix_completions_ignored() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                fn main() {
-                    let bar: u8 = 12;
-                    bar.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 91..91,
-                delete: 87..91,
-                insert: "Box::new(bar)",
-                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,
-                insert: "dbg!(bar)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 91..91,
-                delete: 87..91,
-                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 91..91,
-                delete: 87..91,
-                insert: "!bar",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 91..91,
-                delete: 87..91,
-                insert: "&bar",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 91..91,
-                delete: 87..91,
-                insert: "&mut bar",
-                detail: "&mut expr",
-            },
-        ]
-        "###
+    fn result_match() {
+        check_edit(
+            "match",
+            r#"
+enum Result<T, E> { Ok(T), Err(E) }
+
+fn main() {
+    let bar = Result::Ok(true);
+    bar.<|>
+}
+"#,
+            r#"
+enum Result<T, E> { Ok(T), Err(E) }
+
+fn main() {
+    let bar = Result::Ok(true);
+    match bar {
+    Ok(${1:_}) => {$2},
+    Err(${3:_}) => {$0},
+}
+}
+"#,
         );
     }
 
     #[test]
     fn postfix_completion_works_for_ambiguous_float_literal() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                fn main() {
-                    42.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 52..52,
-                delete: 49..52,
-                insert: "Box::new(42)",
-                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,
-                insert: "dbg!(42)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 52..52,
-                delete: 49..52,
-                insert: "match 42 {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 52..52,
-                delete: 49..52,
-                insert: "!42",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 52..52,
-                delete: 49..52,
-                insert: "&42",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 52..52,
-                delete: 49..52,
-                insert: "&mut 42",
-                detail: "&mut expr",
-            },
-        ]
-        "###
-        );
+        check_edit("refm", r#"fn main() { 42.<|> }"#, r#"fn main() { &mut 42 }"#)
     }
 
     #[test]
     fn works_in_simple_macro() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                macro_rules! m { ($e:expr) => { $e } }
-                fn main() {
-                    let bar: u8 = 12;
-                    m!(bar.b<|>)
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 149..150,
-                delete: 145..150,
-                insert: "Box::new(bar)",
-                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,
-                insert: "dbg!(bar)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 149..150,
-                delete: 145..150,
-                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 149..150,
-                delete: 145..150,
-                insert: "!bar",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 149..150,
-                delete: 145..150,
-                insert: "&bar",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 149..150,
-                delete: 145..150,
-                insert: "&mut bar",
-                detail: "&mut expr",
-            },
-        ]
-        "###
+        check_edit(
+            "dbg",
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+fn main() {
+    let bar: u8 = 12;
+    m!(bar.d<|>)
+}
+"#,
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+fn main() {
+    let bar: u8 = 12;
+    m!(dbg!(bar))
+}
+"#,
         );
     }
 
     #[test]
     fn postfix_completion_for_references() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                fn main() {
-                    &&&&42.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 56..56,
-                delete: 49..56,
-                insert: "Box::new(&&&&42)",
-                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,
-                insert: "dbg!(&&&&42)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 56..56,
-                delete: 49..56,
-                insert: "match &&&&42 {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 56..56,
-                delete: 53..56,
-                insert: "!42",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 56..56,
-                delete: 53..56,
-                insert: "&42",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 56..56,
-                delete: 53..56,
-                insert: "&mut 42",
-                detail: "&mut expr",
-            },
-        ]
-        "###
-        );
+        check_edit("dbg", r#"fn main() { &&42.<|> }"#, r#"fn main() { dbg!(&&42) }"#);
+        check_edit("refm", r#"fn main() { &&42.<|> }"#, r#"fn main() { &&&mut 42 }"#);
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_qualified_path.rs b/crates/ra_ide/src/completion/complete_qualified_path.rs
index 02ac0166b..b08f5b9b4 100644
--- a/crates/ra_ide/src/completion/complete_qualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_qualified_path.rs
@@ -17,21 +17,20 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
         return;
     }
 
-    let scope = ctx.scope();
-    let context_module = scope.module();
+    let context_module = ctx.scope.module();
 
-    let res = match scope.resolve_hir_path_qualifier(&path) {
+    let resolution = match ctx.scope.resolve_hir_path_qualifier(&path) {
         Some(res) => res,
         None => return,
     };
 
     // Add associated types on type parameters and `Self`.
-    res.assoc_type_shorthand_candidates(ctx.db, |alias| {
+    resolution.assoc_type_shorthand_candidates(ctx.db, |alias| {
         acc.add_type_alias(ctx, alias);
         None::<()>
     });
 
-    match res {
+    match resolution {
         PathResolution::Def(hir::ModuleDef::Module(module)) => {
             let module_scope = module.scope(ctx.db, context_module);
             for (name, def) in module_scope {
@@ -68,7 +67,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
 
             let krate = ctx.krate;
             if let Some(krate) = krate {
-                let traits_in_scope = ctx.scope().traits_in_scope();
+                let traits_in_scope = ctx.scope.traits_in_scope();
                 ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
                     if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
                         return None;
@@ -113,13 +112,13 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
         }
         PathResolution::TypeParam(_) | PathResolution::SelfType(_) => {
             if let Some(krate) = ctx.krate {
-                let ty = match res {
+                let ty = match resolution {
                     PathResolution::TypeParam(param) => param.ty(ctx.db),
                     PathResolution::SelfType(impl_def) => impl_def.target_ty(ctx.db),
                     _ => return,
                 };
 
-                let traits_in_scope = ctx.scope().traits_in_scope();
+                let traits_in_scope = ctx.scope.traits_in_scope();
                 let mut seen = FxHashSet::default();
                 ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
                     if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
@@ -147,1229 +146,588 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
 
 #[cfg(test)]
 mod tests {
+    use expect::{expect, Expect};
     use test_utils::mark;
 
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual);
+    }
 
-    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
+    fn check_builtin(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::BuiltinType);
+        expect.assert_eq(&actual);
     }
 
     #[test]
     fn dont_complete_current_use() {
         mark::check!(dont_complete_current_use);
-        let completions = do_completion(r"use self::foo<|>;", CompletionKind::Reference);
-        assert!(completions.is_empty());
+        check(r#"use self::foo<|>;"#, expect![[""]]);
     }
 
     #[test]
     fn dont_complete_current_use_in_braces_with_glob() {
-        let completions = do_completion(
-            r"
-            mod foo { pub struct S; }
-            use self::{foo::*, bar<|>};
-            ",
-            CompletionKind::Reference,
+        check(
+            r#"
+mod foo { pub struct S; }
+use self::{foo::*, bar<|>};
+"#,
+            expect![[r#"
+                st S
+                md foo
+            "#]],
         );
-        assert_eq!(completions.len(), 2);
     }
 
     #[test]
     fn dont_complete_primitive_in_use() {
-        let completions = do_completion(r"use self::<|>;", CompletionKind::BuiltinType);
-        assert!(completions.is_empty());
+        check_builtin(r#"use self::<|>;"#, expect![[""]]);
     }
 
     #[test]
     fn dont_complete_primitive_in_module_scope() {
-        let completions = do_completion(r"fn foo() { self::<|> }", CompletionKind::BuiltinType);
-        assert!(completions.is_empty());
+        check_builtin(r#"fn foo() { self::<|> }"#, expect![[""]]);
     }
 
     #[test]
     fn completes_primitives() {
-        let completions =
-            do_completion(r"fn main() { let _: <|> = 92; }", CompletionKind::BuiltinType);
-        assert_eq!(completions.len(), 17);
-    }
-
-    #[test]
-    fn completes_mod_with_docs() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                use self::my<|>;
-
-                /// Some simple
-                /// docs describing `mod my`.
-                mod my {
-                    struct Bar;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "my",
-                source_range: 27..29,
-                delete: 27..29,
-                insert: "my",
-                kind: Module,
-                documentation: Documentation(
-                    "Some simple\ndocs describing `mod my`.",
-                ),
-            },
-        ]
-        "###
+        check_builtin(
+            r#"fn main() { let _: <|> = 92; }"#,
+            expect![[r#"
+                bt bool
+                bt char
+                bt f32
+                bt f64
+                bt i128
+                bt i16
+                bt i32
+                bt i64
+                bt i8
+                bt isize
+                bt str
+                bt u128
+                bt u16
+                bt u32
+                bt u64
+                bt u8
+                bt usize
+            "#]],
         );
     }
 
     #[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,
-            },
-        ]
-        "###
+        check(
+            r#"
+use self::my::<|>;
+
+mod my { pub struct Bar; }
+fn my() {}
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
         );
     }
 
     #[test]
-    fn path_visibility() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                use self::my::<|>;
-
-                mod my {
-                    struct Bar;
-                    pub struct Foo;
-                    pub use Bar as PublicBar;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Foo",
-                source_range: 31..31,
-                delete: 31..31,
-                insert: "Foo",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "PublicBar",
-                source_range: 31..31,
-                delete: 31..31,
-                insert: "PublicBar",
-                kind: Struct,
-            },
-        ]
-        "###
+    fn filters_visibility() {
+        check(
+            r#"
+use self::my::<|>;
+
+mod my {
+    struct Bar;
+    pub struct Foo;
+    pub use Bar as PublicBar;
+}
+"#,
+            expect![[r#"
+                st Foo
+                st PublicBar
+            "#]],
         );
     }
 
     #[test]
     fn completes_use_item_starting_with_self() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                use self::m::<|>;
+        check(
+            r#"
+use self::m::<|>;
 
-                mod m {
-                    pub struct Bar;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Bar",
-                source_range: 30..30,
-                delete: 30..30,
-                insert: "Bar",
-                kind: Struct,
-            },
-        ]
-        "###
+mod m { pub struct Bar; }
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
         );
     }
 
     #[test]
     fn completes_use_item_starting_with_crate() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                mod foo;
-                struct Spam;
-                //- /foo.rs
-                use crate::Sp<|>
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Spam",
-                source_range: 11..13,
-                delete: 11..13,
-                insert: "Spam",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "foo",
-                source_range: 11..13,
-                delete: 11..13,
-                insert: "foo",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /lib.rs
+mod foo;
+struct Spam;
+//- /foo.rs
+use crate::Sp<|>
+"#,
+            expect![[r#"
+                st Spam
+                md foo
+            "#]],
         );
     }
 
     #[test]
     fn completes_nested_use_tree() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                mod foo;
-                struct Spam;
-                //- /foo.rs
-                use crate::{Sp<|>};
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Spam",
-                source_range: 12..14,
-                delete: 12..14,
-                insert: "Spam",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "foo",
-                source_range: 12..14,
-                delete: 12..14,
-                insert: "foo",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /lib.rs
+mod foo;
+struct Spam;
+//- /foo.rs
+use crate::{Sp<|>};
+"#,
+            expect![[r#"
+                st Spam
+                md foo
+            "#]],
         );
     }
 
     #[test]
     fn completes_deeply_nested_use_tree() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                mod foo;
-                pub mod bar {
-                    pub mod baz {
-                        pub struct Spam;
-                    }
-                }
-                //- /foo.rs
-                use crate::{bar::{baz::Sp<|>}};
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Spam",
-                source_range: 23..25,
-                delete: 23..25,
-                insert: "Spam",
-                kind: Struct,
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn completes_enum_variant() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// An enum
-                enum E {
-                    /// Foo Variant
-                    Foo,
-                    /// Bar Variant with i32
-                    Bar(i32)
-                }
-                fn foo() { let _ = E::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Bar(…)",
-                source_range: 116..116,
-                delete: 116..116,
-                insert: "Bar($0)",
-                kind: EnumVariant,
-                lookup: "Bar",
-                detail: "(i32)",
-                documentation: Documentation(
-                    "Bar Variant with i32",
-                ),
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "Foo",
-                source_range: 116..116,
-                delete: 116..116,
-                insert: "Foo",
-                kind: EnumVariant,
-                detail: "()",
-                documentation: Documentation(
-                    "Foo Variant",
-                ),
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn completes_enum_variant_with_details() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                struct S { field: u32 }
-                /// An enum
-                enum E {
-                    /// Foo Variant (empty)
-                    Foo,
-                    /// Bar Variant with i32 and u32
-                    Bar(i32, u32),
-                    ///
-                    S(S),
-                }
-                fn foo() { let _ = E::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Bar(…)",
-                source_range: 180..180,
-                delete: 180..180,
-                insert: "Bar($0)",
-                kind: EnumVariant,
-                lookup: "Bar",
-                detail: "(i32, u32)",
-                documentation: Documentation(
-                    "Bar Variant with i32 and u32",
-                ),
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "Foo",
-                source_range: 180..180,
-                delete: 180..180,
-                insert: "Foo",
-                kind: EnumVariant,
-                detail: "()",
-                documentation: Documentation(
-                    "Foo Variant (empty)",
-                ),
-            },
-            CompletionItem {
-                label: "S(…)",
-                source_range: 180..180,
-                delete: 180..180,
-                insert: "S($0)",
-                kind: EnumVariant,
-                lookup: "S",
-                detail: "(S)",
-                documentation: Documentation(
-                    "",
-                ),
-                trigger_call_info: true,
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+//- /lib.rs
+mod foo;
+pub mod bar {
+    pub mod baz {
+        pub struct Spam;
     }
-
-    #[test]
-    fn completes_struct_associated_method() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A Struct
-                struct S;
-
-                impl S {
-                    /// An associated method
-                    fn m() { }
-                }
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 100..100,
-                delete: 100..100,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "An associated method",
-                ),
-            },
-        ]
-        "###
+}
+//- /foo.rs
+use crate::{bar::{baz::Sp<|>}};
+"#,
+            expect![[r#"
+                st Spam
+            "#]],
         );
     }
 
     #[test]
-    fn completes_struct_associated_method_with_self() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A Struct
-                struct S;
-
-                impl S {
-                    /// An associated method
-                    fn m(&self) { }
-                }
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 105..105,
-                delete: 105..105,
-                insert: "m()$0",
-                kind: Method,
-                lookup: "m",
-                detail: "fn m(&self)",
-                documentation: Documentation(
-                    "An associated method",
-                ),
-            },
-        ]
-        "###
+    fn completes_enum_variant() {
+        check(
+            r#"
+enum E { Foo, Bar(i32) }
+fn foo() { let _ = E::<|> }
+"#,
+            expect![[r#"
+                ev Bar(…) (i32)
+                ev Foo    ()
+            "#]],
         );
     }
 
     #[test]
-    fn completes_struct_associated_const() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A Struct
-                struct S;
-
-                impl S {
-                    /// An associated const
-                    const C: i32 = 42;
-                }
+    fn completes_struct_associated_items() {
+        check(
+            r#"
+//- /lib.rs
+struct S;
+
+impl S {
+    fn a() {}
+    fn b(&self) {}
+    const C: i32 = 42;
+    type T = i32;
+}
 
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "C",
-                source_range: 107..107,
-                delete: 107..107,
-                insert: "C",
-                kind: Const,
-                detail: "const C: i32 = 42;",
-                documentation: Documentation(
-                    "An associated const",
-                ),
-            },
-        ]
-        "###
+fn foo() { let _ = S::<|> }
+"#,
+            expect![[r#"
+                ct C   const C: i32 = 42;
+                ta T   type T = i32;
+                fn a() fn a()
+                me b() fn b(&self)
+            "#]],
         );
     }
 
     #[test]
-    fn completes_struct_associated_type() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A Struct
-                struct S;
-
-                impl S {
-                    /// An associated type
-                    type T = i32;
-                }
+    fn associated_item_visibility() {
+        check(
+            r#"
+struct S;
 
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "T",
-                source_range: 101..101,
-                delete: 101..101,
-                insert: "T",
-                kind: TypeAlias,
-                detail: "type T = i32;",
-                documentation: Documentation(
-                    "An associated type",
-                ),
-            },
-        ]
-        "###
-        );
+mod m {
+    impl super::S {
+        pub(super) fn public_method() { }
+        fn private_method() { }
+        pub(super) type PublicType = u32;
+        type PrivateType = u32;
+        pub(super) const PUBLIC_CONST: u32 = 1;
+        const PRIVATE_CONST: u32 = 1;
     }
+}
 
-    #[test]
-    fn associated_item_visibility() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                struct S;
-
-                mod m {
-                    impl super::S {
-                        pub(super) fn public_method() { }
-                        fn private_method() { }
-                        pub(super) type PublicType = u32;
-                        type PrivateType = u32;
-                        pub(super) const PUBLIC_CONST: u32 = 1;
-                        const PRIVATE_CONST: u32 = 1;
-                    }
-                }
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "PUBLIC_CONST",
-                source_range: 302..302,
-                delete: 302..302,
-                insert: "PUBLIC_CONST",
-                kind: Const,
-                detail: "pub(super) const PUBLIC_CONST: u32 = 1;",
-            },
-            CompletionItem {
-                label: "PublicType",
-                source_range: 302..302,
-                delete: 302..302,
-                insert: "PublicType",
-                kind: TypeAlias,
-                detail: "pub(super) type PublicType = u32;",
-            },
-            CompletionItem {
-                label: "public_method()",
-                source_range: 302..302,
-                delete: 302..302,
-                insert: "public_method()$0",
-                kind: Function,
-                lookup: "public_method",
-                detail: "pub(super) fn public_method()",
-            },
-        ]
-        "###
+fn foo() { let _ = S::<|> }
+"#,
+            expect![[r#"
+                ct PUBLIC_CONST    pub(super) const PUBLIC_CONST: u32 = 1;
+                ta PublicType      pub(super) type PublicType = u32;
+                fn public_method() pub(super) fn public_method()
+            "#]],
         );
     }
 
     #[test]
     fn completes_enum_associated_method() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// An enum
-                enum S {};
-
-                impl S {
-                    /// An associated method
-                    fn m() { }
-                }
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 100..100,
-                delete: 100..100,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "An associated method",
-                ),
-            },
-        ]
-        "###
+        check(
+            r#"
+enum E {};
+impl E { fn m() { } }
+
+fn foo() { let _ = E::<|> }
+        "#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_union_associated_method() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A union
-                union U {};
-
-                impl U {
-                    /// An associated method
-                    fn m() { }
-                }
-
-                fn foo() { let _ = U::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 101..101,
-                delete: 101..101,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "An associated method",
-                ),
-            },
-        ]
-        "###
+        check(
+            r#"
+union U {};
+impl U { fn m() { } }
+
+fn foo() { let _ = U::<|> }
+"#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_use_paths_across_crates() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                use foo::<|>;
-
-                //- /foo/lib.rs
-                pub mod bar {
-                    pub struct S;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "bar",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /main.rs
+use foo::<|>;
+
+//- /foo/lib.rs
+pub mod bar { pub struct S; }
+"#,
+            expect![[r#"
+                md bar
+            "#]],
         );
     }
 
     #[test]
     fn completes_trait_associated_method_1() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Trait {
-                  /// A trait method
-                  fn m();
-                }
+        check(
+            r#"
+trait Trait { fn m(); }
 
-                fn foo() { let _ = Trait::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 73..73,
-                delete: 73..73,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "A trait method",
-                ),
-            },
-        ]
-        "###
+fn foo() { let _ = Trait::<|> }
+"#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_trait_associated_method_2() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Trait {
-                  /// A trait method
-                  fn m();
-                }
+        check(
+            r#"
+trait Trait { fn m(); }
+
+struct S;
+impl Trait for S {}
 
-                struct S;
-                impl Trait for S {}
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 99..99,
-                delete: 99..99,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "A trait method",
-                ),
-            },
-        ]
-        "###
+fn foo() { let _ = S::<|> }
+"#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_trait_associated_method_3() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Trait {
-                  /// A trait method
-                  fn m();
-                }
+        check(
+            r#"
+trait Trait { fn m(); }
 
-                struct S;
-                impl Trait for S {}
-
-                fn foo() { let _ = <S as Trait>::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 110..110,
-                delete: 110..110,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "A trait method",
-                ),
-            },
-        ]
-        "###
+struct S;
+impl Trait for S {}
+
+fn foo() { let _ = <S as Trait>::<|> }
+"#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_ty_param_assoc_ty() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Super {
-                    type Ty;
-                    const CONST: u8;
-                    fn func() {}
-                    fn method(&self) {}
-                }
+        check(
+            r#"
+trait Super {
+    type Ty;
+    const CONST: u8;
+    fn func() {}
+    fn method(&self) {}
+}
 
-                trait Sub: Super {
-                    type SubTy;
-                    const C2: ();
-                    fn subfunc() {}
-                    fn submethod(&self) {}
-                }
+trait Sub: Super {
+    type SubTy;
+    const C2: ();
+    fn subfunc() {}
+    fn submethod(&self) {}
+}
 
-                fn foo<T: Sub>() {
-                    T::<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "C2",
-                source_range: 219..219,
-                delete: 219..219,
-                insert: "C2",
-                kind: Const,
-                detail: "const C2: ();",
-            },
-            CompletionItem {
-                label: "CONST",
-                source_range: 219..219,
-                delete: 219..219,
-                insert: "CONST",
-                kind: Const,
-                detail: "const CONST: u8;",
-            },
-            CompletionItem {
-                label: "SubTy",
-                source_range: 219..219,
-                delete: 219..219,
-                insert: "SubTy",
-                kind: TypeAlias,
-                detail: "type SubTy;",
-            },
-            CompletionItem {
-                label: "Ty",
-                source_range: 219..219,
-                delete: 219..219,
-                insert: "Ty",
-                kind: TypeAlias,
-                detail: "type Ty;",
-            },
-            CompletionItem {
-                label: "func()",
-                source_range: 219..219,
-                delete: 219..219,
-                insert: "func()$0",
-                kind: Function,
-                lookup: "func",
-                detail: "fn func()",
-            },
-            CompletionItem {
-                label: "method()",
-                source_range: 219..219,
-                delete: 219..219,
-                insert: "method()$0",
-                kind: Method,
-                lookup: "method",
-                detail: "fn method(&self)",
-            },
-            CompletionItem {
-                label: "subfunc()",
-                source_range: 219..219,
-                delete: 219..219,
-                insert: "subfunc()$0",
-                kind: Function,
-                lookup: "subfunc",
-                detail: "fn subfunc()",
-            },
-            CompletionItem {
-                label: "submethod()",
-                source_range: 219..219,
-                delete: 219..219,
-                insert: "submethod()$0",
-                kind: Method,
-                lookup: "submethod",
-                detail: "fn submethod(&self)",
-            },
-        ]
-        "###
+fn foo<T: Sub>() { T::<|> }
+"#,
+            expect![[r#"
+                ct C2          const C2: ();
+                ct CONST       const CONST: u8;
+                ta SubTy       type SubTy;
+                ta Ty          type Ty;
+                fn func()      fn func()
+                me method()    fn method(&self)
+                fn subfunc()   fn subfunc()
+                me submethod() fn submethod(&self)
+            "#]],
         );
     }
 
     #[test]
     fn completes_self_param_assoc_ty() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Super {
-                    type Ty;
-                    const CONST: u8 = 0;
-                    fn func() {}
-                    fn method(&self) {}
-                }
+        check(
+            r#"
+trait Super {
+    type Ty;
+    const CONST: u8 = 0;
+    fn func() {}
+    fn method(&self) {}
+}
 
-                trait Sub: Super {
-                    type SubTy;
-                    const C2: () = ();
-                    fn subfunc() {}
-                    fn submethod(&self) {}
-                }
+trait Sub: Super {
+    type SubTy;
+    const C2: () = ();
+    fn subfunc() {}
+    fn submethod(&self) {}
+}
 
-                struct Wrap<T>(T);
-                impl<T> Super for Wrap<T> {}
-                impl<T> Sub for Wrap<T> {
-                    fn subfunc() {
-                        // Should be able to assume `Self: Sub + Super`
-                        Self::<|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "C2",
-                source_range: 365..365,
-                delete: 365..365,
-                insert: "C2",
-                kind: Const,
-                detail: "const C2: () = ();",
-            },
-            CompletionItem {
-                label: "CONST",
-                source_range: 365..365,
-                delete: 365..365,
-                insert: "CONST",
-                kind: Const,
-                detail: "const CONST: u8 = 0;",
-            },
-            CompletionItem {
-                label: "SubTy",
-                source_range: 365..365,
-                delete: 365..365,
-                insert: "SubTy",
-                kind: TypeAlias,
-                detail: "type SubTy;",
-            },
-            CompletionItem {
-                label: "Ty",
-                source_range: 365..365,
-                delete: 365..365,
-                insert: "Ty",
-                kind: TypeAlias,
-                detail: "type Ty;",
-            },
-            CompletionItem {
-                label: "func()",
-                source_range: 365..365,
-                delete: 365..365,
-                insert: "func()$0",
-                kind: Function,
-                lookup: "func",
-                detail: "fn func()",
-            },
-            CompletionItem {
-                label: "method()",
-                source_range: 365..365,
-                delete: 365..365,
-                insert: "method()$0",
-                kind: Method,
-                lookup: "method",
-                detail: "fn method(&self)",
-            },
-            CompletionItem {
-                label: "subfunc()",
-                source_range: 365..365,
-                delete: 365..365,
-                insert: "subfunc()$0",
-                kind: Function,
-                lookup: "subfunc",
-                detail: "fn subfunc()",
-            },
-            CompletionItem {
-                label: "submethod()",
-                source_range: 365..365,
-                delete: 365..365,
-                insert: "submethod()$0",
-                kind: Method,
-                lookup: "submethod",
-                detail: "fn submethod(&self)",
-            },
-        ]
-        "###
+struct Wrap<T>(T);
+impl<T> Super for Wrap<T> {}
+impl<T> Sub for Wrap<T> {
+    fn subfunc() {
+        // Should be able to assume `Self: Sub + Super`
+        Self::<|>
+    }
+}
+"#,
+            expect![[r#"
+                ct C2          const C2: () = ();
+                ct CONST       const CONST: u8 = 0;
+                ta SubTy       type SubTy;
+                ta Ty          type Ty;
+                fn func()      fn func()
+                me method()    fn method(&self)
+                fn subfunc()   fn subfunc()
+                me submethod() fn submethod(&self)
+            "#]],
         );
     }
 
     #[test]
     fn completes_type_alias() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                struct S;
-                impl S { fn foo() {} }
-                type T = S;
-                impl T { fn bar() {} }
-
-                fn main() {
-                    T::<|>;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "bar()",
-                source_range: 185..185,
-                delete: 185..185,
-                insert: "bar()$0",
-                kind: Function,
-                lookup: "bar",
-                detail: "fn bar()",
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 185..185,
-                delete: 185..185,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct S;
+impl S { fn foo() {} }
+type T = S;
+impl T { fn bar() {} }
+
+fn main() { T::<|>; }
+"#,
+            expect![[r#"
+                fn bar() fn bar()
+                fn foo() fn foo()
+            "#]],
         );
     }
 
     #[test]
     fn completes_qualified_macros() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                #[macro_export]
-                macro_rules! foo {
-                    () => {}
-                }
+        check(
+            r#"
+#[macro_export]
+macro_rules! foo { () => {} }
+
+fn main() { let _ = crate::<|> }
+        "#,
+            expect![[r##"
+                ma foo!(…) #[macro_export]
+                macro_rules! foo
+                fn main()  fn main()
+            "##]],
+        );
+    }
 
-                fn main() {
-                    let _ = crate::<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 179..179,
-                delete: 179..179,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "#[macro_export]\nmacro_rules! foo",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 179..179,
-                delete: 179..179,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+    #[test]
+    fn test_super_super_completion() {
+        check(
+            r#"
+mod a {
+    const A: usize = 0;
+    mod b {
+        const B: usize = 0;
+        mod c { use super::super::<|> }
+    }
+}
+"#,
+            expect![[r#"
+                ct A
+                md b
+            "#]],
         );
     }
 
     #[test]
     fn completes_reexported_items_under_correct_name() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn foo() {
-                    self::m::<|>
-                }
+        check(
+            r#"
+fn foo() { self::m::<|> }
 
-                mod m {
-                    pub use super::p::wrong_fn as right_fn;
-                    pub use super::p::WRONG_CONST as RIGHT_CONST;
-                    pub use super::p::WrongType as RightType;
-                }
-                mod p {
-                    fn wrong_fn() {}
-                    const WRONG_CONST: u32 = 1;
-                    struct WrongType {};
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "RIGHT_CONST",
-                source_range: 57..57,
-                delete: 57..57,
-                insert: "RIGHT_CONST",
-                kind: Const,
-            },
-            CompletionItem {
-                label: "RightType",
-                source_range: 57..57,
-                delete: 57..57,
-                insert: "RightType",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "right_fn()",
-                source_range: 57..57,
-                delete: 57..57,
-                insert: "right_fn()$0",
-                kind: Function,
-                lookup: "right_fn",
-                detail: "fn wrong_fn()",
-            },
-        ]
-        "###
+mod m {
+    pub use super::p::wrong_fn as right_fn;
+    pub use super::p::WRONG_CONST as RIGHT_CONST;
+    pub use super::p::WrongType as RightType;
+}
+mod p {
+    fn wrong_fn() {}
+    const WRONG_CONST: u32 = 1;
+    struct WrongType {};
+}
+"#,
+            expect![[r#"
+                ct RIGHT_CONST
+                st RightType
+                fn right_fn()  fn wrong_fn()
+            "#]],
+        );
+
+        check_edit(
+            "RightType",
+            r#"
+fn foo() { self::m::<|> }
+
+mod m {
+    pub use super::p::wrong_fn as right_fn;
+    pub use super::p::WRONG_CONST as RIGHT_CONST;
+    pub use super::p::WrongType as RightType;
+}
+mod p {
+    fn wrong_fn() {}
+    const WRONG_CONST: u32 = 1;
+    struct WrongType {};
+}
+"#,
+            r#"
+fn foo() { self::m::RightType }
+
+mod m {
+    pub use super::p::wrong_fn as right_fn;
+    pub use super::p::WRONG_CONST as RIGHT_CONST;
+    pub use super::p::WrongType as RightType;
+}
+mod p {
+    fn wrong_fn() {}
+    const WRONG_CONST: u32 = 1;
+    struct WrongType {};
+}
+"#,
         );
     }
 
     #[test]
     fn completes_in_simple_macro_call() {
-        let completions = do_reference_completion(
+        check(
             r#"
-                macro_rules! m { ($e:expr) => { $e } }
-                fn main() { m!(self::f<|>); }
-                fn foo() {}
-            "#,
+macro_rules! m { ($e:expr) => { $e } }
+fn main() { m!(self::f<|>); }
+fn foo() {}
+"#,
+            expect![[r#"
+                fn foo()  fn foo()
+                fn main() fn main()
+            "#]],
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "foo()",
-                source_range: 93..94,
-                delete: 93..94,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 93..94,
-                delete: 93..94,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn function_mod_share_name() {
-        assert_debug_snapshot!(
-        do_reference_completion(
-                r"
-                fn foo() {
-                    self::m::<|>
-                }
+        check(
+            r#"
+fn foo() { self::m::<|> }
 
-                mod m {
-                    pub mod z {}
-                    pub fn z() {}
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "z",
-                source_range: 57..57,
-                delete: 57..57,
-                insert: "z",
-                kind: Module,
-            },
-            CompletionItem {
-                label: "z()",
-                source_range: 57..57,
-                delete: 57..57,
-                insert: "z()$0",
-                kind: Function,
-                lookup: "z",
-                detail: "pub fn z()",
-            },
-        ]
-        "###
+mod m {
+    pub mod z {}
+    pub fn z() {}
+}
+"#,
+            expect![[r#"
+                md z
+                fn z() pub fn z()
+            "#]],
         );
     }
 
     #[test]
     fn completes_hashmap_new() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct RandomState;
-                struct HashMap<K, V, S = RandomState> {}
-
-                impl<K, V> HashMap<K, V, RandomState> {
-                    pub fn new() -> HashMap<K, V, RandomState> { }
-                }
-                fn foo() {
-                    HashMap::<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "new()",
-                source_range: 292..292,
-                delete: 292..292,
-                insert: "new()$0",
-                kind: Function,
-                lookup: "new",
-                detail: "pub fn new() -> HashMap<K, V, RandomState>",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct RandomState;
+struct HashMap<K, V, S = RandomState> {}
+
+impl<K, V> HashMap<K, V, RandomState> {
+    pub fn new() -> HashMap<K, V, RandomState> { }
+}
+fn foo() {
+    HashMap::<|>
+}
+"#,
+            expect![[r#"
+                fn new() pub fn new() -> HashMap<K, V, RandomState>
+            "#]],
         );
     }
 
     #[test]
     fn dont_complete_attr() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                mod foo { pub struct Foo; }
-                #[foo::<|>]
-                fn f() {}
-                "
-            ),
-            @r###"[]"###
-        )
+        check(
+            r#"
+mod foo { pub struct Foo; }
+#[foo::<|>]
+fn f() {}
+"#,
+            expect![[""]],
+        );
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_record.rs b/crates/ra_ide/src/completion/complete_record.rs
index b7ab654c5..74b94594d 100644
--- a/crates/ra_ide/src/completion/complete_record.rs
+++ b/crates/ra_ide/src/completion/complete_record.rs
@@ -18,389 +18,209 @@ pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
 
 #[cfg(test)]
 mod tests {
-    mod record_pat_tests {
-        use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::completion_list, CompletionKind};
 
-        fn complete(code: &str) -> Vec<CompletionItem> {
-            do_completion(code, CompletionKind::Reference)
-        }
-
-        #[test]
-        fn test_record_pattern_field() {
-            let completions = complete(
-                r"
-            struct S { foo: u32 }
-
-            fn process(f: S) {
-                match f {
-                    S { f<|>: 92 } => (),
-                }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "foo",
-                source_range: 117..118,
-                delete: 117..118,
-                insert: "foo",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
-
-        #[test]
-        fn test_record_pattern_enum_variant() {
-            let completions = complete(
-                r"
-            enum E {
-                S { foo: u32, bar: () }
-            }
-
-            fn process(e: E) {
-                match e {
-                    E::S { <|> } => (),
-                }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: 161..161,
-                delete: 161..161,
-                insert: "bar",
-                kind: Field,
-                detail: "()",
-            },
-            CompletionItem {
-                label: "foo",
-                source_range: 161..161,
-                delete: 161..161,
-                insert: "foo",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual);
+    }
 
-        #[test]
-        fn test_record_pattern_field_in_simple_macro() {
-            let completions = complete(
-                r"
-            macro_rules! m { ($e:expr) => { $e } }
-            struct S { foo: u32 }
+    #[test]
+    fn test_record_pattern_field() {
+        check(
+            r#"
+struct S { foo: u32 }
 
-            fn process(f: S) {
-                m!(match f {
-                    S { f<|>: 92 } => (),
-                })
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "foo",
-                source_range: 171..172,
-                delete: 171..172,
-                insert: "foo",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+fn process(f: S) {
+    match f {
+        S { f<|>: 92 } => (),
+    }
+}
+"#,
+            expect![[r#"
+                fd foo u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn only_missing_fields_are_completed_in_destruct_pats() {
-            let completions = complete(
-                r"
-            struct S {
-                foo1: u32,
-                foo2: u32,
-                bar: u32,
-                baz: u32,
-            }
+    #[test]
+    fn test_record_pattern_enum_variant() {
+        check(
+            r#"
+enum E { S { foo: u32, bar: () } }
 
-            fn main() {
-                let s = S {
-                    foo1: 1,
-                    foo2: 2,
-                    bar: 3,
-                    baz: 4,
-                };
-                if let S { foo1, foo2: a, <|> } = s {}
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: 372..372,
-                delete: 372..372,
-                insert: "bar",
-                kind: Field,
-                detail: "u32",
-            },
-            CompletionItem {
-                label: "baz",
-                source_range: 372..372,
-                delete: 372..372,
-                insert: "baz",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+fn process(e: E) {
+    match e {
+        E::S { <|> } => (),
+    }
+}
+"#,
+            expect![[r#"
+                fd bar ()
+                fd foo u32
+            "#]],
+        );
     }
 
-    mod record_lit_tests {
-        use insta::assert_debug_snapshot;
-
-        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    #[test]
+    fn test_record_pattern_field_in_simple_macro() {
+        check(
+            r"
+macro_rules! m { ($e:expr) => { $e } }
+struct S { foo: u32 }
+
+fn process(f: S) {
+    m!(match f {
+        S { f<|>: 92 } => (),
+    })
+}
+",
+            expect![[r#"
+                fd foo u32
+            "#]],
+        );
+    }
 
-        fn complete(code: &str) -> Vec<CompletionItem> {
-            do_completion(code, CompletionKind::Reference)
-        }
+    #[test]
+    fn only_missing_fields_are_completed_in_destruct_pats() {
+        check(
+            r#"
+struct S {
+    foo1: u32, foo2: u32,
+    bar: u32, baz: u32,
+}
 
-        #[test]
-        fn test_record_literal_deprecated_field() {
-            let completions = complete(
-                r"
-            struct A {
-                #[deprecated]
-                the_field: u32,
-            }
-            fn foo() {
-               A { the<|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 142..145,
-                delete: 142..145,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-                deprecated: true,
-            },
-        ]
-        "###);
-        }
+fn main() {
+    let s = S {
+        foo1: 1, foo2: 2,
+        bar: 3, baz: 4,
+    };
+    if let S { foo1, foo2: a, <|> } = s {}
+}
+"#,
+            expect![[r#"
+                fd bar u32
+                fd baz u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_field() {
-            let completions = complete(
-                r"
-            struct A { the_field: u32 }
-            fn foo() {
-               A { the<|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 83..86,
-                delete: 83..86,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+    #[test]
+    fn test_record_literal_field() {
+        check(
+            r#"
+struct A { the_field: u32 }
+fn foo() {
+   A { the<|> }
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_enum_variant() {
-            let completions = complete(
-                r"
-            enum E {
-                A { a: u32 }
-            }
-            fn foo() {
-                let _ = E::A { <|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "a",
-                source_range: 119..119,
-                delete: 119..119,
-                insert: "a",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+    #[test]
+    fn test_record_literal_enum_variant() {
+        check(
+            r#"
+enum E { A { a: u32 } }
+fn foo() {
+    let _ = E::A { <|> }
+}
+"#,
+            expect![[r#"
+                fd a u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_two_structs() {
-            let completions = complete(
-                r"
-            struct A { a: u32 }
-            struct B { b: u32 }
+    #[test]
+    fn test_record_literal_two_structs() {
+        check(
+            r#"
+struct A { a: u32 }
+struct B { b: u32 }
 
-            fn foo() {
-               let _: A = B { <|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "b",
-                source_range: 119..119,
-                delete: 119..119,
-                insert: "b",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+fn foo() {
+   let _: A = B { <|> }
+}
+"#,
+            expect![[r#"
+                fd b u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_generic_struct() {
-            let completions = complete(
-                r"
-            struct A<T> { a: T }
+    #[test]
+    fn test_record_literal_generic_struct() {
+        check(
+            r#"
+struct A<T> { a: T }
 
-            fn foo() {
-               let _: A<u32> = A { <|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "a",
-                source_range: 93..93,
-                delete: 93..93,
-                insert: "a",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+fn foo() {
+   let _: A<u32> = A { <|> }
+}
+"#,
+            expect![[r#"
+                fd a u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_field_in_simple_macro() {
-            let completions = complete(
-                r"
-            macro_rules! m { ($e:expr) => { $e } }
-            struct A { the_field: u32 }
-            fn foo() {
-               m!(A { the<|> })
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 137..140,
-                delete: 137..140,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+    #[test]
+    fn test_record_literal_field_in_simple_macro() {
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+struct A { the_field: u32 }
+fn foo() {
+   m!(A { the<|> })
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn only_missing_fields_are_completed() {
-            let completions = complete(
-                r"
-            struct S {
-                foo1: u32,
-                foo2: u32,
-                bar: u32,
-                baz: u32,
-            }
+    #[test]
+    fn only_missing_fields_are_completed() {
+        check(
+            r#"
+struct S {
+    foo1: u32, foo2: u32,
+    bar: u32, baz: u32,
+}
 
-            fn main() {
-                let foo1 = 1;
-                let s = S {
-                    foo1,
-                    foo2: 5,
-                    <|>
-                }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: 302..302,
-                delete: 302..302,
-                insert: "bar",
-                kind: Field,
-                detail: "u32",
-            },
-            CompletionItem {
-                label: "baz",
-                source_range: 302..302,
-                delete: 302..302,
-                insert: "baz",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+fn main() {
+    let foo1 = 1;
+    let s = S { foo1, foo2: 5, <|> }
+}
+"#,
+            expect![[r#"
+                fd bar u32
+                fd baz u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn completes_functional_update() {
-            let completions = complete(
-                r"
-            struct S {
-                foo1: u32,
-                foo2: u32,
-            }
+    #[test]
+    fn completes_functional_update() {
+        check(
+            r#"
+struct S { foo1: u32, foo2: u32 }
 
-            fn main() {
-                let foo1 = 1;
-                let s = S {
-                    foo1,
-                    <|>
-                    .. loop {}
-                }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "foo2",
-                source_range: 221..221,
-                delete: 221..221,
-                insert: "foo2",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-        }
+fn main() {
+    let foo1 = 1;
+    let s = S { foo1, <|> .. loop {} }
+}
+"#,
+            expect![[r#"
+                fd foo2 u32
+            "#]],
+        );
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_snippet.rs b/crates/ra_ide/src/completion/complete_snippet.rs
index 0568d9ccf..28d8f7876 100644
--- a/crates/ra_ide/src/completion/complete_snippet.rs
+++ b/crates/ra_ide/src/completion/complete_snippet.rs
@@ -70,95 +70,47 @@ fn ${1:feature}() {
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    fn do_snippet_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Snippet)
+    use crate::completion::{test_utils::completion_list, CompletionKind};
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Snippet);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn completes_snippets_in_expressions() {
-        assert_debug_snapshot!(
-                    do_snippet_completion(r"fn foo(x: i32) { <|> }"),
-        @r###"
-        [
-            CompletionItem {
-                label: "pd",
-                source_range: 17..17,
-                delete: 17..17,
-                insert: "eprintln!(\"$0 = {:?}\", $0);",
-                kind: Snippet,
-            },
-            CompletionItem {
-                label: "ppd",
-                source_range: 17..17,
-                delete: 17..17,
-                insert: "eprintln!(\"$0 = {:#?}\", $0);",
-                kind: Snippet,
-            },
-        ]
-        "###
-                );
+        check(
+            r#"fn foo(x: i32) { <|> }"#,
+            expect![[r#"
+                sn pd
+                sn ppd
+            "#]],
+        );
     }
 
     #[test]
     fn should_not_complete_snippets_in_path() {
-        assert_debug_snapshot!(
-                    do_snippet_completion(r"fn foo(x: i32) { ::foo<|> }"),
-        @"[]"
-                );
-        assert_debug_snapshot!(
-                    do_snippet_completion(r"fn foo(x: i32) { ::<|> }"),
-        @"[]"
-                );
+        check(r#"fn foo(x: i32) { ::foo<|> }"#, expect![[""]]);
+        check(r#"fn foo(x: i32) { ::<|> }"#, expect![[""]]);
     }
 
     #[test]
     fn completes_snippets_in_items() {
-        assert_debug_snapshot!(
-            do_snippet_completion(
-                r"
-                #[cfg(test)]
-                mod tests {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Test function",
-                source_range: 78..78,
-                delete: 78..78,
-                insert: "#[test]\nfn ${1:feature}() {\n    $0\n}",
-                kind: Snippet,
-                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,
-                insert: "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}",
-                kind: Snippet,
-            },
-            CompletionItem {
-                label: "pub(crate)",
-                source_range: 78..78,
-                delete: 78..78,
-                insert: "pub(crate) $0",
-                kind: Snippet,
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+#[cfg(test)]
+mod tests {
+    <|>
+}
+"#,
+            expect![[r#"
+                sn Test function
+                sn Test module
+                sn macro_rules
+                sn pub(crate)
+            "#]],
+        )
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index 21c9316e6..a610fd6d1 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -227,330 +227,264 @@ fn make_const_compl_syntax(const_: &ast::ConstDef) -> String {
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
 
-    fn complete(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Magic)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Magic);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn name_ref_function_type_const() {
-        let completions = complete(
-            r"
-            trait Test {
-                type TestType;
-                const TEST_CONST: u16;
-                fn test();
-            }
-
-            struct T1;
+        check(
+            r#"
+trait Test {
+    type TestType;
+    const TEST_CONST: u16;
+    fn test();
+}
+struct T;
 
-            impl Test for T1 {
-                t<|>
-            }
-            ",
+impl Test for T {
+    t<|>
+}
+"#,
+            expect![["
+ct const TEST_CONST: u16 = \n\
+fn fn test()
+ta type TestType = \n\
+            "]],
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "const TEST_CONST: u16 = ",
-                source_range: 209..210,
-                delete: 209..210,
-                insert: "const TEST_CONST: u16 = ",
-                kind: Const,
-                lookup: "TEST_CONST",
-            },
-            CompletionItem {
-                label: "fn test()",
-                source_range: 209..210,
-                delete: 209..210,
-                insert: "fn test() {\n    $0\n}",
-                kind: Function,
-                lookup: "test",
-            },
-            CompletionItem {
-                label: "type TestType = ",
-                source_range: 209..210,
-                delete: 209..210,
-                insert: "type TestType = ",
-                kind: TypeAlias,
-                lookup: "TestType",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn no_nested_fn_completions() {
-        let completions = complete(
+        check(
             r"
-            trait Test {
-                fn test();
-                fn test2();
-            }
-
-            struct T1;
+trait Test {
+    fn test();
+    fn test2();
+}
+struct T;
 
-            impl Test for T1 {
-                fn test() {
-                    t<|>
-                }
-            }
-            ",
+impl Test for T {
+    fn test() {
+        t<|>
+    }
+}
+",
+            expect![[""]],
         );
-        assert_debug_snapshot!(completions, @r###"[]"###);
     }
 
     #[test]
     fn name_ref_single_function() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn test();
-            }
+        check_edit(
+            "test",
+            r#"
+trait Test {
+    fn test();
+}
+struct T;
 
-            struct T1;
+impl Test for T {
+    t<|>
+}
+"#,
+            r#"
+trait Test {
+    fn test();
+}
+struct T;
 
-            impl Test for T1 {
-                t<|>
-            }
-            ",
+impl Test for T {
+    fn test() {
+    $0
+}
+}
+"#,
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn test()",
-                source_range: 139..140,
-                delete: 139..140,
-                insert: "fn test() {\n    $0\n}",
-                kind: Function,
-                lookup: "test",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn single_function() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo();
-            }
+        check_edit(
+            "test",
+            r#"
+trait Test {
+    fn test();
+}
+struct T;
 
-            struct T1;
+impl Test for T {
+    fn t<|>
+}
+"#,
+            r#"
+trait Test {
+    fn test();
+}
+struct T;
 
-            impl Test for T1 {
-                fn f<|>
-            }
-            ",
+impl Test for T {
+    fn test() {
+    $0
+}
+}
+"#,
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn foo()",
-                source_range: 141..142,
-                delete: 138..142,
-                insert: "fn foo() {\n    $0\n}",
-                kind: Function,
-                lookup: "foo",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn hide_implemented_fn() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo();
-                fn foo_bar();
-            }
-
-            struct T1;
-
-            impl Test for T1 {
-                fn foo() {}
-
-                fn f<|>
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn foo_bar()",
-                source_range: 200..201,
-                delete: 197..201,
-                insert: "fn foo_bar() {\n    $0\n}",
-                kind: Function,
-                lookup: "foo_bar",
-            },
-        ]
-        "###);
-    }
-
-    #[test]
-    fn completes_only_on_top_level() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo();
-
-                fn foo_bar();
-            }
-
-            struct T1;
+        check(
+            r#"
+trait Test {
+    fn foo();
+    fn foo_bar();
+}
+struct T;
 
-            impl Test for T1 {
-                fn foo() {
-                    <|>
-                }
-            }
-            ",
+impl Test for T {
+    fn foo() {}
+    fn f<|>
+}
+"#,
+            expect![[r#"
+                fn fn foo_bar()
+            "#]],
         );
-        assert_debug_snapshot!(completions, @r###"[]"###);
     }
 
     #[test]
     fn generic_fn() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo<T>();
-            }
+        check_edit(
+            "foo",
+            r#"
+trait Test {
+    fn foo<T>();
+}
+struct T;
 
-            struct T1;
+impl Test for T {
+    fn f<|>
+}
+"#,
+            r#"
+trait Test {
+    fn foo<T>();
+}
+struct T;
 
-            impl Test for T1 {
-                fn f<|>
-            }
-            ",
+impl Test for T {
+    fn foo<T>() {
+    $0
+}
+}
+"#,
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn foo()",
-                source_range: 144..145,
-                delete: 141..145,
-                insert: "fn foo<T>() {\n    $0\n}",
-                kind: Function,
-                lookup: "foo",
-            },
-        ]
-        "###);
-    }
-
-    #[test]
-    fn generic_constrait_fn() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo<T>() where T: Into<String>;
-            }
+        check_edit(
+            "foo",
+            r#"
+trait Test {
+    fn foo<T>() where T: Into<String>;
+}
+struct T;
 
-            struct T1;
+impl Test for T {
+    fn f<|>
+}
+"#,
+            r#"
+trait Test {
+    fn foo<T>() where T: Into<String>;
+}
+struct T;
 
-            impl Test for T1 {
-                fn f<|>
-            }
-            ",
+impl Test for T {
+    fn foo<T>()
+where T: Into<String> {
+    $0
+}
+}
+"#,
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn foo()",
-                source_range: 166..167,
-                delete: 163..167,
-                insert: "fn foo<T>()\nwhere T: Into<String> {\n    $0\n}",
-                kind: Function,
-                lookup: "foo",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn associated_type() {
-        let completions = complete(
-            r"
-            trait Test {
-                type SomeType;
-            }
+        check_edit(
+            "SomeType",
+            r#"
+trait Test {
+    type SomeType;
+}
 
-            impl Test for () {
-                type S<|>
-            }
-            ",
+impl Test for () {
+    type S<|>
+}
+"#,
+            "
+trait Test {
+    type SomeType;
+}
+
+impl Test for () {
+    type SomeType = \n\
+}
+",
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "type SomeType = ",
-                source_range: 124..125,
-                delete: 119..125,
-                insert: "type SomeType = ",
-                kind: TypeAlias,
-                lookup: "SomeType",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn associated_const() {
-        let completions = complete(
-            r"
-            trait Test {
-                const SOME_CONST: u16;
-            }
+        check_edit(
+            "SOME_CONST",
+            r#"
+trait Test {
+    const SOME_CONST: u16;
+}
 
-            impl Test for () {
-                const S<|>
-            }
-            ",
+impl Test for () {
+    const S<|>
+}
+"#,
+            "
+trait Test {
+    const SOME_CONST: u16;
+}
+
+impl Test for () {
+    const SOME_CONST: u16 = \n\
+}
+",
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "const SOME_CONST: u16 = ",
-                source_range: 133..134,
-                delete: 127..134,
-                insert: "const SOME_CONST: u16 = ",
-                kind: Const,
-                lookup: "SOME_CONST",
-            },
-        ]
-        "###);
-    }
 
-    #[test]
-    fn associated_const_with_default() {
-        let completions = complete(
-            r"
-            trait Test {
-                const SOME_CONST: u16 = 42;
-            }
+        check_edit(
+            "SOME_CONST",
+            r#"
+trait Test {
+    const SOME_CONST: u16 = 92;
+}
 
-            impl Test for () {
-                const S<|>
-            }
-            ",
+impl Test for () {
+    const S<|>
+}
+"#,
+            "
+trait Test {
+    const SOME_CONST: u16 = 92;
+}
+
+impl Test for () {
+    const SOME_CONST: u16 = \n\
+}
+",
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "const SOME_CONST: u16 = ",
-                source_range: 138..139,
-                delete: 132..139,
-                insert: "const SOME_CONST: u16 = ",
-                kind: Const,
-                lookup: "SOME_CONST",
-            },
-        ]
-        "###);
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
index 68032c37e..bd9551f35 100644
--- a/crates/ra_ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -1,11 +1,10 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 
-use hir::ScopeDef;
+use hir::{Adt, ModuleDef, ScopeDef, Type};
+use ra_syntax::AstNode;
 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) {
@@ -26,7 +25,7 @@ pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         return;
     }
 
-    ctx.scope().process_all_names(&mut |name, res| {
+    ctx.scope.process_all_names(&mut |name, res| {
         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() {
@@ -43,7 +42,7 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
     if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
         let variants = enum_data.variants(ctx.db);
 
-        let module = if let Some(module) = ctx.scope().module() {
+        let module = if let Some(module) = ctx.scope.module() {
             // Compute path from the completion site if available.
             module
         } else {
@@ -65,1361 +64,595 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
     use test_utils::mark;
 
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
 
-    fn do_reference_completion(ra_fixture: &str) -> Vec<CompletionItem> {
-        do_completion(ra_fixture, CompletionKind::Reference)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn self_fulfilling_completion() {
         mark::check!(self_fulfilling_completion);
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r#"
-                use foo<|>
-                use std::collections;
-                "#,
-            ),
-            @r###"
-            [
-                CompletionItem {
-                    label: "collections",
-                    source_range: 21..24,
-                    delete: 21..24,
-                    insert: "collections",
-                },
-            ]
-            "###
+        check(
+            r#"
+use foo<|>
+use std::collections;
+"#,
+            expect![[r#"
+                ?? collections
+            "#]],
         );
     }
 
     #[test]
     fn bind_pat_and_path_ignore_at() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Enum {
-                    A,
-                    B,
-                }
-                fn quux(x: Option<Enum>) {
-                    match x {
-                        None => (),
-                        Some(en<|> @ Enum::A) => (),
-                    }
-                }
-                "
-            ),
-            @"[]"
+        check(
+            r#"
+enum Enum { A, B }
+fn quux(x: Option<Enum>) {
+    match x {
+        None => (),
+        Some(en<|> @ Enum::A) => (),
+    }
+}
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
     fn bind_pat_and_path_ignore_ref() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Enum {
-                    A,
-                    B,
-                }
-                fn quux(x: Option<Enum>) {
-                    match x {
-                        None => (),
-                        Some(ref en<|>) => (),
-                    }
-                }
-                "
-            ),
-            @r###"[]"###
+        check(
+            r#"
+enum Enum { A, B }
+fn quux(x: Option<Enum>) {
+    match x {
+        None => (),
+        Some(ref en<|>) => (),
+    }
+}
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
     fn bind_pat_and_path() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Enum {
-                    A,
-                    B,
-                }
-                fn quux(x: Option<Enum>) {
-                    match x {
-                        None => (),
-                        Some(En<|>) => (),
-                    }
-                }
-                "
-            ),
-            @r###"
-            [
-                CompletionItem {
-                    label: "Enum",
-                    source_range: 231..233,
-                    delete: 231..233,
-                    insert: "Enum",
-                    kind: Enum,
-                },
-            ]
-            "###
+        check(
+            r#"
+enum Enum { A, B }
+fn quux(x: Option<Enum>) {
+    match x {
+        None => (),
+        Some(En<|>) => (),
+    }
+}
+"#,
+            expect![[r#"
+                en Enum
+            "#]],
         );
     }
 
     #[test]
     fn completes_bindings_from_let() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn quux(x: i32) {
-                    let y = 92;
-                    1 + <|>;
-                    let z = ();
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "quux(…)",
-                source_range: 91..91,
-                delete: 91..91,
-                insert: "quux(${1:x})$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux(x: i32)",
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "x",
-                source_range: 91..91,
-                delete: 91..91,
-                insert: "x",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "y",
-                source_range: 91..91,
-                delete: 91..91,
-                insert: "y",
-                kind: Binding,
-                detail: "i32",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn quux(x: i32) {
+    let y = 92;
+    1 + <|>;
+    let z = ();
+}
+"#,
+            expect![[r#"
+                fn quux(…) fn quux(x: i32)
+                bn x       i32
+                bn y       i32
+            "#]],
         );
     }
 
     #[test]
     fn completes_bindings_from_if_let() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn quux() {
-                    if let Some(x) = foo() {
-                        let y = 92;
-                    };
-                    if let Some(a) = bar() {
-                        let b = 62;
-                        1 + <|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "a",
-                source_range: 242..242,
-                delete: 242..242,
-                insert: "a",
-                kind: Binding,
-            },
-            CompletionItem {
-                label: "b",
-                source_range: 242..242,
-                delete: 242..242,
-                insert: "b",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "quux()",
-                source_range: 242..242,
-                delete: 242..242,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux()",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn quux() {
+    if let Some(x) = foo() {
+        let y = 92;
+    };
+    if let Some(a) = bar() {
+        let b = 62;
+        1 + <|>
+    }
+}
+"#,
+            expect![[r#"
+                bn a
+                bn b      i32
+                fn quux() fn quux()
+            "#]],
         );
     }
 
     #[test]
     fn completes_bindings_from_for() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn quux() {
-                    for x in &[1, 2, 3] {
-                        <|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "quux()",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux()",
-            },
-            CompletionItem {
-                label: "x",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "x",
-                kind: Binding,
-            },
-        ]
-        "###
+        check(
+            r#"
+fn quux() {
+    for x in &[1, 2, 3] { <|> }
+}
+"#,
+            expect![[r#"
+                fn quux() fn quux()
+                bn x
+            "#]],
         );
     }
 
     #[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()",
-            },
-        ]
-        "###
-        );
+    fn completes_if_prefix_is_keyword() {
+        mark::check!(completes_if_prefix_is_keyword);
+        check_edit(
+            "wherewolf",
+            r#"
+fn main() {
+    let wherewolf = 92;
+    drop(where<|>)
+}
+"#,
+            r#"
+fn main() {
+    let wherewolf = 92;
+    drop(wherewolf)
+}
+"#,
+        )
     }
 
     #[test]
     fn completes_generic_params() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn quux<T>() {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "T",
-                source_range: 52..52,
-                delete: 52..52,
-                insert: "T",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "quux()",
-                source_range: 52..52,
-                delete: 52..52,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux<T>()",
-            },
-        ]
-        "###
+        check(
+            r#"fn quux<T>() { <|> }"#,
+            expect![[r#"
+                tp T
+                fn quux() fn quux<T>()
+            "#]],
         );
     }
 
     #[test]
     fn completes_generic_params_in_struct() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct X<T> {
-                    x: <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Self",
-                source_range: 54..54,
-                delete: 54..54,
-                insert: "Self",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "T",
-                source_range: 54..54,
-                delete: 54..54,
-                insert: "T",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "X<…>",
-                source_range: 54..54,
-                delete: 54..54,
-                insert: "X<$0>",
-                kind: Struct,
-                lookup: "X",
-            },
-        ]
-        "###
+        check(
+            r#"struct S<T> { x: <|>}"#,
+            expect![[r#"
+                st S<…>
+                tp Self
+                tp T
+            "#]],
         );
     }
 
     #[test]
     fn completes_self_in_enum() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum X {
-                    Y(<|>)
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Self",
-                source_range: 48..48,
-                delete: 48..48,
-                insert: "Self",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "X",
-                source_range: 48..48,
-                delete: 48..48,
-                insert: "X",
-                kind: Enum,
-            },
-        ]
-        "###
+        check(
+            r#"enum X { Y(<|>) }"#,
+            expect![[r#"
+                tp Self
+                en X
+            "#]],
         );
     }
 
     #[test]
     fn completes_module_items() {
-        assert_debug_snapshot!(
-        do_reference_completion(
-            r"
-                struct Foo;
-                enum Baz {}
-                fn quux() {
-                    <|>
-                }
-                "
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "Baz",
-                source_range: 105..105,
-                delete: 105..105,
-                insert: "Baz",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "Foo",
-                source_range: 105..105,
-                delete: 105..105,
-                insert: "Foo",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "quux()",
-                source_range: 105..105,
-                delete: 105..105,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux()",
-            },
-        ]
-        "###
-            );
+        check(
+            r#"
+struct S;
+enum E {}
+fn quux() { <|> }
+"#,
+            expect![[r#"
+                en E
+                st S
+                fn quux() fn quux()
+            "#]],
+        );
     }
 
     #[test]
     fn completes_extern_prelude() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                //- /lib.rs
-                use <|>;
-
-                //- /other_crate/lib.rs
-                // nothing here
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "other_crate",
-                source_range: 4..4,
-                delete: 4..4,
-                insert: "other_crate",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /lib.rs
+use <|>;
+
+//- /other_crate/lib.rs
+// nothing here
+"#,
+            expect![[r#"
+                md other_crate
+            "#]],
         );
     }
 
     #[test]
     fn completes_module_items_in_nested_modules() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct Foo;
-                mod m {
-                    struct Bar;
-                    fn quux() { <|> }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Bar",
-                source_range: 117..117,
-                delete: 117..117,
-                insert: "Bar",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "quux()",
-                source_range: 117..117,
-                delete: 117..117,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux()",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct Foo;
+mod m {
+    struct Bar;
+    fn quux() { <|> }
+}
+"#,
+            expect![[r#"
+                st Bar
+                fn quux() fn quux()
+            "#]],
         );
     }
 
     #[test]
     fn completes_return_type() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct Foo;
-                fn x() -> <|>
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Foo",
-                source_range: 55..55,
-                delete: 55..55,
-                insert: "Foo",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "x()",
-                source_range: 55..55,
-                delete: 55..55,
-                insert: "x()$0",
-                kind: Function,
-                lookup: "x",
-                detail: "fn x()",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct Foo;
+fn x() -> <|>
+"#,
+            expect![[r#"
+                st Foo
+                fn x() fn x()
+            "#]],
         );
     }
 
     #[test]
     fn dont_show_both_completions_for_shadowing() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn foo() {
-                    let bar = 92;
-                    {
-                        let bar = 62;
-                        <|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: 146..146,
-                delete: 146..146,
-                insert: "bar",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 146..146,
-                delete: 146..146,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn foo() {
+    let bar = 92;
+    {
+        let bar = 62;
+        drop(<|>)
+    }
+}
+"#,
+            // FIXME: should be only one bar here
+            expect![[r#"
+                bn bar   i32
+                bn bar   i32
+                fn foo() fn foo()
+            "#]],
         );
     }
 
     #[test]
     fn completes_self_in_methods() {
-        assert_debug_snapshot!(
-            do_reference_completion(r"impl S { fn foo(&self) { <|> } }"),
-            @r###"
-        [
-            CompletionItem {
-                label: "Self",
-                source_range: 25..25,
-                delete: 25..25,
-                insert: "Self",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "self",
-                source_range: 25..25,
-                delete: 25..25,
-                insert: "self",
-                kind: Binding,
-                detail: "&{unknown}",
-            },
-        ]
-        "###
+        check(
+            r#"impl S { fn foo(&self) { <|> } }"#,
+            expect![[r#"
+                tp Self
+                bn self &{unknown}
+            "#]],
         );
     }
 
     #[test]
     fn completes_prelude() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                fn foo() { let x: <|> }
-
-                //- /std/lib.rs
-                #[prelude_import]
-                use prelude::*;
-
-                mod prelude {
-                    struct Option;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Option",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "Option",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-            CompletionItem {
-                label: "std",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "std",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /main.rs
+fn foo() { let x: <|> }
+
+//- /std/lib.rs
+#[prelude_import]
+use prelude::*;
+
+mod prelude { struct Option; }
+"#,
+            expect![[r#"
+                st Option
+                fn foo()  fn foo()
+                md std
+            "#]],
         );
     }
 
     #[test]
     fn completes_std_prelude_if_core_is_defined() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                fn foo() { let x: <|> }
-
-                //- /core/lib.rs
-                #[prelude_import]
-                use prelude::*;
-
-                mod prelude {
-                    struct Option;
-                }
-
-                //- /std/lib.rs
-                #[prelude_import]
-                use prelude::*;
-
-                mod prelude {
-                    struct String;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "String",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "String",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "core",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "core",
-                kind: Module,
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-            CompletionItem {
-                label: "std",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "std",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /main.rs
+fn foo() { let x: <|> }
+
+//- /core/lib.rs
+#[prelude_import]
+use prelude::*;
+
+mod prelude { struct Option; }
+
+//- /std/lib.rs
+#[prelude_import]
+use prelude::*;
+
+mod prelude { struct String; }
+"#,
+            expect![[r#"
+                st String
+                md core
+                fn foo()  fn foo()
+                md std
+            "#]],
         );
     }
 
     #[test]
     fn completes_macros_as_value() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
+        check(
+            r#"
+macro_rules! foo { () => {} }
 
-                #[macro_use]
-                mod m1 {
-                    macro_rules! bar {
-                        () => {}
-                    }
-                }
+#[macro_use]
+mod m1 {
+    macro_rules! bar { () => {} }
+}
 
-                mod m2 {
-                    macro_rules! nope {
-                        () => {}
-                    }
+mod m2 {
+    macro_rules! nope { () => {} }
 
-                    #[macro_export]
-                    macro_rules! baz {
-                        () => {}
-                    }
-                }
+    #[macro_export]
+    macro_rules! baz { () => {} }
+}
 
-                fn main() {
-                    let v = <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "bar!(…)",
-                source_range: 252..252,
-                delete: 252..252,
-                insert: "bar!($0)",
-                kind: Macro,
-                detail: "macro_rules! bar",
-            },
-            CompletionItem {
-                label: "baz!(…)",
-                source_range: 252..252,
-                delete: 252..252,
-                insert: "baz!($0)",
-                kind: Macro,
-                detail: "#[macro_export]\nmacro_rules! baz",
-            },
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 252..252,
-                delete: 252..252,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-            CompletionItem {
-                label: "m1",
-                source_range: 252..252,
-                delete: 252..252,
-                insert: "m1",
-                kind: Module,
-            },
-            CompletionItem {
-                label: "m2",
-                source_range: 252..252,
-                delete: 252..252,
-                insert: "m2",
-                kind: Module,
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 252..252,
-                delete: 252..252,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+fn main() { let v = <|> }
+"#,
+            expect![[r##"
+                ma bar!(…) macro_rules! bar
+                ma baz!(…) #[macro_export]
+                macro_rules! baz
+                ma foo!(…) macro_rules! foo
+                md m1
+                md m2
+                fn main()  fn main()
+            "##]],
         );
     }
 
     #[test]
     fn completes_both_macro_and_value() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn foo() {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! foo { () => {} }
+fn foo() { <|> }
+"#,
+            expect![[r#"
+                ma foo!(…) macro_rules! foo
+                fn foo()   fn foo()
+            "#]],
         );
     }
 
     #[test]
     fn completes_macros_as_type() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn main() {
-                    let x: <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 57..57,
-                delete: 57..57,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 57..57,
-                delete: 57..57,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! foo { () => {} }
+fn main() { let x: <|> }
+"#,
+            expect![[r#"
+                ma foo!(…) macro_rules! foo
+                fn main()  fn main()
+            "#]],
         );
     }
 
     #[test]
     fn completes_macros_as_stmt() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn main() {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 50..50,
-                delete: 50..50,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 50..50,
-                delete: 50..50,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! foo { () => {} }
+fn main() { <|> }
+"#,
+            expect![[r#"
+                ma foo!(…) macro_rules! foo
+                fn main()  fn main()
+            "#]],
         );
     }
 
     #[test]
     fn completes_local_item() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                fn main() {
-                    return f<|>;
-                    fn frobnicate() {}
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "frobnicate()",
-                source_range: 23..24,
-                delete: 23..24,
-                insert: "frobnicate()$0",
-                kind: Function,
-                lookup: "frobnicate",
-                detail: "fn frobnicate()",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 23..24,
-                delete: 23..24,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
-        )
+        check(
+            r#"
+fn main() {
+    return f<|>;
+    fn frobnicate() {}
+}
+"#,
+            expect![[r#"
+                fn frobnicate() fn frobnicate()
+                fn main()       fn main()
+            "#]],
+        );
     }
 
     #[test]
     fn completes_in_simple_macro_1() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                fn quux(x: i32) {
-                    let y = 92;
-                    m!(<|>);
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m!(…)",
-                source_range: 145..145,
-                delete: 145..145,
-                insert: "m!($0)",
-                kind: Macro,
-                detail: "macro_rules! m",
-            },
-            CompletionItem {
-                label: "quux(…)",
-                source_range: 145..145,
-                delete: 145..145,
-                insert: "quux(${1:x})$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux(x: i32)",
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "x",
-                source_range: 145..145,
-                delete: 145..145,
-                insert: "x",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "y",
-                source_range: 145..145,
-                delete: 145..145,
-                insert: "y",
-                kind: Binding,
-                detail: "i32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+fn quux(x: i32) {
+    let y = 92;
+    m!(<|>);
+}
+"#,
+            expect![[r#"
+                ma m!(…)   macro_rules! m
+                fn quux(…) fn quux(x: i32)
+                bn x       i32
+                bn y       i32
+            "#]],
         );
     }
 
     #[test]
     fn completes_in_simple_macro_2() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                fn quux(x: i32) {
-                    let y = 92;
-                    m!(x<|>);
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m!(…)",
-                source_range: 145..146,
-                delete: 145..146,
-                insert: "m!($0)",
-                kind: Macro,
-                detail: "macro_rules! m",
-            },
-            CompletionItem {
-                label: "quux(…)",
-                source_range: 145..146,
-                delete: 145..146,
-                insert: "quux(${1:x})$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux(x: i32)",
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "x",
-                source_range: 145..146,
-                delete: 145..146,
-                insert: "x",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "y",
-                source_range: 145..146,
-                delete: 145..146,
-                insert: "y",
-                kind: Binding,
-                detail: "i32",
-            },
-        ]
-        "###
+        check(
+            r"
+macro_rules! m { ($e:expr) => { $e } }
+fn quux(x: i32) {
+    let y = 92;
+    m!(x<|>);
+}
+",
+            expect![[r#"
+                ma m!(…)   macro_rules! m
+                fn quux(…) fn quux(x: i32)
+                bn x       i32
+                bn y       i32
+            "#]],
         );
     }
 
     #[test]
     fn completes_in_simple_macro_without_closing_parens() {
-        assert_debug_snapshot!(
-                    do_reference_completion(
-                        r"
-                macro_rules! m { ($e:expr) => { $e } }
-                fn quux(x: i32) {
-                    let y = 92;
-                    m!(x<|>
-                }
-                "
-                    ),
-                    @r###"
-        [
-            CompletionItem {
-                label: "m!(…)",
-                source_range: 145..146,
-                delete: 145..146,
-                insert: "m!($0)",
-                kind: Macro,
-                detail: "macro_rules! m",
-            },
-            CompletionItem {
-                label: "quux(…)",
-                source_range: 145..146,
-                delete: 145..146,
-                insert: "quux(${1:x})$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux(x: i32)",
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "x",
-                source_range: 145..146,
-                delete: 145..146,
-                insert: "x",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "y",
-                source_range: 145..146,
-                delete: 145..146,
-                insert: "y",
-                kind: Binding,
-                detail: "i32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+fn quux(x: i32) {
+    let y = 92;
+    m!(x<|>
+}
+"#,
+            expect![[r#"
+                ma m!(…)   macro_rules! m
+                fn quux(…) fn quux(x: i32)
+                bn x       i32
+                bn y       i32
+            "#]],
         );
     }
 
     #[test]
     fn completes_unresolved_uses() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                use spam::Quux;
-
-                fn main() {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Quux",
-                source_range: 82..82,
-                delete: 82..82,
-                insert: "Quux",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 82..82,
-                delete: 82..82,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+        check(
+            r#"
+use spam::Quux;
+
+fn main() { <|> }
+"#,
+            expect![[r#"
+                ?? Quux
+                fn main() fn main()
+            "#]],
         );
     }
     #[test]
     fn completes_enum_variant_matcharm() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Foo {
-                    Bar,
-                    Baz,
-                    Quux
-                }
-
-                fn main() {
-                    let foo = Foo::Quux;
+        check(
+            r#"
+enum Foo { Bar, Baz, Quux }
 
-                    match foo {
-                        Qu<|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Foo",
-                source_range: 248..250,
-                delete: 248..250,
-                insert: "Foo",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "Foo::Bar",
-                source_range: 248..250,
-                delete: 248..250,
-                insert: "Foo::Bar",
-                kind: EnumVariant,
-                lookup: "Bar",
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Foo::Baz",
-                source_range: 248..250,
-                delete: 248..250,
-                insert: "Foo::Baz",
-                kind: EnumVariant,
-                lookup: "Baz",
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Foo::Quux",
-                source_range: 248..250,
-                delete: 248..250,
-                insert: "Foo::Quux",
-                kind: EnumVariant,
-                lookup: "Quux",
-                detail: "()",
-            },
-        ]
-        "###
+fn main() {
+    let foo = Foo::Quux;
+    match foo { Qu<|> }
+}
+"#,
+            expect![[r#"
+                en Foo
+                ev Foo::Bar  ()
+                ev Foo::Baz  ()
+                ev Foo::Quux ()
+            "#]],
         )
     }
 
     #[test]
     fn completes_enum_variant_iflet() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Foo {
-                    Bar,
-                    Baz,
-                    Quux
-                }
+        check(
+            r#"
+enum Foo { Bar, Baz, Quux }
 
-                fn main() {
-                    let foo = Foo::Quux;
-
-                    if let Qu<|> = foo {
-
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Foo",
-                source_range: 219..221,
-                delete: 219..221,
-                insert: "Foo",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "Foo::Bar",
-                source_range: 219..221,
-                delete: 219..221,
-                insert: "Foo::Bar",
-                kind: EnumVariant,
-                lookup: "Bar",
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Foo::Baz",
-                source_range: 219..221,
-                delete: 219..221,
-                insert: "Foo::Baz",
-                kind: EnumVariant,
-                lookup: "Baz",
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Foo::Quux",
-                source_range: 219..221,
-                delete: 219..221,
-                insert: "Foo::Quux",
-                kind: EnumVariant,
-                lookup: "Quux",
-                detail: "()",
-            },
-        ]
-        "###
+fn main() {
+    let foo = Foo::Quux;
+    if let Qu<|> = foo { }
+}
+"#,
+            expect![[r#"
+                en Foo
+                ev Foo::Bar  ()
+                ev Foo::Baz  ()
+                ev Foo::Quux ()
+            "#]],
         )
     }
 
     #[test]
     fn completes_enum_variant_basic_expr() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Foo {
-                    Bar,
-                    Baz,
-                    Quux
-                }
-
-                fn main() {
-                    let foo: Foo = Q<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Foo",
-                source_range: 185..186,
-                delete: 185..186,
-                insert: "Foo",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "Foo::Bar",
-                source_range: 185..186,
-                delete: 185..186,
-                insert: "Foo::Bar",
-                kind: EnumVariant,
-                lookup: "Bar",
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Foo::Baz",
-                source_range: 185..186,
-                delete: 185..186,
-                insert: "Foo::Baz",
-                kind: EnumVariant,
-                lookup: "Baz",
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Foo::Quux",
-                source_range: 185..186,
-                delete: 185..186,
-                insert: "Foo::Quux",
-                kind: EnumVariant,
-                lookup: "Quux",
-                detail: "()",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 185..186,
-                delete: 185..186,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+        check(
+            r#"
+enum Foo { Bar, Baz, Quux }
+fn main() { let foo: Foo = Q<|> }
+"#,
+            expect![[r#"
+                en Foo
+                ev Foo::Bar  ()
+                ev Foo::Baz  ()
+                ev Foo::Quux ()
+                fn main()    fn main()
+            "#]],
         )
     }
 
     #[test]
     fn completes_enum_variant_from_module() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                mod m { pub enum E { V } }
-
-                fn f() -> m::E {
-                    V<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "f()",
-                source_range: 98..99,
-                delete: 98..99,
-                insert: "f()$0",
-                kind: Function,
-                lookup: "f",
-                detail: "fn f() -> m::E",
-            },
-            CompletionItem {
-                label: "m",
-                source_range: 98..99,
-                delete: 98..99,
-                insert: "m",
-                kind: Module,
-            },
-            CompletionItem {
-                label: "m::E::V",
-                source_range: 98..99,
-                delete: 98..99,
-                insert: "m::E::V",
-                kind: EnumVariant,
-                lookup: "V",
-                detail: "()",
-            },
-        ]
-        "###
+        check(
+            r#"
+mod m { pub enum E { V } }
+fn f() -> m::E { V<|> }
+"#,
+            expect![[r#"
+                fn f()     fn f() -> m::E
+                md m
+                ev m::E::V ()
+            "#]],
         )
     }
 
     #[test]
     fn dont_complete_attr() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct Foo;
-                #[<|>]
-                fn f() {}
-                "
-            ),
-            @r###"[]"###
+        check(
+            r#"
+struct Foo;
+#[<|>]
+fn f() {}
+"#,
+            expect![[""]],
+        )
+    }
+
+    #[test]
+    fn completes_type_or_trait_in_impl_block() {
+        check(
+            r#"
+trait MyTrait {}
+struct MyStruct {}
+
+impl My<|>
+"#,
+            expect![[r#"
+                st MyStruct
+                tt MyTrait
+                tp Self
+            "#]],
         )
     }
 }
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index c4646b727..9e82d6854 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -5,12 +5,17 @@ use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::{find_covering_element, find_node_at_offset},
-    ast, match_ast, AstNode,
+    ast, match_ast, AstNode, NodeOrToken,
     SyntaxKind::*,
     SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
 use ra_text_edit::Indel;
 
+use super::patterns::{
+    has_bind_pat_parent, has_block_expr_parent, has_impl_as_prev_sibling, has_impl_parent,
+    has_item_list_or_source_file_parent, has_ref_parent, has_trait_as_prev_sibling,
+    has_trait_parent, if_is_prev, is_in_loop_body, is_match_arm, unsafe_is_prev,
+};
 use crate::{call_info::ActiveParameter, completion::CompletionConfig, FilePosition};
 use test_utils::mark;
 
@@ -19,6 +24,7 @@ use test_utils::mark;
 #[derive(Debug)]
 pub(crate) struct CompletionContext<'a> {
     pub(super) sema: Semantics<'a, RootDatabase>,
+    pub(super) scope: SemanticsScope<'a>,
     pub(super) db: &'a RootDatabase,
     pub(super) config: &'a CompletionConfig,
     pub(super) offset: TextSize,
@@ -48,6 +54,8 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) after_if: bool,
     /// `true` if we are a statement or a last expr in the block.
     pub(super) can_be_stmt: bool,
+    /// `true` if we expect an expression at the cursor position.
+    pub(super) is_expr: bool,
     /// Something is typed at the "top" level, in module or impl/trait.
     pub(super) is_new_item: bool,
     /// The receiver if this is a field or method access, i.e. writing something.<|>
@@ -55,11 +63,25 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) dot_receiver_is_ambiguous_float_literal: bool,
     /// If this is a call (method or function) in particular, i.e. the () are already there.
     pub(super) is_call: bool,
+    /// Like `is_call`, but for tuple patterns.
+    pub(super) is_pattern_call: bool,
     /// If this is a macro call, i.e. the () are already there.
     pub(super) is_macro_call: bool,
     pub(super) is_path_type: bool,
     pub(super) has_type_args: bool,
     pub(super) attribute_under_caret: Option<ast::Attr>,
+    pub(super) unsafe_is_prev: bool,
+    pub(super) if_is_prev: bool,
+    pub(super) block_expr_parent: bool,
+    pub(super) bind_pat_parent: bool,
+    pub(super) ref_pat_parent: bool,
+    pub(super) in_loop_body: bool,
+    pub(super) has_trait_parent: bool,
+    pub(super) has_impl_parent: bool,
+    pub(super) trait_as_prev_sibling: bool,
+    pub(super) impl_as_prev_sibling: bool,
+    pub(super) is_match_arm: bool,
+    pub(super) has_item_list_or_source_file_parent: bool,
 }
 
 impl<'a> CompletionContext<'a> {
@@ -87,8 +109,10 @@ impl<'a> CompletionContext<'a> {
         let original_token =
             original_file.syntax().token_at_offset(position.offset).left_biased()?;
         let token = sema.descend_into_macros(original_token.clone());
+        let scope = sema.scope_at_offset(&token.parent(), position.offset);
         let mut ctx = CompletionContext {
             sema,
+            scope,
             db,
             config,
             original_token,
@@ -110,14 +134,28 @@ impl<'a> CompletionContext<'a> {
             path_prefix: None,
             after_if: false,
             can_be_stmt: false,
+            is_expr: false,
             is_new_item: false,
             dot_receiver: None,
             is_call: false,
+            is_pattern_call: false,
             is_macro_call: false,
             is_path_type: false,
             has_type_args: false,
             dot_receiver_is_ambiguous_float_literal: false,
             attribute_under_caret: None,
+            unsafe_is_prev: false,
+            in_loop_body: false,
+            ref_pat_parent: false,
+            bind_pat_parent: false,
+            block_expr_parent: false,
+            has_trait_parent: false,
+            has_impl_parent: false,
+            trait_as_prev_sibling: false,
+            impl_as_prev_sibling: false,
+            if_is_prev: false,
+            is_match_arm: false,
+            has_item_list_or_source_file_parent: false,
         };
 
         let mut original_file = original_file.syntax().clone();
@@ -159,7 +197,7 @@ impl<'a> CompletionContext<'a> {
                 break;
             }
         }
-
+        ctx.fill_keyword_patterns(&hypothetical_file, offset);
         ctx.fill(&original_file, hypothetical_file, offset);
         Some(ctx)
     }
@@ -167,25 +205,30 @@ impl<'a> CompletionContext<'a> {
     // The range of the identifier that is being completed.
     pub(crate) fn source_range(&self) -> TextRange {
         // check kind of macro-expanded token, but use range of original token
-        match self.token.kind() {
-            // workaroud when completion is triggered by trigger characters.
-            IDENT => self.original_token.text_range(),
-            _ => {
-                // 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)
-                }
-            }
+        if self.token.kind() == IDENT || self.token.kind().is_keyword() {
+            mark::hit!(completes_if_prefix_is_keyword);
+            self.original_token.text_range()
+        } else {
+            TextRange::empty(self.offset)
         }
     }
 
-    pub(crate) fn scope(&self) -> SemanticsScope<'_, RootDatabase> {
-        self.sema.scope_at_offset(&self.token.parent(), self.offset)
+    fn fill_keyword_patterns(&mut self, file_with_fake_ident: &SyntaxNode, offset: TextSize) {
+        let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
+        let syntax_element = NodeOrToken::Token(fake_ident_token.clone());
+        self.block_expr_parent = has_block_expr_parent(syntax_element.clone());
+        self.unsafe_is_prev = unsafe_is_prev(syntax_element.clone());
+        self.if_is_prev = if_is_prev(syntax_element.clone());
+        self.bind_pat_parent = has_bind_pat_parent(syntax_element.clone());
+        self.ref_pat_parent = has_ref_parent(syntax_element.clone());
+        self.in_loop_body = is_in_loop_body(syntax_element.clone());
+        self.has_trait_parent = has_trait_parent(syntax_element.clone());
+        self.has_impl_parent = has_impl_parent(syntax_element.clone());
+        self.impl_as_prev_sibling = has_impl_as_prev_sibling(syntax_element.clone());
+        self.trait_as_prev_sibling = has_trait_as_prev_sibling(syntax_element.clone());
+        self.is_match_arm = is_match_arm(syntax_element.clone());
+        self.has_item_list_or_source_file_parent =
+            has_item_list_or_source_file_parent(syntax_element.clone());
     }
 
     fn fill(
@@ -330,10 +373,13 @@ 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_pattern_call =
+                path.syntax().parent().and_then(ast::TupleStructPat::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();
 
+            #[allow(deprecated)]
             if let Some(path) = hir::Path::from_ast(path.clone()) {
                 if let Some(path_prefix) = path.qualifier() {
                     self.path_prefix = Some(path_prefix);
@@ -364,6 +410,7 @@ impl<'a> CompletionContext<'a> {
                         None
                     })
                     .unwrap_or(false);
+                self.is_expr = path.syntax().parent().and_then(ast::PathExpr::cast).is_some();
 
                 if let Some(off) = name_ref.syntax().text_range().start().checked_sub(2.into()) {
                     if let Some(if_expr) =
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index cfb7c1e38..7bdda316c 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -58,7 +58,7 @@ pub struct CompletionItem {
     score: Option<CompletionScore>,
 }
 
-// We use custom debug for CompletionItem to make `insta`'s diffs more readable.
+// We use custom debug for CompletionItem to make snapshot tests more readable.
 impl fmt::Debug for CompletionItem {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut s = f.debug_struct("CompletionItem");
@@ -95,7 +95,7 @@ impl fmt::Debug for CompletionItem {
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq)]
 pub enum CompletionScore {
     /// If only type match
     TypeMatch,
@@ -123,6 +123,34 @@ pub enum CompletionItemKind {
     TypeParam,
     Macro,
     Attribute,
+    UnresolvedReference,
+}
+
+impl CompletionItemKind {
+    #[cfg(test)]
+    pub(crate) fn tag(&self) -> &'static str {
+        match self {
+            CompletionItemKind::Attribute => "at",
+            CompletionItemKind::Binding => "bn",
+            CompletionItemKind::BuiltinType => "bt",
+            CompletionItemKind::Const => "ct",
+            CompletionItemKind::Enum => "en",
+            CompletionItemKind::EnumVariant => "ev",
+            CompletionItemKind::Field => "fd",
+            CompletionItemKind::Function => "fn",
+            CompletionItemKind::Keyword => "kw",
+            CompletionItemKind::Macro => "ma",
+            CompletionItemKind::Method => "me",
+            CompletionItemKind::Module => "md",
+            CompletionItemKind::Snippet => "sn",
+            CompletionItemKind::Static => "sc",
+            CompletionItemKind::Struct => "st",
+            CompletionItemKind::Trait => "tt",
+            CompletionItemKind::TypeAlias => "ta",
+            CompletionItemKind::TypeParam => "tp",
+            CompletionItemKind::UnresolvedReference => "??",
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
diff --git a/crates/ra_ide/src/completion/patterns.rs b/crates/ra_ide/src/completion/patterns.rs
new file mode 100644
index 000000000..b2fe13280
--- /dev/null
+++ b/crates/ra_ide/src/completion/patterns.rs
@@ -0,0 +1,194 @@
+//! Patterns telling us certain facts about current syntax element, they are used in completion context
+
+use ra_syntax::{
+    algo::non_trivia_sibling,
+    ast::{self, LoopBodyOwner},
+    match_ast, AstNode, Direction, NodeOrToken, SyntaxElement,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxToken,
+};
+
+#[cfg(test)]
+use crate::completion::test_utils::check_pattern_is_applicable;
+
+pub(crate) fn has_trait_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == ITEM_LIST)
+        .and_then(|it| it.parent())
+        .filter(|it| it.kind() == TRAIT_DEF)
+        .is_some()
+}
+#[test]
+fn test_has_trait_parent() {
+    check_pattern_is_applicable(r"trait A { f<|> }", has_trait_parent);
+}
+
+pub(crate) fn has_impl_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == ITEM_LIST)
+        .and_then(|it| it.parent())
+        .filter(|it| it.kind() == IMPL_DEF)
+        .is_some()
+}
+#[test]
+fn test_has_impl_parent() {
+    check_pattern_is_applicable(r"impl A { f<|> }", has_impl_parent);
+}
+
+pub(crate) fn has_block_expr_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element).filter(|it| it.kind() == BLOCK_EXPR).is_some()
+}
+#[test]
+fn test_has_block_expr_parent() {
+    check_pattern_is_applicable(r"fn my_fn() { let a = 2; f<|> }", has_block_expr_parent);
+}
+
+pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
+    element.ancestors().find(|it| it.kind() == BIND_PAT).is_some()
+}
+#[test]
+fn test_has_bind_pat_parent() {
+    check_pattern_is_applicable(r"fn my_fn(m<|>) {}", has_bind_pat_parent);
+    check_pattern_is_applicable(r"fn my_fn() { let m<|> }", has_bind_pat_parent);
+}
+
+pub(crate) fn has_ref_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == REF_PAT || it.kind() == REF_EXPR)
+        .is_some()
+}
+#[test]
+fn test_has_ref_parent() {
+    check_pattern_is_applicable(r"fn my_fn(&m<|>) {}", has_ref_parent);
+    check_pattern_is_applicable(r"fn my() { let &m<|> }", has_ref_parent);
+}
+
+pub(crate) fn has_item_list_or_source_file_parent(element: SyntaxElement) -> bool {
+    let ancestor = not_same_range_ancestor(element);
+    if !ancestor.is_some() {
+        return true;
+    }
+    ancestor.filter(|it| it.kind() == SOURCE_FILE || it.kind() == ITEM_LIST).is_some()
+}
+#[test]
+fn test_has_item_list_or_source_file_parent() {
+    check_pattern_is_applicable(r"i<|>", has_item_list_or_source_file_parent);
+    check_pattern_is_applicable(r"impl { f<|> }", has_item_list_or_source_file_parent);
+}
+
+pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element.clone()).filter(|it| it.kind() == MATCH_ARM).is_some()
+        && previous_sibling_or_ancestor_sibling(element)
+            .and_then(|it| it.into_token())
+            .filter(|it| it.kind() == FAT_ARROW)
+            .is_some()
+}
+#[test]
+fn test_is_match_arm() {
+    check_pattern_is_applicable(r"fn my_fn() { match () { () => m<|> } }", is_match_arm);
+}
+
+pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
+    element
+        .into_token()
+        .and_then(|it| previous_non_trivia_token(it))
+        .filter(|it| it.kind() == UNSAFE_KW)
+        .is_some()
+}
+#[test]
+fn test_unsafe_is_prev() {
+    check_pattern_is_applicable(r"unsafe i<|>", unsafe_is_prev);
+}
+
+pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
+    element
+        .into_token()
+        .and_then(|it| previous_non_trivia_token(it))
+        .filter(|it| it.kind() == IF_KW)
+        .is_some()
+}
+#[test]
+fn test_if_is_prev() {
+    check_pattern_is_applicable(r"if l<|>", if_is_prev);
+}
+
+pub(crate) fn has_trait_as_prev_sibling(element: SyntaxElement) -> bool {
+    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == TRAIT_DEF).is_some()
+}
+#[test]
+fn test_has_trait_as_prev_sibling() {
+    check_pattern_is_applicable(r"trait A w<|> {}", has_trait_as_prev_sibling);
+}
+
+pub(crate) fn has_impl_as_prev_sibling(element: SyntaxElement) -> bool {
+    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == IMPL_DEF).is_some()
+}
+#[test]
+fn test_has_impl_as_prev_sibling() {
+    check_pattern_is_applicable(r"impl A w<|> {}", has_impl_as_prev_sibling);
+}
+
+pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
+    let leaf = match element {
+        NodeOrToken::Node(node) => node,
+        NodeOrToken::Token(token) => token.parent(),
+    };
+    for node in leaf.ancestors() {
+        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
+            break;
+        }
+        let loop_body = match_ast! {
+            match node {
+                ast::ForExpr(it) => it.loop_body(),
+                ast::WhileExpr(it) => it.loop_body(),
+                ast::LoopExpr(it) => it.loop_body(),
+                _ => None,
+            }
+        };
+        if let Some(body) = loop_body {
+            if body.syntax().text_range().contains_range(leaf.text_range()) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn not_same_range_ancestor(element: SyntaxElement) -> Option<SyntaxNode> {
+    element
+        .ancestors()
+        .take_while(|it| it.text_range() == element.text_range())
+        .last()
+        .and_then(|it| it.parent())
+}
+
+fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
+    let mut token = token.prev_token();
+    while let Some(inner) = token.clone() {
+        if !inner.kind().is_trivia() {
+            return Some(inner);
+        } else {
+            token = inner.prev_token();
+        }
+    }
+    None
+}
+
+fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<SyntaxElement> {
+    let token_sibling = non_trivia_sibling(element.clone(), Direction::Prev);
+    if let Some(sibling) = token_sibling {
+        Some(sibling)
+    } else {
+        // if not trying to find first ancestor which has such a sibling
+        let node = match element {
+            NodeOrToken::Node(node) => node,
+            NodeOrToken::Token(token) => token.parent(),
+        };
+        let range = node.text_range();
+        let top_node = node.ancestors().take_while(|it| it.text_range() == range).last()?;
+        let prev_sibling_node = top_node.ancestors().find(|it| {
+            non_trivia_sibling(NodeOrToken::Node(it.to_owned()), Direction::Prev).is_some()
+        })?;
+        non_trivia_sibling(NodeOrToken::Node(prev_sibling_node), Direction::Prev)
+    }
+}
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 61565c84f..64349dcb8 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -1,4 +1,5 @@
 //! This modules takes care of rendering various definitions as completion items.
+//! It also handles scoring (sorting) completions.
 
 use hir::{Docs, HasAttrs, HasSource, HirDisplay, ModPath, ScopeDef, StructKind, Type};
 use ra_syntax::ast::NameOwner;
@@ -78,11 +79,10 @@ impl Completions {
                 return self.add_macro(ctx, Some(local_name), *mac);
             }
             ScopeDef::Unknown => {
-                return self.add(CompletionItem::new(
-                    CompletionKind::Reference,
-                    ctx.source_range(),
-                    local_name,
-                ));
+                return self.add(
+                    CompletionItem::new(CompletionKind::Reference, ctx.source_range(), local_name)
+                        .kind(CompletionItemKind::UnresolvedReference),
+                );
             }
         };
 
@@ -173,6 +173,7 @@ impl Completions {
                 builder
                     .insert_snippet(cap, format!("{}!{}$0{}", name, bra, ket))
                     .label(format!("{}!{}…{}", name, bra, ket))
+                    .lookup_by(format!("{}!", name))
             }
             None if needs_bang => builder.insert_text(format!("{}!", name)),
             _ => {
@@ -314,6 +315,7 @@ impl Completions {
         }
 
         if variant_kind == StructKind::Tuple {
+            mark::hit!(inserts_parens_for_tuple_enums);
             let params = Params::Anonymous(variant.fields(ctx.db).len());
             res = res.add_call_parens(ctx, qualified_name, params)
         }
@@ -330,14 +332,14 @@ pub(crate) fn compute_score(
     // 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 {
-        mark::hit!(test_struct_field_completion_in_record_lit);
+        mark::hit!(record_field_type_match);
         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 {
-        mark::hit!(test_struct_field_completion_in_func_call);
+        mark::hit!(active_param_type_match);
         (active_parameter.name.clone(), active_parameter.ty.clone())
     } else {
         return None;
@@ -382,13 +384,22 @@ impl Builder {
         if !ctx.config.add_call_parenthesis {
             return self;
         }
-        if ctx.use_item_syntax.is_some() || ctx.is_call {
+        if ctx.use_item_syntax.is_some() {
+            mark::hit!(no_parens_in_use_item);
+            return self;
+        }
+        if ctx.is_pattern_call {
+            mark::hit!(dont_duplicate_pattern_parens);
+            return self;
+        }
+        if ctx.is_call {
             return self;
         }
 
         // Don't add parentheses if the expected type is some function reference.
         if let Some(ty) = &ctx.expected_type {
             if ty.is_fn() {
+                mark::hit!(no_call_parens_if_fn_ptr_needed);
                 return self;
             }
         }
@@ -413,7 +424,10 @@ impl Builder {
                         .sep_by(", ");
                     format!("{}({})$0", name, function_params_snippet)
                 }
-                _ => format!("{}($0)", name),
+                _ => {
+                    mark::hit!(suppress_arg_snippets);
+                    format!("{}($0)", name)
+                }
             };
 
             (snippet, format!("{}(…)", name))
@@ -456,1061 +470,750 @@ fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static s
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use std::cmp::Reverse;
+
+    use expect::{expect, Expect};
     use test_utils::mark;
 
-    use crate::completion::{
-        test_utils::{do_completion, do_completion_with_options},
-        CompletionConfig, CompletionItem, CompletionKind,
+    use crate::{
+        completion::{
+            test_utils::{
+                check_edit, check_edit_with_config, do_completion, get_all_completion_items,
+            },
+            CompletionConfig, CompletionKind,
+        },
+        CompletionScore,
     };
 
-    fn do_reference_completion(ra_fixture: &str) -> Vec<CompletionItem> {
-        do_completion(ra_fixture, CompletionKind::Reference)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = do_completion(ra_fixture, CompletionKind::Reference);
+        expect.assert_debug_eq(&actual);
     }
 
-    fn do_reference_completion_with_options(
-        ra_fixture: &str,
-        options: CompletionConfig,
-    ) -> Vec<CompletionItem> {
-        do_completion_with_options(ra_fixture, CompletionKind::Reference, &options)
+    fn check_scores(ra_fixture: &str, expect: Expect) {
+        fn display_score(score: Option<CompletionScore>) -> &'static str {
+            match score {
+                Some(CompletionScore::TypeMatch) => "[type]",
+                Some(CompletionScore::TypeAndNameMatch) => "[type+name]",
+                None => "[]".into(),
+            }
+        }
+
+        let mut completions = get_all_completion_items(CompletionConfig::default(), ra_fixture);
+        completions.sort_by_key(|it| (Reverse(it.score()), it.label().to_string()));
+        let actual = completions
+            .into_iter()
+            .filter(|it| it.completion_kind == CompletionKind::Reference)
+            .map(|it| {
+                let tag = it.kind().unwrap().tag();
+                let score = display_score(it.score());
+                format!("{} {} {}\n", tag, it.label(), score)
+            })
+            .collect::<String>();
+        expect.assert_eq(&actual);
     }
 
     #[test]
-    fn enum_detail_includes_names_for_record() {
-        assert_debug_snapshot!(
-        do_reference_completion(
+    fn enum_detail_includes_record_fields() {
+        check(
             r#"
-                enum Foo {
-                    Foo {x: i32, y: i32}
-                }
-
-                fn main() { Foo::Fo<|> }
-                "#,
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "Foo",
-                source_range: 121..123,
-                delete: 121..123,
-                insert: "Foo",
-                kind: EnumVariant,
-                detail: "{ x: i32, y: i32 }",
-            },
-        ]"###
+enum Foo { Foo { x: i32, y: i32 } }
+
+fn main() { Foo::Fo<|> }
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "Foo",
+                        source_range: 54..56,
+                        delete: 54..56,
+                        insert: "Foo",
+                        kind: EnumVariant,
+                        detail: "{ x: i32, y: i32 }",
+                    },
+                ]
+            "#]],
         );
     }
 
     #[test]
-    fn enum_detail_doesnt_include_names_for_tuple() {
-        assert_debug_snapshot!(
-        do_reference_completion(
+    fn enum_detail_doesnt_include_tuple_fields() {
+        check(
             r#"
-                enum Foo {
-                    Foo (i32, i32)
-                }
-
-                fn main() { Foo::Fo<|> }
-                "#,
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "Foo(…)",
-                source_range: 115..117,
-                delete: 115..117,
-                insert: "Foo($0)",
-                kind: EnumVariant,
-                lookup: "Foo",
-                detail: "(i32, i32)",
-                trigger_call_info: true,
-            },
-        ]"###
+enum Foo { Foo (i32, i32) }
+
+fn main() { Foo::Fo<|> }
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "Foo(…)",
+                        source_range: 46..48,
+                        delete: 46..48,
+                        insert: "Foo($0)",
+                        kind: EnumVariant,
+                        lookup: "Foo",
+                        detail: "(i32, i32)",
+                        trigger_call_info: true,
+                    },
+                ]
+            "#]],
         );
     }
 
     #[test]
     fn enum_detail_just_parentheses_for_unit() {
-        assert_debug_snapshot!(
-        do_reference_completion(
+        check(
             r#"
-                enum Foo {
-                    Foo
-                }
-
-                fn main() { Foo::Fo<|> }
-                "#,
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "Foo",
-                source_range: 104..106,
-                delete: 104..106,
-                insert: "Foo",
-                kind: EnumVariant,
-                detail: "()",
-            },
-        ]"###
+enum Foo { Foo }
+
+fn main() { Foo::Fo<|> }
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "Foo",
+                        source_range: 35..37,
+                        delete: 35..37,
+                        insert: "Foo",
+                        kind: EnumVariant,
+                        detail: "()",
+                    },
+                ]
+            "#]],
         );
     }
 
     #[test]
     fn sets_deprecated_flag_in_completion_items() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r#"
-                #[deprecated]
-                fn something_deprecated() {}
-
-                #[deprecated(since = "1.0.0")]
-                fn something_else_deprecated() {}
-
-                fn main() { som<|> }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "main()",
-                source_range: 203..206,
-                delete: 203..206,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-            CompletionItem {
-                label: "something_deprecated()",
-                source_range: 203..206,
-                delete: 203..206,
-                insert: "something_deprecated()$0",
-                kind: Function,
-                lookup: "something_deprecated",
-                detail: "fn something_deprecated()",
-                deprecated: true,
-            },
-            CompletionItem {
-                label: "something_else_deprecated()",
-                source_range: 203..206,
-                delete: 203..206,
-                insert: "something_else_deprecated()$0",
-                kind: Function,
-                lookup: "something_else_deprecated",
-                detail: "fn something_else_deprecated()",
-                deprecated: true,
-            },
-        ]
-        "###
+        check(
+            r#"
+#[deprecated]
+fn something_deprecated() {}
+#[deprecated(since = "1.0.0")]
+fn something_else_deprecated() {}
+
+fn main() { som<|> }
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "main()",
+                        source_range: 121..124,
+                        delete: 121..124,
+                        insert: "main()$0",
+                        kind: Function,
+                        lookup: "main",
+                        detail: "fn main()",
+                    },
+                    CompletionItem {
+                        label: "something_deprecated()",
+                        source_range: 121..124,
+                        delete: 121..124,
+                        insert: "something_deprecated()$0",
+                        kind: Function,
+                        lookup: "something_deprecated",
+                        detail: "fn something_deprecated()",
+                        deprecated: true,
+                    },
+                    CompletionItem {
+                        label: "something_else_deprecated()",
+                        source_range: 121..124,
+                        delete: 121..124,
+                        insert: "something_else_deprecated()$0",
+                        kind: Function,
+                        lookup: "something_else_deprecated",
+                        detail: "fn something_else_deprecated()",
+                        deprecated: true,
+                    },
+                ]
+            "#]],
+        );
+
+        check(
+            r#"
+struct A { #[deprecated] the_field: u32 }
+fn foo() { A { the<|> } }
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "the_field",
+                        source_range: 57..60,
+                        delete: 57..60,
+                        insert: "the_field",
+                        kind: Field,
+                        detail: "u32",
+                        deprecated: true,
+                    },
+                ]
+            "#]],
         );
     }
 
     #[test]
+    fn renders_docs() {
+        check(
+            r#"
+struct S {
+    /// Field docs
+    foo:
+}
+impl S {
+    /// Method docs
+    fn bar(self) { self.<|> }
+}"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "bar()",
+                        source_range: 94..94,
+                        delete: 94..94,
+                        insert: "bar()$0",
+                        kind: Method,
+                        lookup: "bar",
+                        detail: "fn bar(self)",
+                        documentation: Documentation(
+                            "Method docs",
+                        ),
+                    },
+                    CompletionItem {
+                        label: "foo",
+                        source_range: 94..94,
+                        delete: 94..94,
+                        insert: "foo",
+                        kind: Field,
+                        detail: "{unknown}",
+                        documentation: Documentation(
+                            "Field docs",
+                        ),
+                    },
+                ]
+            "#]],
+        );
+
+        check(
+            r#"
+use self::my<|>;
+
+/// mod docs
+mod my { }
+
+/// enum docs
+enum E {
+    /// variant docs
+    V
+}
+use self::E::*;
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "E",
+                        source_range: 10..12,
+                        delete: 10..12,
+                        insert: "E",
+                        kind: Enum,
+                        documentation: Documentation(
+                            "enum docs",
+                        ),
+                    },
+                    CompletionItem {
+                        label: "V",
+                        source_range: 10..12,
+                        delete: 10..12,
+                        insert: "V",
+                        kind: EnumVariant,
+                        detail: "()",
+                        documentation: Documentation(
+                            "variant docs",
+                        ),
+                    },
+                    CompletionItem {
+                        label: "my",
+                        source_range: 10..12,
+                        delete: 10..12,
+                        insert: "my",
+                        kind: Module,
+                        documentation: Documentation(
+                            "mod docs",
+                        ),
+                    },
+                ]
+            "#]],
+        )
+    }
+
+    #[test]
+    fn dont_render_attrs() {
+        check(
+            r#"
+struct S;
+impl S {
+    #[inline]
+    fn the_method(&self) { }
+}
+fn foo(s: S) { s.<|> }
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "the_method()",
+                        source_range: 81..81,
+                        delete: 81..81,
+                        insert: "the_method()$0",
+                        kind: Method,
+                        lookup: "the_method",
+                        detail: "fn the_method(&self)",
+                    },
+                ]
+            "#]],
+        )
+    }
+
+    #[test]
     fn inserts_parens_for_function_calls() {
         mark::check!(inserts_parens_for_function_calls);
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn no_args() {}
-                fn main() { no_<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "main()",
-                source_range: 61..64,
-                delete: 61..64,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-            CompletionItem {
-                label: "no_args()",
-                source_range: 61..64,
-                delete: 61..64,
-                insert: "no_args()$0",
-                kind: Function,
-                lookup: "no_args",
-                detail: "fn no_args()",
-            },
-        ]
-        "###
-        );
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn with_args(x: i32, y: String) {}
-                fn main() { with_<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "main()",
-                source_range: 80..85,
-                delete: 80..85,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-            CompletionItem {
-                label: "with_args(…)",
-                source_range: 80..85,
-                delete: 80..85,
-                insert: "with_args(${1:x}, ${2:y})$0",
-                kind: Function,
-                lookup: "with_args",
-                detail: "fn with_args(x: i32, y: String)",
-                trigger_call_info: true,
-            },
-        ]
-        "###
+        check_edit(
+            "no_args",
+            r#"
+fn no_args() {}
+fn main() { no_<|> }
+"#,
+            r#"
+fn no_args() {}
+fn main() { no_args()$0 }
+"#,
         );
-        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,
-            },
-        ]
-        "###
+
+        check_edit(
+            "with_args",
+            r#"
+fn with_args(x: i32, y: String) {}
+fn main() { with_<|> }
+"#,
+            r#"
+fn with_args(x: i32, y: String) {}
+fn main() { with_args(${1:x}, ${2:y})$0 }
+"#,
         );
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct S {}
-                impl S {
-                    fn foo(&self) {}
-                }
-                fn bar(s: &S) {
-                    s.f<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo()",
-                source_range: 163..164,
-                delete: 163..164,
-                insert: "foo()$0",
-                kind: Method,
-                lookup: "foo",
-                detail: "fn foo(&self)",
-            },
-        ]
-        "###
+
+        check_edit(
+            "foo",
+            r#"
+struct S;
+impl S {
+    fn foo(&self) {}
+}
+fn bar(s: &S) { s.f<|> }
+"#,
+            r#"
+struct S;
+impl S {
+    fn foo(&self) {}
+}
+fn bar(s: &S) { s.foo()$0 }
+"#,
         );
-        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,
-            },
-        ]
-        "###
+
+        check_edit(
+            "foo",
+            r#"
+struct S {}
+impl S {
+    fn foo(&self, x: i32) {}
+}
+fn bar(s: &S) {
+    s.f<|>
+}
+"#,
+            r#"
+struct S {}
+impl S {
+    fn foo(&self, x: i32) {}
+}
+fn bar(s: &S) {
+    s.foo(${1:x})$0
+}
+"#,
         );
     }
 
     #[test]
-    fn inserts_parens_for_tuple_enums() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Option<T> { Some(T), None }
-                use Option::*;
-                fn main() -> Option<i32> {
-                    Som<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "None",
-                source_range: 144..147,
-                delete: 144..147,
-                insert: "None",
-                kind: EnumVariant,
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Option",
-                source_range: 144..147,
-                delete: 144..147,
-                insert: "Option",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "Some(…)",
-                source_range: 144..147,
-                delete: 144..147,
-                insert: "Some($0)",
-                kind: EnumVariant,
-                lookup: "Some",
-                detail: "(T)",
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 144..147,
-                delete: 144..147,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main() -> Option<i32>",
-            },
-        ]
-        "###
-        );
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Option<T> { Some(T), None }
-                use Option::*;
-                fn main(value: Option<i32>) {
-                    match value {
-                        Som<|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "None",
-                source_range: 185..188,
-                delete: 185..188,
-                insert: "None",
-                kind: EnumVariant,
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Option",
-                source_range: 185..188,
-                delete: 185..188,
-                insert: "Option",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "Some(…)",
-                source_range: 185..188,
-                delete: 185..188,
-                insert: "Some($0)",
-                kind: EnumVariant,
-                lookup: "Some",
-                detail: "(T)",
-                trigger_call_info: true,
-            },
-        ]
-        "###
+    fn suppress_arg_snippets() {
+        mark::check!(suppress_arg_snippets);
+        check_edit_with_config(
+            CompletionConfig { add_call_argument_snippets: false, ..CompletionConfig::default() },
+            "with_args",
+            r#"
+fn with_args(x: i32, y: String) {}
+fn main() { with_<|> }
+"#,
+            r#"
+fn with_args(x: i32, y: String) {}
+fn main() { with_args($0) }
+"#,
         );
     }
 
     #[test]
-    fn no_call_parens_if_fn_ptr_needed() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn somefn(with: u8, a: u8, lot: u8, of: u8, args: u8) {}
-
-                struct ManualVtable {
-                    method: fn(u8, u8, u8, u8, u8),
-                }
+    fn strips_underscores_from_args() {
+        check_edit(
+            "foo",
+            r#"
+fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {}
+fn main() { f<|> }
+"#,
+            r#"
+fn foo(_foo: i32, ___bar: bool, ho_ge_: String) {}
+fn main() { foo(${1:foo}, ${2:bar}, ${3:ho_ge_})$0 }
+"#,
+        );
+    }
 
-                fn main() -> ManualVtable {
-                    ManualVtable {
-                        method: some<|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "ManualVtable",
-                source_range: 295..299,
-                delete: 295..299,
-                insert: "ManualVtable",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "main",
-                source_range: 295..299,
-                delete: 295..299,
-                insert: "main",
-                kind: Function,
-                detail: "fn main() -> ManualVtable",
-            },
-            CompletionItem {
-                label: "somefn",
-                source_range: 295..299,
-                delete: 295..299,
-                insert: "somefn",
-                kind: Function,
-                detail: "fn somefn(with: u8, a: u8, lot: u8, of: u8, args: u8)",
-            },
-        ]
-        "###
+    #[test]
+    fn inserts_parens_for_tuple_enums() {
+        mark::check!(inserts_parens_for_tuple_enums);
+        check_edit(
+            "Some",
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+fn main() -> Option<i32> {
+    Som<|>
+}
+"#,
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+fn main() -> Option<i32> {
+    Some($0)
+}
+"#,
+        );
+        check_edit(
+            "Some",
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+fn main(value: Option<i32>) {
+    match value {
+        Som<|>
+    }
+}
+"#,
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+fn main(value: Option<i32>) {
+    match value {
+        Some($0)
+    }
+}
+"#,
         );
     }
 
     #[test]
-    fn arg_snippets_for_method_call() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct S {}
-                impl S {
-                    fn foo(&self, x: i32) {}
-                }
-                fn bar(s: &S) {
-                    s.f<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo(…)",
-                source_range: 171..172,
-                delete: 171..172,
-                insert: "foo(${1:x})$0",
-                kind: Method,
-                lookup: "foo",
-                detail: "fn foo(&self, x: i32)",
-                trigger_call_info: true,
-            },
-        ]
-        "###
-        )
+    fn dont_duplicate_pattern_parens() {
+        mark::check!(dont_duplicate_pattern_parens);
+        check_edit(
+            "Var",
+            r#"
+enum E { Var(i32) }
+fn main() {
+    match E::Var(92) {
+        E::<|>(92) => (),
+    }
+}
+"#,
+            r#"
+enum E { Var(i32) }
+fn main() {
+    match E::Var(92) {
+        E::Var(92) => (),
+    }
+}
+"#,
+        );
     }
 
     #[test]
-    fn no_arg_snippets_for_method_call() {
-        assert_debug_snapshot!(
-            do_reference_completion_with_options(
-                r"
-                struct S {}
-                impl S {
-                    fn foo(&self, x: i32) {}
-                }
-                fn bar(s: &S) {
-                    s.f<|>
-                }
-                ",
-                CompletionConfig {
-                    add_call_argument_snippets: false,
-                    .. Default::default()
-                }
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo(…)",
-                source_range: 171..172,
-                delete: 171..172,
-                insert: "foo($0)",
-                kind: Method,
-                lookup: "foo",
-                detail: "fn foo(&self, x: i32)",
-                trigger_call_info: true,
-            },
-        ]
-        "###
-        )
+    fn no_call_parens_if_fn_ptr_needed() {
+        mark::check!(no_call_parens_if_fn_ptr_needed);
+        check_edit(
+            "foo",
+            r#"
+fn foo(foo: u8, bar: u8) {}
+struct ManualVtable { f: fn(u8, u8) }
+
+fn main() -> ManualVtable {
+    ManualVtable { f: f<|> }
+}
+"#,
+            r#"
+fn foo(foo: u8, bar: u8) {}
+struct ManualVtable { f: fn(u8, u8) }
+
+fn main() -> ManualVtable {
+    ManualVtable { f: foo }
+}
+"#,
+        );
     }
 
     #[test]
-    fn dont_render_function_parens_in_use_item() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                mod m { pub fn foo() {} }
-                use crate::m::f<|>;
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo",
-                source_range: 40..41,
-                delete: 40..41,
-                insert: "foo",
-                kind: Function,
-                detail: "pub fn foo()",
-            },
-        ]
-        "###
+    fn no_parens_in_use_item() {
+        mark::check!(no_parens_in_use_item);
+        check_edit(
+            "foo",
+            r#"
+mod m { pub fn foo() {} }
+use crate::m::f<|>;
+"#,
+            r#"
+mod m { pub fn foo() {} }
+use crate::m::foo;
+"#,
         );
     }
 
     #[test]
-    fn dont_render_function_parens_if_already_call() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                fn frobnicate() {}
-                fn main() {
-                    frob<|>();
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "frobnicate",
-                source_range: 35..39,
-                delete: 35..39,
-                insert: "frobnicate",
-                kind: Function,
-                detail: "fn frobnicate()",
-            },
-            CompletionItem {
-                label: "main",
-                source_range: 35..39,
-                delete: 35..39,
-                insert: "main",
-                kind: Function,
-                detail: "fn main()",
-            },
-        ]
-        "###
+    fn no_parens_in_call() {
+        check_edit(
+            "foo",
+            r#"
+fn foo(x: i32) {}
+fn main() { f<|>(); }
+"#,
+            r#"
+fn foo(x: i32) {}
+fn main() { foo(); }
+"#,
         );
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                struct Foo {}
-                impl Foo { fn new() -> Foo {} }
-                fn main() {
-                    Foo::ne<|>();
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "new",
-                source_range: 67..69,
-                delete: 67..69,
-                insert: "new",
-                kind: Function,
-                detail: "fn new() -> Foo",
-            },
-        ]
-        "###
+        check_edit(
+            "foo",
+            r#"
+struct Foo;
+impl Foo { fn foo(&self){} }
+fn f(foo: &Foo) { foo.f<|>(); }
+"#,
+            r#"
+struct Foo;
+impl Foo { fn foo(&self){} }
+fn f(foo: &Foo) { foo.foo(); }
+"#,
         );
     }
 
     #[test]
     fn inserts_angle_brackets_for_generics() {
         mark::check!(inserts_angle_brackets_for_generics);
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct Vec<T> {}
-                fn foo(xs: Ve<|>)
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Vec<…>",
-                source_range: 61..63,
-                delete: 61..63,
-                insert: "Vec<$0>",
-                kind: Struct,
-                lookup: "Vec",
-            },
-            CompletionItem {
-                label: "foo(…)",
-                source_range: 61..63,
-                delete: 61..63,
-                insert: "foo(${1:xs})$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo(xs: Ve)",
-                trigger_call_info: true,
-            },
-        ]
-        "###
+        check_edit(
+            "Vec",
+            r#"
+struct Vec<T> {}
+fn foo(xs: Ve<|>)
+"#,
+            r#"
+struct Vec<T> {}
+fn foo(xs: Vec<$0>)
+"#,
         );
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                type Vec<T> = (T,);
-                fn foo(xs: Ve<|>)
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Vec<…>",
-                source_range: 64..66,
-                delete: 64..66,
-                insert: "Vec<$0>",
-                kind: TypeAlias,
-                lookup: "Vec",
-            },
-            CompletionItem {
-                label: "foo(…)",
-                source_range: 64..66,
-                delete: 64..66,
-                insert: "foo(${1:xs})$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo(xs: Ve)",
-                trigger_call_info: true,
-            },
-        ]
-        "###
+        check_edit(
+            "Vec",
+            r#"
+type Vec<T> = (T,);
+fn foo(xs: Ve<|>)
+"#,
+            r#"
+type Vec<T> = (T,);
+fn foo(xs: Vec<$0>)
+"#,
         );
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct Vec<T = i128> {}
-                fn foo(xs: Ve<|>)
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Vec",
-                source_range: 68..70,
-                delete: 68..70,
-                insert: "Vec",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "foo(…)",
-                source_range: 68..70,
-                delete: 68..70,
-                insert: "foo(${1:xs})$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo(xs: Ve)",
-                trigger_call_info: true,
-            },
-        ]
-        "###
+        check_edit(
+            "Vec",
+            r#"
+struct Vec<T = i128> {}
+fn foo(xs: Ve<|>)
+"#,
+            r#"
+struct Vec<T = i128> {}
+fn foo(xs: Vec)
+"#,
         );
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct Vec<T> {}
-                fn foo(xs: Ve<|><i128>)
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Vec",
-                source_range: 61..63,
-                delete: 61..63,
-                insert: "Vec",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "foo(…)",
-                source_range: 61..63,
-                delete: 61..63,
-                insert: "foo(${1:xs})$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo(xs: Ve<i128>)",
-                trigger_call_info: true,
-            },
-        ]
-        "###
+        check_edit(
+            "Vec",
+            r#"
+struct Vec<T> {}
+fn foo(xs: Ve<|><i128>)
+"#,
+            r#"
+struct Vec<T> {}
+fn foo(xs: Vec<i128>)
+"#,
         );
     }
 
     #[test]
     fn dont_insert_macro_call_parens_unncessary() {
         mark::check!(dont_insert_macro_call_parens_unncessary);
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                //- /main.rs
-                use foo::<|>;
-
-                //- /foo/lib.rs
-                #[macro_export]
-                macro_rules frobnicate {
-                    () => ()
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "frobnicate!",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "frobnicate",
-                kind: Macro,
-                detail: "#[macro_export]\nmacro_rules! frobnicate",
-            },
-        ]
-        "###
+        check_edit(
+            "frobnicate!",
+            r#"
+//- /main.rs
+use foo::<|>;
+//- /foo/lib.rs
+#[macro_export]
+macro_rules frobnicate { () => () }
+"#,
+            r#"
+use foo::frobnicate;
+"#,
         );
 
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                //- /main.rs
-                macro_rules frobnicate {
-                    () => ()
-                }
-                fn main() {
-                    frob<|>!();
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "frobnicate!",
-                source_range: 56..60,
-                delete: 56..60,
-                insert: "frobnicate",
-                kind: Macro,
-                detail: "macro_rules! frobnicate",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 56..60,
-                delete: 56..60,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+        check_edit(
+            "frobnicate!",
+            r#"
+macro_rules frobnicate { () => () }
+fn main() { frob<|>!(); }
+"#,
+            r#"
+macro_rules frobnicate { () => () }
+fn main() { frobnicate!(); }
+"#,
         );
     }
 
     #[test]
-    fn test_struct_field_completion_in_func_call() {
-        mark::check!(test_struct_field_completion_in_func_call);
-        assert_debug_snapshot!(
-        do_reference_completion(
-                r"
-                struct A { another_field: i64, the_field: u32, my_string: String }
-                fn test(my_param: u32) -> u32 { my_param }
-                fn foo(a: A) {
-                    test(a.<|>)
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "another_field",
-                source_range: 201..201,
-                delete: 201..201,
-                insert: "another_field",
-                kind: Field,
-                detail: "i64",
-            },
-            CompletionItem {
-                label: "my_string",
-                source_range: 201..201,
-                delete: 201..201,
-                insert: "my_string",
-                kind: Field,
-                detail: "{unknown}",
-            },
-            CompletionItem {
-                label: "the_field",
-                source_range: 201..201,
-                delete: 201..201,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-                score: TypeMatch,
-            },
-        ]
-        "###
+    fn active_param_score() {
+        mark::check!(active_param_type_match);
+        check_scores(
+            r#"
+struct S { foo: i64, bar: u32, baz: u32 }
+fn test(bar: u32) { }
+fn foo(s: S) { test(s.<|>) }
+"#,
+            expect![[r#"
+                fd bar [type+name]
+                fd baz [type]
+                fd foo []
+            "#]],
         );
     }
 
     #[test]
-    fn test_struct_field_completion_in_func_call_with_type_and_name() {
-        assert_debug_snapshot!(
-        do_reference_completion(
-                r"
-                struct A { another_field: i64, another_good_type: u32, the_field: u32 }
-                fn test(the_field: u32) -> u32 { the_field }
-                fn foo(a: A) {
-                    test(a.<|>)
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "another_field",
-                source_range: 208..208,
-                delete: 208..208,
-                insert: "another_field",
-                kind: Field,
-                detail: "i64",
-            },
-            CompletionItem {
-                label: "another_good_type",
-                source_range: 208..208,
-                delete: 208..208,
-                insert: "another_good_type",
-                kind: Field,
-                detail: "u32",
-                score: TypeMatch,
-            },
-            CompletionItem {
-                label: "the_field",
-                source_range: 208..208,
-                delete: 208..208,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-                score: TypeAndNameMatch,
-            },
-        ]
-        "###
-        );
+    fn record_field_scores() {
+        mark::check!(record_field_type_match);
+        check_scores(
+            r#"
+struct A { foo: i64, bar: u32, baz: u32 }
+struct B { x: (), y: f32, bar: u32 }
+fn foo(a: A) { B { bar: a.<|> }; }
+"#,
+            expect![[r#"
+                fd bar [type+name]
+                fd baz [type]
+                fd foo []
+            "#]],
+        )
     }
 
     #[test]
-    fn test_struct_field_completion_in_record_lit() {
-        mark::check!(test_struct_field_completion_in_record_lit);
-        assert_debug_snapshot!(
-        do_reference_completion(
-                r"
-                struct A { another_field: i64, another_good_type: u32, the_field: u32 }
-                struct B { my_string: String, my_vec: Vec<u32>, the_field: u32 }
-                fn foo(a: A) {
-                    let b = B {
-                        the_field: a.<|>
-                    };
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "another_field",
-                source_range: 270..270,
-                delete: 270..270,
-                insert: "another_field",
-                kind: Field,
-                detail: "i64",
-            },
-            CompletionItem {
-                label: "another_good_type",
-                source_range: 270..270,
-                delete: 270..270,
-                insert: "another_good_type",
-                kind: Field,
-                detail: "u32",
-                score: TypeMatch,
-            },
-            CompletionItem {
-                label: "the_field",
-                source_range: 270..270,
-                delete: 270..270,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-                score: TypeAndNameMatch,
-            },
-        ]
-        "###
+    fn record_field_and_call_scores() {
+        check_scores(
+            r#"
+struct A { foo: i64, bar: u32, baz: u32 }
+struct B { x: (), y: f32, bar: u32 }
+fn f(foo: i64) {  }
+fn foo(a: A) { B { bar: f(a.<|>) }; }
+"#,
+            expect![[r#"
+                fd foo [type+name]
+                fd bar []
+                fd baz []
+            "#]],
         );
-    }
-
-    #[test]
-    fn test_struct_field_completion_in_record_lit_and_fn_call() {
-        assert_debug_snapshot!(
-        do_reference_completion(
-                r"
-                struct A { another_field: i64, another_good_type: u32, the_field: u32 }
-                struct B { my_string: String, my_vec: Vec<u32>, the_field: u32 }
-                fn test(the_field: i64) -> i64 { the_field }
-                fn foo(a: A) {
-                    let b = B {
-                        the_field: test(a.<|>)
-                    };
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "another_field",
-                source_range: 336..336,
-                delete: 336..336,
-                insert: "another_field",
-                kind: Field,
-                detail: "i64",
-                score: TypeMatch,
-            },
-            CompletionItem {
-                label: "another_good_type",
-                source_range: 336..336,
-                delete: 336..336,
-                insert: "another_good_type",
-                kind: Field,
-                detail: "u32",
-            },
-            CompletionItem {
-                label: "the_field",
-                source_range: 336..336,
-                delete: 336..336,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+        check_scores(
+            r#"
+struct A { foo: i64, bar: u32, baz: u32 }
+struct B { x: (), y: f32, bar: u32 }
+fn f(foo: i64) {  }
+fn foo(a: A) { f(B { bar: a.<|> }); }
+"#,
+            expect![[r#"
+                fd bar [type+name]
+                fd baz [type]
+                fd foo []
+            "#]],
         );
     }
 
     #[test]
-    fn test_struct_field_completion_in_fn_call_and_record_lit() {
-        assert_debug_snapshot!(
-        do_reference_completion(
-                r"
-                struct A { another_field: i64, another_good_type: u32, the_field: u32 }
-                struct B { my_string: String, my_vec: Vec<u32>, the_field: u32 }
-                fn test(the_field: i64) -> i64 { the_field }
-                fn foo(a: A) {
-                    test(B {
-                        the_field: a.<|>
-                    });
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "another_field",
-                source_range: 328..328,
-                delete: 328..328,
-                insert: "another_field",
-                kind: Field,
-                detail: "i64",
-            },
-            CompletionItem {
-                label: "another_good_type",
-                source_range: 328..328,
-                delete: 328..328,
-                insert: "another_good_type",
-                kind: Field,
-                detail: "u32",
-                score: TypeMatch,
-            },
-            CompletionItem {
-                label: "the_field",
-                source_range: 328..328,
-                delete: 328..328,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-                score: TypeAndNameMatch,
-            },
-        ]
-        "###
+    fn prioritize_exact_ref_match() {
+        check_scores(
+            r#"
+struct WorldSnapshot { _f: () };
+fn go(world: &WorldSnapshot) { go(w<|>) }
+"#,
+            expect![[r#"
+                bn world [type+name]
+                st WorldSnapshot []
+                fn go(…) []
+            "#]],
         );
     }
 
     #[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,
-            },
-        ]
-        "###
+    fn guesses_macro_braces() {
+        check_edit(
+            "vec!",
+            r#"
+/// Creates a [`Vec`] containing the arguments.
+///
+/// ```
+/// let v = vec![1, 2, 3];
+/// assert_eq!(v[0], 1);
+/// assert_eq!(v[1], 2);
+/// assert_eq!(v[2], 3);
+/// ```
+macro_rules! vec { () => {} }
+
+fn fn main() { v<|> }
+"#,
+            r#"
+/// Creates a [`Vec`] containing the arguments.
+///
+/// ```
+/// let v = vec![1, 2, 3];
+/// assert_eq!(v[0], 1);
+/// assert_eq!(v[1], 2);
+/// assert_eq!(v[2], 3);
+/// ```
+macro_rules! vec { () => {} }
+
+fn fn main() { vec![$0] }
+"#,
         );
+
+        check_edit(
+            "foo!",
+            r#"
+/// Foo
+///
+/// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`,
+/// call as `let _=foo!  { hello world };`
+macro_rules! foo { () => {} }
+fn main() { <|> }
+"#,
+            r#"
+/// Foo
+///
+/// Don't call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`,
+/// call as `let _=foo!  { hello world };`
+macro_rules! foo { () => {} }
+fn main() { foo! {$0} }
+"#,
+        )
     }
 }
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index bf22452a2..919177745 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -1,29 +1,114 @@
 //! Runs completion for testing purposes.
 
+use hir::Semantics;
+use itertools::Itertools;
+use ra_syntax::{AstNode, NodeOrToken, SyntaxElement};
+use stdx::{format_to, trim_indent};
+use test_utils::assert_eq_text;
+
 use crate::{
     completion::{completion_item::CompletionKind, CompletionConfig},
-    mock_analysis::{analysis_and_position, single_file_with_position},
+    mock_analysis::analysis_and_position,
     CompletionItem,
 };
 
 pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
-    do_completion_with_options(code, kind, &CompletionConfig::default())
+    do_completion_with_config(CompletionConfig::default(), code, kind)
 }
 
-pub(crate) fn do_completion_with_options(
+pub(crate) fn do_completion_with_config(
+    config: CompletionConfig,
     code: &str,
     kind: CompletionKind,
-    options: &CompletionConfig,
 ) -> Vec<CompletionItem> {
-    let (analysis, position) = if code.contains("//-") {
-        analysis_and_position(code)
-    } else {
-        single_file_with_position(code)
-    };
-    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();
+    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(config, code)
+        .into_iter()
+        .filter(|c| c.completion_kind == kind)
+        .collect();
+    kind_completions.sort_by(|l, r| l.label().cmp(r.label()));
+    kind_completions
+}
+
+pub(crate) fn completion_list(code: &str, kind: CompletionKind) -> String {
+    completion_list_with_config(CompletionConfig::default(), code, kind)
+}
+
+pub(crate) fn completion_list_with_config(
+    config: CompletionConfig,
+    code: &str,
+    kind: CompletionKind,
+) -> String {
+    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(config, code)
+        .into_iter()
+        .filter(|c| c.completion_kind == kind)
+        .collect();
     kind_completions.sort_by_key(|c| c.label().to_owned());
+    let label_width = kind_completions
+        .iter()
+        .map(|it| monospace_width(it.label()))
+        .max()
+        .unwrap_or_default()
+        .min(16);
     kind_completions
+        .into_iter()
+        .map(|it| {
+            let tag = it.kind().unwrap().tag();
+            let var_name = format!("{} {}", tag, it.label());
+            let mut buf = var_name;
+            if let Some(detail) = it.detail() {
+                let width = label_width.saturating_sub(monospace_width(it.label()));
+                format_to!(buf, "{:width$} {}", "", detail, width = width);
+            }
+            format_to!(buf, "\n");
+            buf
+        })
+        .collect()
+}
+
+fn monospace_width(s: &str) -> usize {
+    s.chars().count()
+}
+
+pub(crate) fn check_edit(what: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
+    check_edit_with_config(CompletionConfig::default(), what, ra_fixture_before, ra_fixture_after)
+}
+
+pub(crate) fn check_edit_with_config(
+    config: CompletionConfig,
+    what: &str,
+    ra_fixture_before: &str,
+    ra_fixture_after: &str,
+) {
+    let ra_fixture_after = trim_indent(ra_fixture_after);
+    let (analysis, position) = analysis_and_position(ra_fixture_before);
+    let completions: Vec<CompletionItem> =
+        analysis.completions(&config, position).unwrap().unwrap().into();
+    let (completion,) = completions
+        .iter()
+        .filter(|it| it.lookup() == what)
+        .collect_tuple()
+        .unwrap_or_else(|| panic!("can't find {:?} completion in {:#?}", what, completions));
+    let mut actual = analysis.file_text(position.file_id).unwrap().to_string();
+    completion.text_edit().apply(&mut actual);
+    assert_eq_text!(&ra_fixture_after, &actual)
+}
+
+pub(crate) fn check_pattern_is_applicable(code: &str, check: fn(SyntaxElement) -> bool) {
+    let (analysis, pos) = analysis_and_position(code);
+    analysis
+        .with_db(|db| {
+            let sema = Semantics::new(db);
+            let original_file = sema.parse(pos.file_id);
+            let token = original_file.syntax().token_at_offset(pos.offset).left_biased().unwrap();
+            assert!(check(NodeOrToken::Token(token)));
+        })
+        .unwrap();
+}
+
+pub(crate) fn get_all_completion_items(
+    config: CompletionConfig,
+    code: &str,
+) -> Vec<CompletionItem> {
+    let (analysis, position) = analysis_and_position(code);
+    analysis.completions(&config, position).unwrap().unwrap().into()
 }
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index 15dc50cf1..fe75f4b2c 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -8,20 +8,20 @@ use std::cell::RefCell;
 
 use hir::{
     diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink},
-    Semantics,
+    HasSource, HirDisplay, Semantics, VariantDef,
 };
 use itertools::Itertools;
-use ra_db::{RelativePath, SourceDatabase, SourceDatabaseExt};
+use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
     algo,
-    ast::{self, make, AstNode},
+    ast::{self, edit::IndentLevel, make, AstNode},
     SyntaxNode, TextRange, T,
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
 
-use crate::{Diagnostic, FileId, FileSystemEdit, Fix, SourceChange, SourceFileEdit};
+use crate::{Diagnostic, FileId, FileSystemEdit, Fix, SourceFileEdit};
 
 #[derive(Debug, Copy, Clone)]
 pub enum Severity {
@@ -35,7 +35,8 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
     let parse = db.parse(file_id);
     let mut res = Vec::new();
 
-    res.extend(parse.errors().iter().map(|err| Diagnostic {
+    // [#34344] Only take first 128 errors to prevent slowing down editor/ide, the number 128 is chosen arbitrarily.
+    res.extend(parse.errors().iter().take(128).map(|err| Diagnostic {
         range: err.range(),
         message: format!("Syntax Error: {}", err),
         severity: Severity::Error,
@@ -57,14 +58,10 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
     })
     .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
         let original_file = d.source().file_id.original_file(db);
-        let source_root = db.file_source_root(original_file);
-        let path = db
-            .file_relative_path(original_file)
-            .parent()
-            .unwrap_or_else(|| RelativePath::new(""))
-            .join(&d.candidate);
-        let fix =
-            Fix::new("Create module", FileSystemEdit::CreateFile { source_root, path }.into());
+        let fix = Fix::new(
+            "Create module",
+            FileSystemEdit::CreateFile { anchor: original_file, dst: d.candidate.clone() }.into(),
+        );
         res.borrow_mut().push(Diagnostic {
             range: sema.diagnostics_range(d).range,
             message: d.message(),
@@ -103,19 +100,11 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
             fix,
         })
     })
-    .on::<hir::diagnostics::MissingMatchArms, _>(|d| {
-        res.borrow_mut().push(Diagnostic {
-            range: sema.diagnostics_range(d).range,
-            message: d.message(),
-            severity: Severity::Error,
-            fix: None,
-        })
-    })
     .on::<hir::diagnostics::MissingOkInTailExpr, _>(|d| {
         let node = d.ast(db);
         let replacement = format!("Ok({})", node.syntax());
         let edit = TextEdit::replace(node.syntax().text_range(), replacement);
-        let source_change = SourceChange::source_file_edit_from(file_id, edit);
+        let source_change = SourceFileEdit { file_id, edit }.into();
         let fix = Fix::new("Wrap with ok", source_change);
         res.borrow_mut().push(Diagnostic {
             range: sema.diagnostics_range(d).range,
@@ -123,7 +112,16 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
             severity: Severity::Error,
             fix: Some(fix),
         })
+    })
+    .on::<hir::diagnostics::NoSuchField, _>(|d| {
+        res.borrow_mut().push(Diagnostic {
+            range: sema.diagnostics_range(d).range,
+            message: d.message(),
+            severity: Severity::Error,
+            fix: missing_struct_field_fix(&sema, file_id, d),
+        })
     });
+
     if let Some(m) = sema.to_module_def(file_id) {
         m.diagnostics(db, &mut sink);
     };
@@ -131,6 +129,80 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
     res.into_inner()
 }
 
+fn missing_struct_field_fix(
+    sema: &Semantics<RootDatabase>,
+    usage_file_id: FileId,
+    d: &hir::diagnostics::NoSuchField,
+) -> Option<Fix> {
+    let record_expr = sema.ast(d);
+
+    let record_lit = ast::RecordLit::cast(record_expr.syntax().parent()?.parent()?)?;
+    let def_id = sema.resolve_variant(record_lit)?;
+    let module;
+    let def_file_id;
+    let record_fields = match VariantDef::from(def_id) {
+        VariantDef::Struct(s) => {
+            module = s.module(sema.db);
+            let source = s.source(sema.db);
+            def_file_id = source.file_id;
+            let fields = source.value.field_def_list()?;
+            record_field_def_list(fields)?
+        }
+        VariantDef::Union(u) => {
+            module = u.module(sema.db);
+            let source = u.source(sema.db);
+            def_file_id = source.file_id;
+            source.value.record_field_def_list()?
+        }
+        VariantDef::EnumVariant(e) => {
+            module = e.module(sema.db);
+            let source = e.source(sema.db);
+            def_file_id = source.file_id;
+            let fields = source.value.field_def_list()?;
+            record_field_def_list(fields)?
+        }
+    };
+    let def_file_id = def_file_id.original_file(sema.db);
+
+    let new_field_type = sema.type_of_expr(&record_expr.expr()?)?;
+    if new_field_type.is_unknown() {
+        return None;
+    }
+    let new_field = make::record_field_def(
+        record_expr.field_name()?,
+        make::type_ref(&new_field_type.display_source_code(sema.db, module.into()).ok()?),
+    );
+
+    let last_field = record_fields.fields().last()?;
+    let last_field_syntax = last_field.syntax();
+    let indent = IndentLevel::from_node(last_field_syntax);
+
+    let mut new_field = new_field.to_string();
+    if usage_file_id != def_file_id {
+        new_field = format!("pub(crate) {}", new_field);
+    }
+    new_field = format!("\n{}{}", indent, new_field);
+
+    let needs_comma = !last_field_syntax.to_string().ends_with(",");
+    if needs_comma {
+        new_field = format!(",{}", new_field);
+    }
+
+    let source_change = SourceFileEdit {
+        file_id: def_file_id,
+        edit: TextEdit::insert(last_field_syntax.text_range().end(), new_field),
+    };
+    let fix = Fix::new("Create field", source_change.into());
+    return Some(fix);
+
+    fn record_field_def_list(field_def_list: ast::FieldDefList) -> Option<ast::RecordFieldDefList> {
+        match field_def_list {
+            ast::FieldDefList::RecordFieldDefList(it) => Some(it),
+            ast::FieldDefList::TupleFieldDefList(_) => None,
+        }
+    }
+}
+
 fn check_unnecessary_braces_in_use_statement(
     acc: &mut Vec<Diagnostic>,
     file_id: FileId,
@@ -187,7 +259,8 @@ fn check_struct_shorthand_initialization(
         if let (Some(name_ref), Some(expr)) = (record_field.name_ref(), record_field.expr()) {
             let field_name = name_ref.syntax().text().to_string();
             let field_expr = expr.syntax().text().to_string();
-            if field_name == field_expr {
+            let field_name_is_tup_index = name_ref.as_tuple_field().is_some();
+            if field_name == field_expr && !field_name_is_tup_index {
                 let mut edit_builder = TextEditBuilder::default();
                 edit_builder.delete(record_field.syntax().text_range());
                 edit_builder.insert(record_field.syntax().text_range().start(), field_name);
@@ -210,51 +283,21 @@ fn check_struct_shorthand_initialization(
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
-    use ra_syntax::SourceFile;
-    use stdx::SepBy;
+    use stdx::trim_indent;
     use test_utils::assert_eq_text;
 
-    use crate::mock_analysis::{analysis_and_position, single_file};
-
-    use super::*;
-
-    type DiagnosticChecker = fn(&mut Vec<Diagnostic>, FileId, &SyntaxNode) -> Option<()>;
-
-    fn check_not_applicable(code: &str, func: DiagnosticChecker) {
-        let parse = SourceFile::parse(code);
-        let mut diagnostics = Vec::new();
-        for node in parse.tree().syntax().descendants() {
-            func(&mut diagnostics, FileId(0), &node);
-        }
-        assert!(diagnostics.is_empty());
-    }
-
-    fn check_apply(before: &str, after: &str, func: DiagnosticChecker) {
-        let parse = SourceFile::parse(before);
-        let mut diagnostics = Vec::new();
-        for node in parse.tree().syntax().descendants() {
-            func(&mut diagnostics, FileId(0), &node);
-        }
-        let diagnostic =
-            diagnostics.pop().unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
-        let mut fix = diagnostic.fix.unwrap();
-        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);
-    }
+    use crate::mock_analysis::{analysis_and_position, single_file, MockAnalysis};
+    use expect::{expect, Expect};
 
     /// Takes a multi-file input fixture with annotated cursor positions,
     /// and checks that:
     ///  * a diagnostic is produced
     ///  * this diagnostic touches the input cursor position
     ///  * that the contents of the file containing the cursor match `after` after the diagnostic fix is applied
-    fn check_apply_diagnostic_fix_from_position(fixture: &str, after: &str) {
-        let (analysis, file_position) = analysis_and_position(fixture);
+    fn check_fix(ra_fixture_before: &str, ra_fixture_after: &str) {
+        let after = trim_indent(ra_fixture_after);
+
+        let (analysis, file_position) = analysis_and_position(ra_fixture_before);
         let diagnostic = analysis.diagnostics(file_position.file_id).unwrap().pop().unwrap();
         let mut fix = diagnostic.fix.unwrap();
         let edit = fix.source_change.source_file_edits.pop().unwrap().edit;
@@ -265,21 +308,6 @@ mod tests {
             actual
         };
 
-        // Strip indent and empty lines from `after`, to match the behaviour of
-        // `parse_fixture` called from `analysis_and_position`.
-        let margin = fixture
-            .lines()
-            .filter(|it| it.trim_start().starts_with("//-"))
-            .map(|it| it.len() - it.trim_start().len())
-            .next()
-            .expect("empty fixture");
-        let after = after
-            .lines()
-            .filter_map(|line| if line.len() > margin { Some(&line[margin..]) } else { None })
-            .sep_by("\n")
-            .suffix("\n")
-            .to_string();
-
         assert_eq_text!(&after, &actual);
         assert!(
             diagnostic.range.start() <= file_position.offset
@@ -290,508 +318,470 @@ mod tests {
         );
     }
 
-    fn check_apply_diagnostic_fix(before: &str, after: &str) {
-        let (analysis, file_id) = single_file(before);
-        let diagnostic = analysis.diagnostics(file_id).unwrap().pop().unwrap();
+    /// Checks that a diagnostic applies to the file containing the `<|>` cursor marker
+    /// which has a fix that can apply to other files.
+    fn check_apply_diagnostic_fix_in_other_file(ra_fixture_before: &str, ra_fixture_after: &str) {
+        let ra_fixture_after = &trim_indent(ra_fixture_after);
+        let (analysis, file_pos) = analysis_and_position(ra_fixture_before);
+        let current_file_id = file_pos.file_id;
+        let diagnostic = analysis.diagnostics(current_file_id).unwrap().pop().unwrap();
         let mut fix = diagnostic.fix.unwrap();
-        let edit = fix.source_change.source_file_edits.pop().unwrap().edit;
+        let edit = fix.source_change.source_file_edits.pop().unwrap();
+        let changed_file_id = edit.file_id;
+        let before = analysis.file_text(changed_file_id).unwrap();
         let actual = {
             let mut actual = before.to_string();
-            edit.apply(&mut actual);
+            edit.edit.apply(&mut actual);
             actual
         };
-        assert_eq_text!(after, &actual);
+        assert_eq_text!(ra_fixture_after, &actual);
     }
 
     /// Takes a multi-file input fixture with annotated cursor position and checks that no diagnostics
     /// apply to the file containing the cursor.
-    fn check_no_diagnostic_for_target_file(fixture: &str) {
-        let (analysis, file_position) = analysis_and_position(fixture);
-        let diagnostics = analysis.diagnostics(file_position.file_id).unwrap();
-        assert_eq!(diagnostics.len(), 0);
+    fn check_no_diagnostics(ra_fixture: &str) {
+        let mock = MockAnalysis::with_files(ra_fixture);
+        let files = mock.files().map(|(it, _)| it).collect::<Vec<_>>();
+        let analysis = mock.analysis();
+        let diagnostics = files
+            .into_iter()
+            .flat_map(|file_id| analysis.diagnostics(file_id).unwrap())
+            .collect::<Vec<_>>();
+        assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
     }
 
-    fn check_no_diagnostic(content: &str) {
-        let (analysis, file_id) = single_file(content);
+    fn check_expect(ra_fixture: &str, expect: Expect) {
+        let (analysis, file_id) = single_file(ra_fixture);
         let diagnostics = analysis.diagnostics(file_id).unwrap();
-        assert_eq!(diagnostics.len(), 0, "expected no diagnostic, found one");
+        expect.assert_debug_eq(&diagnostics)
     }
 
     #[test]
     fn test_wrap_return_type() {
-        let before = r#"
-            //- /main.rs
-            use std::{string::String, result::Result::{self, Ok, Err}};
+        check_fix(
+            r#"
+//- /main.rs
+use core::result::Result::{self, Ok, Err};
 
-            fn div(x: i32, y: i32) -> Result<i32, String> {
-                if y == 0 {
-                    return Err("div by zero".into());
-                }
-                x / y<|>
-            }
+fn div(x: i32, y: i32) -> Result<i32, ()> {
+    if y == 0 {
+        return Err(());
+    }
+    x / y<|>
+}
+//- /core/lib.rs
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+"#,
+            r#"
+use core::result::Result::{self, Ok, Err};
 
-            //- /std/lib.rs
-            pub mod string {
-                pub struct String { }
-            }
-            pub mod result {
-                pub enum Result<T, E> { Ok(T), Err(E) }
-            }
-        "#;
-        let after = r#"
-            use std::{string::String, result::Result::{self, Ok, Err}};
-
-            fn div(x: i32, y: i32) -> Result<i32, String> {
-                if y == 0 {
-                    return Err("div by zero".into());
-                }
-                Ok(x / y)
-            }
-        "#;
-        check_apply_diagnostic_fix_from_position(before, after);
+fn div(x: i32, y: i32) -> Result<i32, ()> {
+    if y == 0 {
+        return Err(());
+    }
+    Ok(x / y)
+}
+"#,
+        );
     }
 
     #[test]
     fn test_wrap_return_type_handles_generic_functions() {
-        let before = r#"
-            //- /main.rs
-            use std::result::Result::{self, Ok, Err};
+        check_fix(
+            r#"
+//- /main.rs
+use core::result::Result::{self, Ok, Err};
 
-            fn div<T>(x: T) -> Result<T, i32> {
-                if x == 0 {
-                    return Err(7);
-                }
-                <|>x
-            }
+fn div<T>(x: T) -> Result<T, i32> {
+    if x == 0 {
+        return Err(7);
+    }
+    <|>x
+}
+//- /core/lib.rs
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+"#,
+            r#"
+use core::result::Result::{self, Ok, Err};
 
-            //- /std/lib.rs
-            pub mod result {
-                pub enum Result<T, E> { Ok(T), Err(E) }
-            }
-        "#;
-        let after = r#"
-            use std::result::Result::{self, Ok, Err};
-
-            fn div<T>(x: T) -> Result<T, i32> {
-                if x == 0 {
-                    return Err(7);
-                }
-                Ok(x)
-            }
-        "#;
-        check_apply_diagnostic_fix_from_position(before, after);
+fn div<T>(x: T) -> Result<T, i32> {
+    if x == 0 {
+        return Err(7);
+    }
+    Ok(x)
+}
+"#,
+        );
     }
 
     #[test]
     fn test_wrap_return_type_handles_type_aliases() {
-        let before = r#"
-            //- /main.rs
-            use std::{string::String, result::Result::{self, Ok, Err}};
+        check_fix(
+            r#"
+//- /main.rs
+use core::result::Result::{self, Ok, Err};
 
-            type MyResult<T> = Result<T, String>;
+type MyResult<T> = Result<T, ()>;
 
-            fn div(x: i32, y: i32) -> MyResult<i32> {
-                if y == 0 {
-                    return Err("div by zero".into());
-                }
-                x <|>/ y
-            }
+fn div(x: i32, y: i32) -> MyResult<i32> {
+    if y == 0 {
+        return Err(());
+    }
+    x <|>/ y
+}
+//- /core/lib.rs
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+"#,
+            r#"
+use core::result::Result::{self, Ok, Err};
 
-            //- /std/lib.rs
-            pub mod string {
-                pub struct String { }
-            }
-            pub mod result {
-                pub enum Result<T, E> { Ok(T), Err(E) }
-            }
-        "#;
-        let after = r#"
-            use std::{string::String, result::Result::{self, Ok, Err}};
-
-            type MyResult<T> = Result<T, String>;
-            fn div(x: i32, y: i32) -> MyResult<i32> {
-                if y == 0 {
-                    return Err("div by zero".into());
-                }
-                Ok(x / y)
-            }
-        "#;
-        check_apply_diagnostic_fix_from_position(before, after);
+type MyResult<T> = Result<T, ()>;
+
+fn div(x: i32, y: i32) -> MyResult<i32> {
+    if y == 0 {
+        return Err(());
+    }
+    Ok(x / y)
+}
+"#,
+        );
     }
 
     #[test]
     fn test_wrap_return_type_not_applicable_when_expr_type_does_not_match_ok_type() {
-        let content = r#"
-            //- /main.rs
-            use std::{string::String, result::Result::{self, Ok, Err}};
+        check_no_diagnostics(
+            r#"
+//- /main.rs
+use core::result::Result::{self, Ok, Err};
 
-            fn foo() -> Result<String, i32> {
-                0<|>
-            }
+fn foo() -> Result<(), i32> { 0 }
 
-            //- /std/lib.rs
-            pub mod string {
-                pub struct String { }
-            }
-            pub mod result {
-                pub enum Result<T, E> { Ok(T), Err(E) }
-            }
-        "#;
-        check_no_diagnostic_for_target_file(content);
+//- /core/lib.rs
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+"#,
+        );
     }
 
     #[test]
     fn test_wrap_return_type_not_applicable_when_return_type_is_not_result() {
-        let content = r#"
-            //- /main.rs
-            use std::{string::String, result::Result::{self, Ok, Err}};
+        check_no_diagnostics(
+            r#"
+//- /main.rs
+use core::result::Result::{self, Ok, Err};
 
-            enum SomeOtherEnum {
-                Ok(i32),
-                Err(String),
-            }
+enum SomeOtherEnum { Ok(i32), Err(String) }
 
-            fn foo() -> SomeOtherEnum {
-                0<|>
-            }
+fn foo() -> SomeOtherEnum { 0 }
 
-            //- /std/lib.rs
-            pub mod string {
-                pub struct String { }
-            }
-            pub mod result {
-                pub enum Result<T, E> { Ok(T), Err(E) }
-            }
-        "#;
-        check_no_diagnostic_for_target_file(content);
+//- /core/lib.rs
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+"#,
+        );
     }
 
     #[test]
     fn test_fill_struct_fields_empty() {
-        let before = r"
-            struct TestStruct {
-                one: i32,
-                two: i64,
-            }
+        check_fix(
+            r#"
+struct TestStruct { one: i32, two: i64 }
 
-            fn test_fn() {
-                let s = TestStruct{};
-            }
-        ";
-        let after = r"
-            struct TestStruct {
-                one: i32,
-                two: i64,
-            }
+fn test_fn() {
+    let s = TestStruct {<|>};
+}
+"#,
+            r#"
+struct TestStruct { one: i32, two: i64 }
 
-            fn test_fn() {
-                let s = TestStruct{ one: (), two: ()};
-            }
-        ";
-        check_apply_diagnostic_fix(before, after);
+fn test_fn() {
+    let s = TestStruct { one: (), two: ()};
+}
+"#,
+        );
     }
 
     #[test]
     fn test_fill_struct_fields_self() {
-        let before = r"
-            struct TestStruct {
-                one: i32,
-            }
+        check_fix(
+            r#"
+struct TestStruct { one: i32 }
 
-            impl TestStruct {
-                fn test_fn() {
-                    let s = Self {};
-                }
-            }
-        ";
-        let after = r"
-            struct TestStruct {
-                one: i32,
-            }
+impl TestStruct {
+    fn test_fn() { let s = Self {<|>}; }
+}
+"#,
+            r#"
+struct TestStruct { one: i32 }
 
-            impl TestStruct {
-                fn test_fn() {
-                    let s = Self { one: ()};
-                }
-            }
-        ";
-        check_apply_diagnostic_fix(before, after);
+impl TestStruct {
+    fn test_fn() { let s = Self { one: ()}; }
+}
+"#,
+        );
     }
 
     #[test]
     fn test_fill_struct_fields_enum() {
-        let before = r"
-            enum Expr {
-                Bin { lhs: Box<Expr>, rhs: Box<Expr> }
-            }
-
-            impl Expr {
-                fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
-                    Expr::Bin { <|> }
-                }
-            }
-
-        ";
-        let after = r"
-            enum Expr {
-                Bin { lhs: Box<Expr>, rhs: Box<Expr> }
-            }
+        check_fix(
+            r#"
+enum Expr {
+    Bin { lhs: Box<Expr>, rhs: Box<Expr> }
+}
 
-            impl Expr {
-                fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
-                    Expr::Bin { lhs: (), rhs: () <|> }
-                }
-            }
+impl Expr {
+    fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
+        Expr::Bin {<|> }
+    }
+}
+"#,
+            r#"
+enum Expr {
+    Bin { lhs: Box<Expr>, rhs: Box<Expr> }
+}
 
-        ";
-        check_apply_diagnostic_fix(before, after);
+impl Expr {
+    fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
+        Expr::Bin { lhs: (), rhs: () }
+    }
+}
+"#,
+        );
     }
 
     #[test]
     fn test_fill_struct_fields_partial() {
-        let before = r"
-            struct TestStruct {
-                one: i32,
-                two: i64,
-            }
+        check_fix(
+            r#"
+struct TestStruct { one: i32, two: i64 }
 
-            fn test_fn() {
-                let s = TestStruct{ two: 2 };
-            }
-        ";
-        let after = r"
-            struct TestStruct {
-                one: i32,
-                two: i64,
-            }
+fn test_fn() {
+    let s = TestStruct{ two: 2<|> };
+}
+"#,
+            r"
+struct TestStruct { one: i32, two: i64 }
 
-            fn test_fn() {
-                let s = TestStruct{ two: 2, one: () };
-            }
-        ";
-        check_apply_diagnostic_fix(before, after);
+fn test_fn() {
+    let s = TestStruct{ two: 2, one: () };
+}
+",
+        );
     }
 
     #[test]
     fn test_fill_struct_fields_no_diagnostic() {
-        let content = r"
-            struct TestStruct {
-                one: i32,
-                two: i64,
-            }
+        check_no_diagnostics(
+            r"
+            struct TestStruct { one: i32, two: i64 }
 
             fn test_fn() {
                 let one = 1;
                 let s = TestStruct{ one, two: 2 };
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn test_fill_struct_fields_no_diagnostic_on_spread() {
-        let content = r"
-            struct TestStruct {
-                one: i32,
-                two: i64,
-            }
+        check_no_diagnostics(
+            r"
+            struct TestStruct { one: i32, two: i64 }
 
             fn test_fn() {
                 let one = 1;
                 let s = TestStruct{ ..a };
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn test_unresolved_module_diagnostic() {
-        let (analysis, file_id) = single_file("mod foo;");
-        let diagnostics = analysis.diagnostics(file_id).unwrap();
-        assert_debug_snapshot!(diagnostics, @r###"
-        [
-            Diagnostic {
-                message: "unresolved module",
-                range: 0..8,
-                severity: Error,
-                fix: Some(
-                    Fix {
-                        label: "Create module",
-                        source_change: SourceChange {
-                            source_file_edits: [],
-                            file_system_edits: [
-                                CreateFile {
-                                    source_root: SourceRootId(
-                                        0,
-                                    ),
-                                    path: "foo.rs",
+        check_expect(
+            r#"mod foo;"#,
+            expect![[r#"
+                [
+                    Diagnostic {
+                        message: "unresolved module",
+                        range: 0..8,
+                        severity: Error,
+                        fix: Some(
+                            Fix {
+                                label: "Create module",
+                                source_change: SourceChange {
+                                    source_file_edits: [],
+                                    file_system_edits: [
+                                        CreateFile {
+                                            anchor: FileId(
+                                                1,
+                                            ),
+                                            dst: "foo.rs",
+                                        },
+                                    ],
+                                    is_snippet: false,
                                 },
-                            ],
-                            is_snippet: false,
-                        },
+                            },
+                        ),
                     },
-                ),
-            },
-        ]
-        "###);
+                ]
+            "#]],
+        );
     }
 
     #[test]
     fn range_mapping_out_of_macros() {
-        let (analysis, file_id) = single_file(
-            r"
-            fn some() {}
-            fn items() {}
-            fn here() {}
+        // FIXME: this is very wrong, but somewhat tricky to fix.
+        check_fix(
+            r#"
+fn some() {}
+fn items() {}
+fn here() {}
 
-            macro_rules! id {
-                ($($tt:tt)*) => { $($tt)*};
-            }
+macro_rules! id { ($($tt:tt)*) => { $($tt)*}; }
 
-            fn main() {
-                let _x = id![Foo { a: 42 }];
-            }
+fn main() {
+    let _x = id![Foo { a: <|>42 }];
+}
 
-            pub struct Foo {
-                pub a: i32,
-                pub b: i32,
-            }
-        ",
+pub struct Foo { pub a: i32, pub b: i32 }
+"#,
+            r#"
+fn {a:42, b: ()} {}
+fn items() {}
+fn here() {}
+
+macro_rules! id { ($($tt:tt)*) => { $($tt)*}; }
+
+fn main() {
+    let _x = id![Foo { a: 42 }];
+}
+
+pub struct Foo { pub a: i32, pub b: i32 }
+"#,
         );
-        let diagnostics = analysis.diagnostics(file_id).unwrap();
-        assert_debug_snapshot!(diagnostics, @r###"
-        [
-            Diagnostic {
-                message: "Missing structure fields:\n- b\n",
-                range: 224..233,
-                severity: Error,
-                fix: Some(
-                    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: [],
-                            is_snippet: false,
-                        },
-                    },
-                ),
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn test_check_unnecessary_braces_in_use_statement() {
-        check_not_applicable(
-            "
-            use a;
-            use a::{c, d::e};
-        ",
-            check_unnecessary_braces_in_use_statement,
-        );
-        check_apply("use {b};", "use b;", check_unnecessary_braces_in_use_statement);
-        check_apply("use a::{c};", "use a::c;", check_unnecessary_braces_in_use_statement);
-        check_apply("use a::{self};", "use a;", check_unnecessary_braces_in_use_statement);
-        check_apply(
-            "use a::{c, d::{e}};",
-            "use a::{c, d::e};",
-            check_unnecessary_braces_in_use_statement,
+        check_no_diagnostics(
+            r#"
+use a;
+use a::{c, d::e};
+"#,
         );
+        check_fix(r#"use {<|>b};"#, r#"use b;"#);
+        check_fix(r#"use {b<|>};"#, r#"use b;"#);
+        check_fix(r#"use a::{c<|>};"#, r#"use a::c;"#);
+        check_fix(r#"use a::{self<|>};"#, r#"use a;"#);
+        check_fix(r#"use a::{c, d::{e<|>}};"#, r#"use a::{c, d::e};"#);
     }
 
     #[test]
     fn test_check_struct_shorthand_initialization() {
-        check_not_applicable(
+        check_no_diagnostics(
             r#"
-            struct A {
-                a: &'static str
-            }
-
-            fn main() {
-                A {
-                    a: "hello"
-                }
-            }
-        "#,
-            check_struct_shorthand_initialization,
+struct A { a: &'static str }
+fn main() { A { a: "hello" } }
+"#,
         );
-
-        check_apply(
+        check_no_diagnostics(
             r#"
-struct A {
-    a: &'static str
-}
+struct A(usize);
+fn main() { A { 0: 0 } }
+"#,
+        );
 
+        check_fix(
+            r#"
+struct A { a: &'static str }
 fn main() {
     let a = "haha";
-    A {
-        a: a
-    }
+    A { a<|>: a }
 }
-        "#,
+"#,
             r#"
-struct A {
-    a: &'static str
-}
-
+struct A { a: &'static str }
 fn main() {
     let a = "haha";
-    A {
-        a
-    }
+    A { a }
 }
-        "#,
-            check_struct_shorthand_initialization,
+"#,
         );
 
-        check_apply(
+        check_fix(
             r#"
-struct A {
-    a: &'static str,
-    b: &'static str
-}
-
+struct A { a: &'static str, b: &'static str }
 fn main() {
     let a = "haha";
     let b = "bb";
-    A {
-        a: a,
-        b
-    }
+    A { a<|>: a, b }
 }
-        "#,
+"#,
             r#"
-struct A {
-    a: &'static str,
-    b: &'static str
-}
-
+struct A { a: &'static str, b: &'static str }
 fn main() {
     let a = "haha";
     let b = "bb";
-    A {
-        a,
-        b
-    }
+    A { a, b }
 }
-        "#,
-            check_struct_shorthand_initialization,
+"#,
         );
     }
+
+    #[test]
+    fn test_add_field_from_usage() {
+        check_fix(
+            r"
+fn main() {
+    Foo { bar: 3, baz<|>: false};
+}
+struct Foo {
+    bar: i32
+}
+",
+            r"
+fn main() {
+    Foo { bar: 3, baz: false};
+}
+struct Foo {
+    bar: i32,
+    baz: bool
+}
+",
+        )
+    }
+
+    #[test]
+    fn test_add_field_in_other_file_from_usage() {
+        check_apply_diagnostic_fix_in_other_file(
+            r"
+            //- /main.rs
+            mod foo;
+
+            fn main() {
+                <|>foo::Foo { bar: 3, baz: false};
+            }
+            //- /foo.rs
+            struct Foo {
+                bar: i32
+            }
+            ",
+            r"
+            struct Foo {
+                bar: i32,
+                pub(crate) baz: bool
+            }
+            ",
+        )
+    }
 }
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index 827c094e7..70d2a2dd1 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -6,13 +6,10 @@ mod navigation_target;
 mod structure;
 mod short_label;
 
-use std::fmt::Display;
-
 use ra_syntax::{
     ast::{self, AstNode, AttrsOwner, NameOwner, TypeParamsOwner},
     SyntaxKind::{ATTR, COMMENT},
 };
-use stdx::format_to;
 
 pub use function_signature::FunctionSignature;
 pub use navigation_target::NavigationTarget;
@@ -69,29 +66,3 @@ pub(crate) fn macro_label(node: &ast::MacroCall) -> String {
     let vis = if node.has_atom_attr("macro_export") { "#[macro_export]\n" } else { "" };
     format!("{}macro_rules! {}", vis, name)
 }
-
-pub(crate) fn rust_code_markup(code: &impl Display) -> String {
-    rust_code_markup_with_doc(code, None, None)
-}
-
-pub(crate) fn rust_code_markup_with_doc(
-    code: &impl Display,
-    doc: Option<&str>,
-    mod_path: Option<&str>,
-) -> String {
-    let mut buf = String::new();
-
-    if let Some(mod_path) = mod_path {
-        if !mod_path.is_empty() {
-            format_to!(buf, "```rust\n{}\n```\n\n", mod_path);
-        }
-    }
-    format_to!(buf, "```rust\n{}\n```", code);
-
-    if let Some(doc) = doc {
-        format_to!(buf, "\n___");
-        format_to!(buf, "\n\n{}", doc);
-    }
-
-    buf
-}
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index 9572debd8..1d39544d3 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -10,7 +10,7 @@ use std::{
 use hir::{Docs, Documentation, HasSource, HirDisplay};
 use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, AstNode, NameOwner, VisibilityOwner};
-use stdx::SepBy;
+use stdx::{split_delim, SepBy};
 
 use crate::display::{generic_parameters, where_predicates};
 
@@ -61,15 +61,11 @@ pub struct FunctionQualifier {
 }
 
 impl FunctionSignature {
-    pub(crate) fn with_doc_opt(mut self, doc: Option<Documentation>) -> Self {
-        self.doc = doc;
-        self
-    }
-
     pub(crate) fn from_hir(db: &RootDatabase, function: hir::Function) -> Self {
-        let doc = function.docs(db);
         let ast_node = function.source(db).value;
-        FunctionSignature::from(&ast_node).with_doc_opt(doc)
+        let mut res = FunctionSignature::from(&ast_node);
+        res.doc = function.docs(db);
+        res
     }
 
     pub(crate) fn from_struct(db: &RootDatabase, st: hir::Struct) -> Option<Self> {
@@ -93,24 +89,21 @@ impl FunctionSignature {
             params.push(raw_param);
         }
 
-        Some(
-            FunctionSignature {
-                kind: CallableKind::StructConstructor,
-                visibility: node.visibility().map(|n| n.syntax().text().to_string()),
-                // Do we need `const`?
-                qualifier: Default::default(),
-                name: node.name().map(|n| n.text().to_string()),
-                ret_type: node.name().map(|n| n.text().to_string()),
-                parameters: params,
-                parameter_names: vec![],
-                parameter_types,
-                generic_parameters: generic_parameters(&node),
-                where_predicates: where_predicates(&node),
-                doc: None,
-                has_self_param: false,
-            }
-            .with_doc_opt(st.docs(db)),
-        )
+        Some(FunctionSignature {
+            kind: CallableKind::StructConstructor,
+            visibility: node.visibility().map(|n| n.syntax().text().to_string()),
+            // Do we need `const`?
+            qualifier: Default::default(),
+            name: node.name().map(|n| n.text().to_string()),
+            ret_type: node.name().map(|n| n.text().to_string()),
+            parameters: params,
+            parameter_names: vec![],
+            parameter_types,
+            generic_parameters: generic_parameters(&node),
+            where_predicates: where_predicates(&node),
+            doc: st.docs(db),
+            has_self_param: false,
+        })
     }
 
     pub(crate) fn from_enum_variant(db: &RootDatabase, variant: hir::EnumVariant) -> Option<Self> {
@@ -140,24 +133,21 @@ impl FunctionSignature {
             params.push(format!("{}: {}", name, ty.display(db)));
         }
 
-        Some(
-            FunctionSignature {
-                kind: CallableKind::VariantConstructor,
-                visibility: None,
-                // Do we need `const`?
-                qualifier: Default::default(),
-                name: Some(name),
-                ret_type: None,
-                parameters: params,
-                parameter_names: vec![],
-                parameter_types,
-                generic_parameters: vec![],
-                where_predicates: vec![],
-                doc: None,
-                has_self_param: false,
-            }
-            .with_doc_opt(variant.docs(db)),
-        )
+        Some(FunctionSignature {
+            kind: CallableKind::VariantConstructor,
+            visibility: None,
+            // Do we need `const`?
+            qualifier: Default::default(),
+            name: Some(name),
+            ret_type: None,
+            parameters: params,
+            parameter_names: vec![],
+            parameter_types,
+            generic_parameters: vec![],
+            where_predicates: vec![],
+            doc: variant.docs(db),
+            has_self_param: false,
+        })
     }
 
     pub(crate) fn from_macro(db: &RootDatabase, macro_def: hir::MacroDef) -> Option<Self> {
@@ -165,23 +155,20 @@ impl FunctionSignature {
 
         let params = vec![];
 
-        Some(
-            FunctionSignature {
-                kind: CallableKind::Macro,
-                visibility: None,
-                qualifier: Default::default(),
-                name: node.name().map(|n| n.text().to_string()),
-                ret_type: None,
-                parameters: params,
-                parameter_names: vec![],
-                parameter_types: vec![],
-                generic_parameters: vec![],
-                where_predicates: vec![],
-                doc: None,
-                has_self_param: false,
-            }
-            .with_doc_opt(macro_def.docs(db)),
-        )
+        Some(FunctionSignature {
+            kind: CallableKind::Macro,
+            visibility: None,
+            qualifier: Default::default(),
+            name: node.name().map(|n| n.text().to_string()),
+            ret_type: None,
+            parameters: params,
+            parameter_names: vec![],
+            parameter_types: vec![],
+            generic_parameters: vec![],
+            where_predicates: vec![],
+            doc: macro_def.docs(db),
+            has_self_param: false,
+        })
     }
 }
 
@@ -207,7 +194,16 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
                     res.push(raw_param);
                 }
 
-                res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
+                // macro-generated functions are missing whitespace
+                fn fmt_param(param: ast::Param) -> String {
+                    let text = param.syntax().text().to_string();
+                    match split_delim(&text, ':') {
+                        Some((left, right)) => format!("{}: {}", left.trim(), right.trim()),
+                        _ => text,
+                    }
+                }
+
+                res.extend(param_list.params().map(fmt_param));
                 res_types.extend(param_list.params().map(|param| {
                     let param_text = param.syntax().text().to_string();
                     match param_text.split(':').nth(1).and_then(|it| it.get(1..)) {
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 5da28edd2..8bf2428ed 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::{FileRange, FileSymbol};
+use crate::FileSymbol;
 
 use super::short_label::ShortLabel;
 
@@ -47,6 +47,19 @@ impl NavigationTarget {
     pub fn range(&self) -> TextRange {
         self.focus_range.unwrap_or(self.full_range)
     }
+    /// A "most interesting" range withing the `full_range`.
+    ///
+    /// Typically, `full_range` is the whole syntax node,
+    /// including doc comments, and `focus_range` is the range of the identifier.
+    pub fn focus_range(&self) -> Option<TextRange> {
+        self.focus_range
+    }
+    pub fn full_range(&self) -> TextRange {
+        self.full_range
+    }
+    pub fn file_id(&self) -> FileId {
+        self.file_id
+    }
 
     pub fn name(&self) -> &SmolStr {
         &self.name
@@ -60,18 +73,6 @@ impl NavigationTarget {
         self.kind
     }
 
-    pub fn file_id(&self) -> FileId {
-        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
-    }
-
     pub fn docs(&self) -> Option<&str> {
         self.docs.as_deref()
     }
@@ -80,27 +81,20 @@ impl NavigationTarget {
         self.description.as_deref()
     }
 
-    /// A "most interesting" range withing the `full_range`.
-    ///
-    /// Typically, `full_range` is the whole syntax node,
-    /// including doc comments, and `focus_range` is the range of the identifier.
-    pub fn focus_range(&self) -> Option<TextRange> {
-        self.focus_range
-    }
-
     pub(crate) fn from_module_to_decl(db: &RootDatabase, module: hir::Module) -> 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)
     }
@@ -130,14 +124,12 @@ 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();
+        let name =
+            node.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
         let focus_range =
             node.value.name().map(|it| original_range(db, node.with_value(it.syntax())).range);
         let frange = original_range(db, node.map(|it| it.syntax()));
@@ -148,8 +140,25 @@ impl NavigationTarget {
             focus_range,
             frange.range,
             node.value.syntax().kind(),
-            docs,
-            description,
+        )
+    }
+
+    /// Allows `NavigationTarget` to be created from a `DocCommentsOwner` and a `NameOwner`
+    pub(crate) fn from_doc_commented(
+        db: &RootDatabase,
+        named: InFile<&dyn ast::NameOwner>,
+        node: InFile<&dyn ast::DocCommentsOwner>,
+    ) -> NavigationTarget {
+        let name =
+            named.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
+        let frange = original_range(db, node.map(|it| it.syntax()));
+
+        NavigationTarget::from_syntax(
+            frange.file_id,
+            name,
+            None,
+            frange.range,
+            node.value.syntax().kind(),
         )
     }
 
@@ -159,8 +168,6 @@ impl NavigationTarget {
         focus_range: Option<TextRange>,
         full_range: TextRange,
         kind: SyntaxKind,
-        docs: Option<String>,
-        description: Option<String>,
     ) -> NavigationTarget {
         NavigationTarget {
             file_id,
@@ -169,8 +176,8 @@ impl NavigationTarget {
             full_range,
             focus_range,
             container_name: None,
-            description,
-            docs,
+            description: None,
+            docs: None,
         }
     }
 }
@@ -238,12 +245,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
     }
 }
 
@@ -258,35 +264,31 @@ 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())
     }
 }
 
 impl ToNav for hir::ImplDef {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
-        let frange = if let Some(item) = self.is_builtin_derive(db) {
+        let derive_attr = self.is_builtin_derive(db);
+        let frange = if let Some(item) = &derive_attr {
             original_range(db, item.syntax())
         } else {
             original_range(db, src.as_ref().map(|it| it.syntax()))
         };
+        let focus_range = if derive_attr.is_some() {
+            None
+        } else {
+            src.value.target_type().map(|ty| original_range(db, src.with_value(ty.syntax())).range)
+        };
 
         NavigationTarget::from_syntax(
             frange.file_id,
             "impl".into(),
-            None,
+            focus_range,
             frange.range,
             src.value.syntax().kind(),
-            None,
-            None,
         )
     }
 }
@@ -296,12 +298,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(
@@ -310,8 +312,6 @@ impl ToNav for hir::Field {
                     None,
                     frange.range,
                     it.syntax().kind(),
-                    None,
-                    None,
                 )
             }
         }
@@ -322,12 +322,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
     }
 }
 
diff --git a/crates/ra_ide/src/display/structure.rs b/crates/ra_ide/src/display/structure.rs
index aad5a8e4d..1f6a3febf 100644
--- a/crates/ra_ide/src/display/structure.rs
+++ b/crates/ra_ide/src/display/structure.rs
@@ -127,6 +127,7 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
                 decl_with_detail(it, Some(detail))
             },
             ast::StructDef(it) => decl(it),
+            ast::UnionDef(it) => decl(it),
             ast::EnumDef(it) => decl(it),
             ast::EnumVariant(it) => decl(it),
             ast::TraitDef(it) => decl(it),
@@ -173,12 +174,19 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
 
 #[cfg(test)]
 mod tests {
+    use expect::{expect, Expect};
+
     use super::*;
-    use insta::assert_debug_snapshot;
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let file = SourceFile::parse(ra_fixture).ok().unwrap();
+        let structure = file_structure(&file);
+        expect.assert_debug_eq(&structure)
+    }
 
     #[test]
     fn test_file_structure() {
-        let file = SourceFile::parse(
+        check(
             r#"
 struct Foo {
     x: i32
@@ -223,216 +231,211 @@ fn obsolete() {}
 #[deprecated(note = "for awhile")]
 fn very_obsolete() {}
 "#,
-        )
-        .ok()
-        .unwrap();
-        let structure = file_structure(&file);
-        assert_debug_snapshot!(structure,
-        @r###"
-        [
-            StructureNode {
-                parent: None,
-                label: "Foo",
-                navigation_range: 8..11,
-                node_range: 1..26,
-                kind: STRUCT_DEF,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: Some(
-                    0,
-                ),
-                label: "x",
-                navigation_range: 18..19,
-                node_range: 18..24,
-                kind: RECORD_FIELD_DEF,
-                detail: Some(
-                    "i32",
-                ),
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "m",
-                navigation_range: 32..33,
-                node_range: 28..158,
-                kind: MODULE,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: Some(
-                    2,
-                ),
-                label: "bar1",
-                navigation_range: 43..47,
-                node_range: 40..52,
-                kind: FN_DEF,
-                detail: Some(
-                    "fn()",
-                ),
-                deprecated: false,
-            },
-            StructureNode {
-                parent: Some(
-                    2,
-                ),
-                label: "bar2",
-                navigation_range: 60..64,
-                node_range: 57..81,
-                kind: FN_DEF,
-                detail: Some(
-                    "fn<T>(t: T) -> T",
-                ),
-                deprecated: false,
-            },
-            StructureNode {
-                parent: Some(
-                    2,
-                ),
-                label: "bar3",
-                navigation_range: 89..93,
-                node_range: 86..156,
-                kind: FN_DEF,
-                detail: Some(
-                    "fn<A, B>(a: A, b: B) -> Vec< u32 >",
-                ),
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "E",
-                navigation_range: 165..166,
-                node_range: 160..180,
-                kind: ENUM_DEF,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: Some(
-                    6,
-                ),
-                label: "X",
-                navigation_range: 169..170,
-                node_range: 169..170,
-                kind: ENUM_VARIANT,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: Some(
-                    6,
-                ),
-                label: "Y",
-                navigation_range: 172..173,
-                node_range: 172..178,
-                kind: ENUM_VARIANT,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "T",
-                navigation_range: 186..187,
-                node_range: 181..193,
-                kind: TYPE_ALIAS_DEF,
-                detail: Some(
-                    "()",
-                ),
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "S",
-                navigation_range: 201..202,
-                node_range: 194..213,
-                kind: STATIC_DEF,
-                detail: Some(
-                    "i32",
-                ),
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "C",
-                navigation_range: 220..221,
-                node_range: 214..232,
-                kind: CONST_DEF,
-                detail: Some(
-                    "i32",
-                ),
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "impl E",
-                navigation_range: 239..240,
-                node_range: 234..243,
-                kind: IMPL_DEF,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "impl fmt::Debug for E",
-                navigation_range: 265..266,
-                node_range: 245..269,
-                kind: IMPL_DEF,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "mc",
-                navigation_range: 284..286,
-                node_range: 271..303,
-                kind: MACRO_CALL,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "mcexp",
-                navigation_range: 334..339,
-                node_range: 305..356,
-                kind: MACRO_CALL,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "mcexp",
-                navigation_range: 387..392,
-                node_range: 358..409,
-                kind: MACRO_CALL,
-                detail: None,
-                deprecated: false,
-            },
-            StructureNode {
-                parent: None,
-                label: "obsolete",
-                navigation_range: 428..436,
-                node_range: 411..441,
-                kind: FN_DEF,
-                detail: Some(
-                    "fn()",
-                ),
-                deprecated: true,
-            },
-            StructureNode {
-                parent: None,
-                label: "very_obsolete",
-                navigation_range: 481..494,
-                node_range: 443..499,
-                kind: FN_DEF,
-                detail: Some(
-                    "fn()",
-                ),
-                deprecated: true,
-            },
-        ]
-        "###
-                );
+            expect![[r#"
+                [
+                    StructureNode {
+                        parent: None,
+                        label: "Foo",
+                        navigation_range: 8..11,
+                        node_range: 1..26,
+                        kind: STRUCT_DEF,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            0,
+                        ),
+                        label: "x",
+                        navigation_range: 18..19,
+                        node_range: 18..24,
+                        kind: RECORD_FIELD_DEF,
+                        detail: Some(
+                            "i32",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "m",
+                        navigation_range: 32..33,
+                        node_range: 28..158,
+                        kind: MODULE,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            2,
+                        ),
+                        label: "bar1",
+                        navigation_range: 43..47,
+                        node_range: 40..52,
+                        kind: FN_DEF,
+                        detail: Some(
+                            "fn()",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            2,
+                        ),
+                        label: "bar2",
+                        navigation_range: 60..64,
+                        node_range: 57..81,
+                        kind: FN_DEF,
+                        detail: Some(
+                            "fn<T>(t: T) -> T",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            2,
+                        ),
+                        label: "bar3",
+                        navigation_range: 89..93,
+                        node_range: 86..156,
+                        kind: FN_DEF,
+                        detail: Some(
+                            "fn<A, B>(a: A, b: B) -> Vec< u32 >",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "E",
+                        navigation_range: 165..166,
+                        node_range: 160..180,
+                        kind: ENUM_DEF,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            6,
+                        ),
+                        label: "X",
+                        navigation_range: 169..170,
+                        node_range: 169..170,
+                        kind: ENUM_VARIANT,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            6,
+                        ),
+                        label: "Y",
+                        navigation_range: 172..173,
+                        node_range: 172..178,
+                        kind: ENUM_VARIANT,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "T",
+                        navigation_range: 186..187,
+                        node_range: 181..193,
+                        kind: TYPE_ALIAS_DEF,
+                        detail: Some(
+                            "()",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "S",
+                        navigation_range: 201..202,
+                        node_range: 194..213,
+                        kind: STATIC_DEF,
+                        detail: Some(
+                            "i32",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "C",
+                        navigation_range: 220..221,
+                        node_range: 214..232,
+                        kind: CONST_DEF,
+                        detail: Some(
+                            "i32",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "impl E",
+                        navigation_range: 239..240,
+                        node_range: 234..243,
+                        kind: IMPL_DEF,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "impl fmt::Debug for E",
+                        navigation_range: 265..266,
+                        node_range: 245..269,
+                        kind: IMPL_DEF,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "mc",
+                        navigation_range: 284..286,
+                        node_range: 271..303,
+                        kind: MACRO_CALL,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "mcexp",
+                        navigation_range: 334..339,
+                        node_range: 305..356,
+                        kind: MACRO_CALL,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "mcexp",
+                        navigation_range: 387..392,
+                        node_range: 358..409,
+                        kind: MACRO_CALL,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "obsolete",
+                        navigation_range: 428..436,
+                        node_range: 411..441,
+                        kind: FN_DEF,
+                        detail: Some(
+                            "fn()",
+                        ),
+                        deprecated: true,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "very_obsolete",
+                        navigation_range: 481..494,
+                        node_range: 443..499,
+                        kind: FN_DEF,
+                        detail: Some(
+                            "fn()",
+                        ),
+                        deprecated: true,
+                    },
+                ]
+            "#]],
+        );
     }
 }
diff --git a/crates/ra_ide/src/expand_macro.rs b/crates/ra_ide/src/expand_macro.rs
index 54a47aac0..043515f54 100644
--- a/crates/ra_ide/src/expand_macro.rs
+++ b/crates/ra_ide/src/expand_macro.rs
@@ -2,7 +2,9 @@ use hir::Semantics;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::{find_node_at_offset, SyntaxRewriter},
-    ast, AstNode, NodeOrToken, SyntaxKind, SyntaxNode, WalkEvent, T,
+    ast, AstNode, NodeOrToken, SyntaxKind,
+    SyntaxKind::*,
+    SyntaxNode, WalkEvent, T,
 };
 
 use crate::FilePosition;
@@ -65,8 +67,6 @@ fn expand_macro_recur(
 // FIXME: It would also be cool to share logic here and in the mbe tests,
 // which are pretty unreadable at the moment.
 fn insert_whitespaces(syn: SyntaxNode) -> String {
-    use SyntaxKind::*;
-
     let mut res = String::new();
     let mut token_iter = syn
         .preorder_with_tokens()
@@ -120,175 +120,164 @@ fn insert_whitespaces(syn: SyntaxNode) -> String {
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_snapshot;
+    use expect::{expect, Expect};
 
     use crate::mock_analysis::analysis_and_position;
 
-    use super::*;
-
-    fn check_expand_macro(fixture: &str) -> ExpandedMacro {
-        let (analysis, pos) = analysis_and_position(fixture);
-        analysis.expand_macro(pos).unwrap().unwrap()
+    fn check(ra_fixture: &str, expect: Expect) {
+        let (analysis, pos) = analysis_and_position(ra_fixture);
+        let expansion = analysis.expand_macro(pos).unwrap().unwrap();
+        let actual = format!("{}\n{}", expansion.name, expansion.expansion);
+        expect.assert_eq(&actual);
     }
 
     #[test]
     fn macro_expand_recursive_expansion() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
-        macro_rules! bar {
-            () => { fn  b() {} }
-        }
-        macro_rules! foo {
-            () => { bar!(); }
-        }
-        macro_rules! baz {
-            () => { foo!(); }
-        }
-        f<|>oo!();
-        "#,
+macro_rules! bar {
+    () => { fn  b() {} }
+}
+macro_rules! foo {
+    () => { bar!(); }
+}
+macro_rules! baz {
+    () => { foo!(); }
+}
+f<|>oo!();
+"#,
+            expect![[r#"
+                foo
+                fn b(){}
+            "#]],
         );
-
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###"
-fn b(){}
-"###);
     }
 
     #[test]
     fn macro_expand_multiple_lines() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
-        macro_rules! foo {
-            () => {
-                fn some_thing() -> u32 {
-                    let a = 0;
-                    a + 10
-                }
-            }
+macro_rules! foo {
+    () => {
+        fn some_thing() -> u32 {
+            let a = 0;
+            a + 10
         }
-        f<|>oo!();
+    }
+}
+f<|>oo!();
         "#,
+            expect![[r#"
+            foo
+            fn some_thing() -> u32 {
+              let a = 0;
+              a+10
+            }"#]],
         );
-
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###"
-fn some_thing() -> u32 {
-  let a = 0;
-  a+10
-}
-"###);
     }
 
     #[test]
     fn macro_expand_match_ast() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
-        macro_rules! match_ast {
-            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+macro_rules! match_ast {
+    (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+    (match ($node:expr) {
+        $( ast::$ast:ident($it:ident) => $res:block, )*
+        _ => $catch_all:expr $(,)?
+    }) => {{
+        $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
+        { $catch_all }
+    }};
+}
 
-            (match ($node:expr) {
-                $( ast::$ast:ident($it:ident) => $res:block, )*
-                _ => $catch_all:expr $(,)?
-            }) => {{
-                $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
-                { $catch_all }
-            }};
+fn main() {
+    mat<|>ch_ast! {
+        match container {
+            ast::TraitDef(it) => {},
+            ast::ImplDef(it) => {},
+            _ => { continue },
         }
-
-        fn main() {
-            mat<|>ch_ast! {
-                match container {
-                    ast::TraitDef(it) => {},
-                    ast::ImplDef(it) => {},
-                    _ => { continue },
-                }
-            }
-        }
-        "#,
-        );
-
-        assert_eq!(res.name, "match_ast");
-        assert_snapshot!(res.expansion, @r###"
-{
-  if let Some(it) = ast::TraitDef::cast(container.clone()){}
-  else if let Some(it) = ast::ImplDef::cast(container.clone()){}
-  else {
-    {
-      continue
     }
-  }
 }
-"###);
+"#,
+            expect![[r#"
+       match_ast
+       {
+         if let Some(it) = ast::TraitDef::cast(container.clone()){}
+         else if let Some(it) = ast::ImplDef::cast(container.clone()){}
+         else {
+           {
+             continue
+           }
+         }
+       }"#]],
+        );
     }
 
     #[test]
     fn macro_expand_match_ast_inside_let_statement() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
-        macro_rules! match_ast {
-            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
-            (match ($node:expr) {}) => {{}};
-        }
+macro_rules! match_ast {
+    (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+    (match ($node:expr) {}) => {{}};
+}
 
-        fn main() {
-            let p = f(|it| {
-                let res = mat<|>ch_ast! { match c {}};
-                Some(res)
-            })?;
-        }
-        "#,
+fn main() {
+    let p = f(|it| {
+        let res = mat<|>ch_ast! { match c {}};
+        Some(res)
+    })?;
+}
+"#,
+            expect![[r#"
+                match_ast
+                {}
+            "#]],
         );
-
-        assert_eq!(res.name, "match_ast");
-        assert_snapshot!(res.expansion, @r###"{}"###);
     }
 
     #[test]
     fn macro_expand_inner_macro_fail_to_expand() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
-        macro_rules! bar {
-            (BAD) => {};
-        }
-        macro_rules! foo {
-            () => {bar!()};
-        }
+macro_rules! bar {
+    (BAD) => {};
+}
+macro_rules! foo {
+    () => {bar!()};
+}
 
-        fn main() {
-            let res = fo<|>o!();
-        }
-        "#,
+fn main() {
+    let res = fo<|>o!();
+}
+"#,
+            expect![[r#"
+                foo
+            "#]],
         );
-
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###""###);
     }
 
     #[test]
     fn macro_expand_with_dollar_crate() {
-        let res = check_expand_macro(
+        check(
             r#"
-        //- /lib.rs
-        #[macro_export]
-        macro_rules! bar {
-            () => {0};
-        }
-        macro_rules! foo {
-            () => {$crate::bar!()};
-        }
+#[macro_export]
+macro_rules! bar {
+    () => {0};
+}
+macro_rules! foo {
+    () => {$crate::bar!()};
+}
 
-        fn main() {
-            let res = fo<|>o!();
-        }
-        "#,
+fn main() {
+    let res = fo<|>o!();
+}
+"#,
+            expect![[r#"
+                foo
+                0 "#]],
         );
-
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###"0"###);
     }
 }
diff --git a/crates/ra_ide/src/extend_selection.rs b/crates/ra_ide/src/extend_selection.rs
index a4bc93cdb..8a6b3ea99 100644
--- a/crates/ra_ide/src/extend_selection.rs
+++ b/crates/ra_ide/src/extend_selection.rs
@@ -315,17 +315,15 @@ fn adj_comments(comment: &ast::Comment, dir: Direction) -> ast::Comment {
 
 #[cfg(test)]
 mod tests {
-    use test_utils::extract_offset;
-
-    use crate::mock_analysis::single_file;
+    use crate::mock_analysis::analysis_and_position;
 
     use super::*;
 
     fn do_check(before: &str, afters: &[&str]) {
-        let (cursor, before) = extract_offset(before);
-        let (analysis, file_id) = single_file(&before);
-        let range = TextRange::empty(cursor);
-        let mut frange = FileRange { file_id, range };
+        let (analysis, position) = analysis_and_position(&before);
+        let before = analysis.file_text(position.file_id).unwrap();
+        let range = TextRange::empty(position.offset);
+        let mut frange = FileRange { file_id: position.file_id, range };
 
         for &after in afters {
             frange.range = analysis.extend_selection(frange).unwrap();
diff --git a/crates/ra_ide/src/folding_ranges.rs b/crates/ra_ide/src/folding_ranges.rs
index 8657377de..e7ec9953f 100644
--- a/crates/ra_ide/src/folding_ranges.rs
+++ b/crates/ra_ide/src/folding_ranges.rs
@@ -15,6 +15,7 @@ pub enum FoldKind {
     Imports,
     Mods,
     Block,
+    ArgList,
 }
 
 #[derive(Debug)]
@@ -83,8 +84,10 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
     match kind {
         COMMENT => Some(FoldKind::Comment),
         USE_ITEM => Some(FoldKind::Imports),
+        ARG_LIST => Some(FoldKind::ArgList),
         RECORD_FIELD_DEF_LIST
         | RECORD_FIELD_PAT_LIST
+        | RECORD_FIELD_LIST
         | ITEM_LIST
         | EXTERN_ITEM_LIST
         | USE_TREE_LIST
@@ -196,89 +199,85 @@ fn contiguous_range_for_comment(
 
 #[cfg(test)]
 mod tests {
+    use test_utils::extract_tags;
+
     use super::*;
-    use test_utils::extract_ranges;
 
-    fn do_check(text: &str, fold_kinds: &[FoldKind]) {
-        let (ranges, text) = extract_ranges(text, "fold");
+    fn check(ra_fixture: &str) {
+        let (ranges, text) = extract_tags(ra_fixture, "fold");
+
         let parse = SourceFile::parse(&text);
         let folds = folding_ranges(&parse.tree());
-
         assert_eq!(
             folds.len(),
             ranges.len(),
             "The amount of folds is different than the expected amount"
         );
-        assert_eq!(
-            folds.len(),
-            fold_kinds.len(),
-            "The amount of fold kinds is different than the expected amount"
-        );
-        for ((fold, range), fold_kind) in
-            folds.iter().zip(ranges.into_iter()).zip(fold_kinds.iter())
-        {
+
+        for (fold, (range, attr)) in folds.iter().zip(ranges.into_iter()) {
             assert_eq!(fold.range.start(), range.start());
             assert_eq!(fold.range.end(), range.end());
-            assert_eq!(&fold.kind, fold_kind);
+
+            let kind = match fold.kind {
+                FoldKind::Comment => "comment",
+                FoldKind::Imports => "imports",
+                FoldKind::Mods => "mods",
+                FoldKind::Block => "block",
+                FoldKind::ArgList => "arglist",
+            };
+            assert_eq!(kind, &attr.unwrap());
         }
     }
 
     #[test]
     fn test_fold_comments() {
-        let text = r#"
-<fold>// Hello
+        check(
+            r#"
+<fold comment>// Hello
 // this is a multiline
 // comment
 //</fold>
 
 // But this is not
 
-fn main() <fold>{
-    <fold>// We should
+fn main() <fold block>{
+    <fold comment>// We should
     // also
     // fold
     // this one.</fold>
-    <fold>//! But this one is different
+    <fold comment>//! But this one is different
     //! because it has another flavor</fold>
-    <fold>/* As does this
+    <fold comment>/* As does this
     multiline comment */</fold>
-}</fold>"#;
-
-        let fold_kinds = &[
-            FoldKind::Comment,
-            FoldKind::Block,
-            FoldKind::Comment,
-            FoldKind::Comment,
-            FoldKind::Comment,
-        ];
-        do_check(text, fold_kinds);
+}</fold>"#,
+        );
     }
 
     #[test]
     fn test_fold_imports() {
-        let text = r#"
-<fold>use std::<fold>{
+        check(
+            r#"
+<fold imports>use std::<fold block>{
     str,
     vec,
     io as iop
 }</fold>;</fold>
 
-fn main() <fold>{
-}</fold>"#;
-
-        let folds = &[FoldKind::Imports, FoldKind::Block, FoldKind::Block];
-        do_check(text, folds);
+fn main() <fold block>{
+}</fold>"#,
+        );
     }
 
     #[test]
     fn test_fold_mods() {
-        let text = r#"
+        check(
+            r#"
 
 pub mod foo;
-<fold>mod after_pub;
+<fold mods>mod after_pub;
 mod after_pub_next;</fold>
 
-<fold>mod before_pub;
+<fold mods>mod before_pub;
 mod before_pub_next;</fold>
 pub mod bar;
 
@@ -286,90 +285,105 @@ mod not_folding_single;
 pub mod foobar;
 pub not_folding_single_next;
 
-<fold>#[cfg(test)]
+<fold mods>#[cfg(test)]
 mod with_attribute;
 mod with_attribute_next;</fold>
 
-fn main() <fold>{
-}</fold>"#;
-
-        let folds = &[FoldKind::Mods, FoldKind::Mods, FoldKind::Mods, FoldKind::Block];
-        do_check(text, folds);
+fn main() <fold block>{
+}</fold>"#,
+        );
     }
 
     #[test]
     fn test_fold_import_groups() {
-        let text = r#"
-<fold>use std::str;
+        check(
+            r#"
+<fold imports>use std::str;
 use std::vec;
 use std::io as iop;</fold>
 
-<fold>use std::mem;
+<fold imports>use std::mem;
 use std::f64;</fold>
 
 use std::collections::HashMap;
 // Some random comment
 use std::collections::VecDeque;
 
-fn main() <fold>{
-}</fold>"#;
-
-        let folds = &[FoldKind::Imports, FoldKind::Imports, FoldKind::Block];
-        do_check(text, folds);
+fn main() <fold block>{
+}</fold>"#,
+        );
     }
 
     #[test]
     fn test_fold_import_and_groups() {
-        let text = r#"
-<fold>use std::str;
+        check(
+            r#"
+<fold imports>use std::str;
 use std::vec;
 use std::io as iop;</fold>
 
-<fold>use std::mem;
+<fold imports>use std::mem;
 use std::f64;</fold>
 
-<fold>use std::collections::<fold>{
+<fold imports>use std::collections::<fold block>{
     HashMap,
     VecDeque,
 }</fold>;</fold>
 // Some random comment
 
-fn main() <fold>{
-}</fold>"#;
-
-        let folds = &[
-            FoldKind::Imports,
-            FoldKind::Imports,
-            FoldKind::Imports,
-            FoldKind::Block,
-            FoldKind::Block,
-        ];
-        do_check(text, folds);
+fn main() <fold block>{
+}</fold>"#,
+        );
     }
 
     #[test]
     fn test_folds_macros() {
-        let text = r#"
-macro_rules! foo <fold>{
+        check(
+            r#"
+macro_rules! foo <fold block>{
     ($($tt:tt)*) => { $($tt)* }
 }</fold>
-"#;
-
-        let folds = &[FoldKind::Block];
-        do_check(text, folds);
+"#,
+        );
     }
 
     #[test]
     fn test_fold_match_arms() {
-        let text = r#"
-fn main() <fold>{
-    match 0 <fold>{
+        check(
+            r#"
+fn main() <fold block>{
+    match 0 <fold block>{
         0 => 0,
         _ => 1,
     }</fold>
-}</fold>"#;
+}</fold>
+"#,
+        );
+    }
+
+    #[test]
+    fn fold_big_calls() {
+        check(
+            r#"
+fn main() <fold block>{
+    frobnicate<fold arglist>(
+        1,
+        2,
+        3,
+    )</fold>
+}</fold>
+"#,
+        )
+    }
 
-        let folds = &[FoldKind::Block, FoldKind::Block];
-        do_check(text, folds);
+    #[test]
+    fn fold_record_literals() {
+        check(
+            r#"
+const _: S = S <fold block>{
+
+}</fold>;
+"#,
+        )
     }
 }
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index a6c86e99c..c30b20611 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -1,13 +1,13 @@
 use hir::Semantics;
 use ra_ide_db::{
-    defs::{classify_name, classify_name_ref},
+    defs::{classify_name, classify_name_ref, NameClass},
     symbol_index, RootDatabase,
 };
 use ra_syntax::{
     ast::{self},
     match_ast, AstNode,
     SyntaxKind::*,
-    SyntaxToken, TokenAtOffset,
+    SyntaxToken, TokenAtOffset, T,
 };
 
 use crate::{
@@ -32,14 +32,18 @@ pub(crate) fn goto_definition(
     let file = sema.parse(position.file_id).syntax().clone();
     let original_token = pick_best(file.token_at_offset(position.offset))?;
     let token = sema.descend_into_macros(original_token.clone());
+    let parent = token.parent();
 
     let nav_targets = match_ast! {
-        match (token.parent()) {
+        match parent {
             ast::NameRef(name_ref) => {
                 reference_definition(&sema, &name_ref).to_vec()
             },
             ast::Name(name) => {
-                let def = classify_name(&sema, &name)?.definition();
+                let def = match classify_name(&sema, &name)? {
+                    NameClass::Definition(def) | NameClass::ConstReference(def) => def,
+                    NameClass::FieldShorthand { local: _, field } => field,
+                };
                 let nav = def.try_to_nav(sema.db)?;
                 vec![nav]
             },
@@ -54,7 +58,7 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
     return tokens.max_by_key(priority);
     fn priority(n: &SyntaxToken) -> usize {
         match n.kind() {
-            IDENT | INT_NUMBER => 2,
+            IDENT | INT_NUMBER | T![self] => 2,
             kind if kind.is_trivia() => 0,
             _ => 1,
         }
@@ -100,790 +104,784 @@ pub(crate) fn reference_definition(
 
 #[cfg(test)]
 mod tests {
-    use test_utils::assert_eq_text;
-
-    use crate::mock_analysis::analysis_and_position;
-
-    fn check_goto(ra_fixture: &str, expected: &str, expected_range: &str) {
-        let (analysis, pos) = analysis_and_position(ra_fixture);
+    use ra_db::FileRange;
+    use ra_syntax::{TextRange, TextSize};
+
+    use crate::mock_analysis::MockAnalysis;
+
+    fn check(ra_fixture: &str) {
+        let (mock, position) = MockAnalysis::with_files_and_position(ra_fixture);
+        let (mut expected, data) = mock.annotation();
+        let analysis = mock.analysis();
+        match data.as_str() {
+            "" => (),
+            "file" => {
+                expected.range =
+                    TextRange::up_to(TextSize::of(&*analysis.file_text(expected.file_id).unwrap()))
+            }
+            data => panic!("bad data: {}", data),
+        }
 
-        let mut navs = analysis.goto_definition(pos).unwrap().unwrap().info;
+        let mut navs =
+            analysis.goto_definition(position).unwrap().expect("no definition found").info;
         if navs.len() == 0 {
             panic!("unresolved reference")
         }
         assert_eq!(navs.len(), 1);
 
         let nav = navs.pop().unwrap();
-        let file_text = analysis.file_text(nav.file_id()).unwrap();
-
-        let mut actual = file_text[nav.full_range()].to_string();
-        if let Some(focus) = nav.focus_range() {
-            actual += "|";
-            actual += &file_text[focus];
-        }
-
-        if !expected_range.contains("...") {
-            test_utils::assert_eq_text!(&actual, expected_range);
-        } else {
-            let mut parts = expected_range.split("...");
-            let prefix = parts.next().unwrap();
-            let suffix = parts.next().unwrap();
-            assert!(
-                actual.starts_with(prefix) && actual.ends_with(suffix),
-                "\nExpected: {}\n Actual: {}\n",
-                expected_range,
-                actual
-            );
-        }
-
-        nav.assert_match(expected);
+        assert_eq!(expected, FileRange { file_id: nav.file_id(), range: nav.range() });
     }
 
     #[test]
     fn goto_def_in_items() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            enum E { X(Foo<|>) }
-            ",
-            "Foo STRUCT_DEF FileId(1) 0..11 7..10",
-            "struct Foo;|Foo",
+        check(
+            r#"
+struct Foo;
+     //^^^
+enum E { X(Foo<|>) }
+"#,
         );
     }
 
     #[test]
     fn goto_def_at_start_of_item() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            enum E { X(<|>Foo) }
-            ",
-            "Foo STRUCT_DEF FileId(1) 0..11 7..10",
-            "struct Foo;|Foo",
+        check(
+            r#"
+struct Foo;
+     //^^^
+enum E { X(<|>Foo) }
+"#,
         );
     }
 
     #[test]
     fn goto_definition_resolves_correct_name() {
-        check_goto(
-            "
-            //- /lib.rs
-            use a::Foo;
-            mod a;
-            mod b;
-            enum E { X(Foo<|>) }
-
-            //- /a.rs
-            struct Foo;
+        check(
+            r#"
+//- /lib.rs
+use a::Foo;
+mod a;
+mod b;
+enum E { X(Foo<|>) }
 
-            //- /b.rs
-            struct Foo;
-            ",
-            "Foo STRUCT_DEF FileId(2) 0..11 7..10",
-            "struct Foo;|Foo",
+//- /a.rs
+struct Foo;
+     //^^^
+//- /b.rs
+struct Foo;
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_module_declaration() {
-        check_goto(
-            "
-            //- /lib.rs
-            mod <|>foo;
+        check(
+            r#"
+//- /lib.rs
+mod <|>foo;
 
-            //- /foo.rs
-            // empty
-            ",
-            "foo SOURCE_FILE FileId(2) 0..10",
-            "// empty\n\n",
+//- /foo.rs
+// empty
+//^ file
+"#,
         );
 
-        check_goto(
-            "
-            //- /lib.rs
-            mod <|>foo;
+        check(
+            r#"
+//- /lib.rs
+mod <|>foo;
 
-            //- /foo/mod.rs
-            // empty
-            ",
-            "foo SOURCE_FILE FileId(2) 0..10",
-            "// empty\n\n",
+//- /foo/mod.rs
+// empty
+//^ file
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_macros() {
-        check_goto(
-            "
-            //- /lib.rs
-            macro_rules! foo { () => { () } }
-
-            fn bar() {
-                <|>foo!();
-            }
-            ",
-            "foo MACRO_CALL FileId(1) 0..33 13..16",
-            "macro_rules! foo { () => { () } }|foo",
+        check(
+            r#"
+macro_rules! foo { () => { () } }
+           //^^^
+fn bar() {
+    <|>foo!();
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_macros_from_other_crates() {
-        check_goto(
-            "
-            //- /lib.rs
-            use foo::foo;
-            fn bar() {
-                <|>foo!();
-            }
+        check(
+            r#"
+//- /lib.rs
+use foo::foo;
+fn bar() {
+    <|>foo!();
+}
 
-            //- /foo/lib.rs
-            #[macro_export]
-            macro_rules! foo { () => { () } }
-            ",
-            "foo MACRO_CALL FileId(2) 0..49 29..32",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
+//- /foo/lib.rs
+#[macro_export]
+macro_rules! foo { () => { () } }
+           //^^^
+"#,
         );
     }
 
     #[test]
-    fn goto_def_for_use_alias() {
-        check_goto(
-            "
-            //- /lib.rs
-            use foo as bar<|>;
-
+    fn goto_def_for_macros_in_use_tree() {
+        check(
+            r#"
+//- /lib.rs
+use foo::foo<|>;
 
-            //- /foo/lib.rs
-            #[macro_export]
-            macro_rules! foo { () => { () } }",
-            "SOURCE_FILE FileId(2) 0..50",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }\n",
+//- /foo/lib.rs
+#[macro_export]
+macro_rules! foo { () => { () } }
+           //^^^
+"#,
         );
     }
 
     #[test]
-    fn goto_def_for_use_alias_foo_macro() {
-        check_goto(
-            "
-            //- /lib.rs
-            use foo::foo as bar<|>;
+    fn goto_def_for_macro_defined_fn_with_arg() {
+        check(
+            r#"
+//- /lib.rs
+macro_rules! define_fn {
+    ($name:ident) => (fn $name() {})
+}
+
+define_fn!(foo);
+         //^^^
 
-            //- /foo/lib.rs
-            #[macro_export]
-            macro_rules! foo { () => { () } }
-            ",
-            "foo MACRO_CALL FileId(2) 0..49 29..32",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
+fn bar() {
+   <|>foo();
+}
+"#,
         );
     }
 
     #[test]
-    fn goto_def_for_macros_in_use_tree() {
-        check_goto(
-            "
-            //- /lib.rs
-            use foo::foo<|>;
+    fn goto_def_for_macro_defined_fn_no_arg() {
+        check(
+            r#"
+//- /lib.rs
+macro_rules! define_fn {
+    () => (fn foo() {})
+}
+
+  define_fn!();
+//^^^^^^^^^^^^^
 
-            //- /foo/lib.rs
-            #[macro_export]
-            macro_rules! foo { () => { () } }
-            ",
-            "foo MACRO_CALL FileId(2) 0..49 29..32",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
+fn bar() {
+   <|>foo();
+}
+"#,
         );
     }
 
     #[test]
-    fn goto_def_for_macro_defined_fn_with_arg() {
-        check_goto(
-            "
-            //- /lib.rs
-            macro_rules! define_fn {
-                ($name:ident) => (fn $name() {})
-            }
-
-            define_fn!(foo);
+    fn goto_definition_works_for_macro_inside_pattern() {
+        check(
+            r#"
+//- /lib.rs
+macro_rules! foo {() => {0}}
+           //^^^
 
-            fn bar() {
-               <|>foo();
-            }
-            ",
-            "foo FN_DEF FileId(1) 64..80 75..78",
-            "define_fn!(foo);|foo",
+fn bar() {
+    match (0,1) {
+        (<|>foo!(), _) => {}
+    }
+}
+"#,
         );
     }
 
     #[test]
-    fn goto_def_for_macro_defined_fn_no_arg() {
-        check_goto(
-            "
-            //- /lib.rs
-            macro_rules! define_fn {
-                () => (fn foo() {})
-            }
-
-            define_fn!();
-
-            fn bar() {
-               <|>foo();
-            }
-            ",
-            "foo FN_DEF FileId(1) 51..64 51..64",
-            "define_fn!();|define_fn!();",
+    fn goto_definition_works_for_macro_inside_match_arm_lhs() {
+        check(
+            r#"
+//- /lib.rs
+macro_rules! foo {() => {0}}
+           //^^^
+fn bar() {
+    match 0 {
+        <|>foo!() => {}
+    }
+}
+"#,
         );
     }
 
     #[test]
-    fn goto_definition_works_for_macro_inside_pattern() {
-        check_goto(
-            "
-            //- /lib.rs
-            macro_rules! foo {() => {0}}
-
-            fn bar() {
-                match (0,1) {
-                    (<|>foo!(), _) => {}
-                }
-            }
-            ",
-            "foo MACRO_CALL FileId(1) 0..28 13..16",
-            "macro_rules! foo {() => {0}}|foo",
+    fn goto_def_for_use_alias() {
+        check(
+            r#"
+//- /lib.rs
+use foo as bar<|>;
+
+//- /foo/lib.rs
+// empty
+//^ file
+"#,
         );
     }
 
     #[test]
-    fn goto_definition_works_for_macro_inside_match_arm_lhs() {
-        check_goto(
-            "
-            //- /lib.rs
-            macro_rules! foo {() => {0}}
-
-            fn bar() {
-                match 0 {
-                    <|>foo!() => {}
-                }
-            }
-            ",
-            "foo MACRO_CALL FileId(1) 0..28 13..16",
-            "macro_rules! foo {() => {0}}|foo",
+    fn goto_def_for_use_alias_foo_macro() {
+        check(
+            r#"
+//- /lib.rs
+use foo::foo as bar<|>;
+
+//- /foo/lib.rs
+#[macro_export]
+macro_rules! foo { () => { () } }
+           //^^^
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_methods() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            impl Foo {
-                fn frobnicate(&self) { }
-            }
+        check(
+            r#"
+//- /lib.rs
+struct Foo;
+impl Foo {
+    fn frobnicate(&self) { }
+     //^^^^^^^^^^
+}
 
-            fn bar(foo: &Foo) {
-                foo.frobnicate<|>();
-            }
-            ",
-            "frobnicate FN_DEF FileId(1) 27..51 30..40",
-            "fn frobnicate(&self) { }|frobnicate",
+fn bar(foo: &Foo) {
+    foo.frobnicate<|>();
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_fields() {
-        check_goto(
-            r"
-            //- /lib.rs
-            struct Foo {
-                spam: u32,
-            }
+        check(
+            r#"
+struct Foo {
+    spam: u32,
+} //^^^^
 
-            fn bar(foo: &Foo) {
-                foo.spam<|>;
-            }
-            ",
-            "spam RECORD_FIELD_DEF FileId(1) 17..26 17..21",
-            "spam: u32|spam",
+fn bar(foo: &Foo) {
+    foo.spam<|>;
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_record_fields() {
-        check_goto(
-            r"
-            //- /lib.rs
-            struct Foo {
-                spam: u32,
-            }
+        check(
+            r#"
+//- /lib.rs
+struct Foo {
+    spam: u32,
+} //^^^^
 
-            fn bar() -> Foo {
-                Foo {
-                    spam<|>: 0,
-                }
-            }
-            ",
-            "spam RECORD_FIELD_DEF FileId(1) 17..26 17..21",
-            "spam: u32|spam",
+fn bar() -> Foo {
+    Foo {
+        spam<|>: 0,
+    }
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_record_pat_fields() {
-        check_goto(
-            r"
-            //- /lib.rs
-            struct Foo {
-                spam: u32,
-            }
+        check(
+            r#"
+//- /lib.rs
+struct Foo {
+    spam: u32,
+} //^^^^
 
-            fn bar(foo: Foo) -> Foo {
-                let Foo { spam<|>: _, } = foo
-            }
-            ",
-            "spam RECORD_FIELD_DEF FileId(1) 17..26 17..21",
-            "spam: u32|spam",
+fn bar(foo: Foo) -> Foo {
+    let Foo { spam<|>: _, } = foo
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_record_fields_macros() {
-        check_goto(
+        check(
             r"
-            //- /lib.rs
-            macro_rules! m { () => { 92 };}
-            struct Foo { spam: u32 }
+macro_rules! m { () => { 92 };}
+struct Foo { spam: u32 }
+           //^^^^
 
-            fn bar() -> Foo {
-                Foo { spam<|>: m!() }
-            }
-            ",
-            "spam RECORD_FIELD_DEF FileId(1) 45..54 45..49",
-            "spam: u32|spam",
+fn bar() -> Foo {
+    Foo { spam<|>: m!() }
+}
+",
         );
     }
 
     #[test]
     fn goto_for_tuple_fields() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo(u32);
-
-            fn bar() {
-                let foo = Foo(0);
-                foo.<|>0;
-            }
-            ",
-            "TUPLE_FIELD_DEF FileId(1) 11..14",
-            "u32",
+        check(
+            r#"
+struct Foo(u32);
+         //^^^
+
+fn bar() {
+    let foo = Foo(0);
+    foo.<|>0;
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_ufcs_inherent_methods() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            impl Foo {
-                fn frobnicate() { }
-            }
+        check(
+            r#"
+struct Foo;
+impl Foo {
+    fn frobnicate() { }
+}    //^^^^^^^^^^
 
-            fn bar(foo: &Foo) {
-                Foo::frobnicate<|>();
-            }
-            ",
-            "frobnicate FN_DEF FileId(1) 27..46 30..40",
-            "fn frobnicate() { }|frobnicate",
+fn bar(foo: &Foo) {
+    Foo::frobnicate<|>();
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_ufcs_trait_methods_through_traits() {
-        check_goto(
-            "
-            //- /lib.rs
-            trait Foo {
-                fn frobnicate();
-            }
+        check(
+            r#"
+trait Foo {
+    fn frobnicate();
+}    //^^^^^^^^^^
 
-            fn bar() {
-                Foo::frobnicate<|>();
-            }
-            ",
-            "frobnicate FN_DEF FileId(1) 16..32 19..29",
-            "fn frobnicate();|frobnicate",
+fn bar() {
+    Foo::frobnicate<|>();
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_ufcs_trait_methods_through_self() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            trait Trait {
-                fn frobnicate();
-            }
-            impl Trait for Foo {}
-
-            fn bar() {
-                Foo::frobnicate<|>();
-            }
-            ",
-            "frobnicate FN_DEF FileId(1) 30..46 33..43",
-            "fn frobnicate();|frobnicate",
+        check(
+            r#"
+struct Foo;
+trait Trait {
+    fn frobnicate();
+}    //^^^^^^^^^^
+impl Trait for Foo {}
+
+fn bar() {
+    Foo::frobnicate<|>();
+}
+"#,
         );
     }
 
     #[test]
     fn goto_definition_on_self() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            impl Foo {
-                pub fn new() -> Self {
-                    Self<|> {}
-                }
-            }
-            ",
-            "impl IMPL_DEF FileId(1) 12..73",
-            "impl Foo {...}",
-        );
-
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            impl Foo {
-                pub fn new() -> Self<|> {
-                    Self {}
-                }
-            }
-            ",
-            "impl IMPL_DEF FileId(1) 12..73",
-            "impl Foo {...}",
-        );
-
-        check_goto(
-            "
-            //- /lib.rs
-            enum Foo { A }
-            impl Foo {
-                pub fn new() -> Self<|> {
-                    Foo::A
-                }
-            }
-            ",
-            "impl IMPL_DEF FileId(1) 15..75",
-            "impl Foo {...}",
-        );
-
-        check_goto(
-            "
-            //- /lib.rs
-            enum Foo { A }
-            impl Foo {
-                pub fn thing(a: &Self<|>) {
-                }
-            }
-            ",
-            "impl IMPL_DEF FileId(1) 15..62",
-            "impl Foo {...}",
+        check(
+            r#"
+struct Foo;
+impl Foo {
+   //^^^
+    pub fn new() -> Self {
+        Self<|> {}
+    }
+}
+"#,
+        );
+        check(
+            r#"
+struct Foo;
+impl Foo {
+   //^^^
+    pub fn new() -> Self<|> {
+        Self {}
+    }
+}
+"#,
+        );
+
+        check(
+            r#"
+enum Foo { A }
+impl Foo {
+   //^^^
+    pub fn new() -> Self<|> {
+        Foo::A
+    }
+}
+"#,
+        );
+
+        check(
+            r#"
+enum Foo { A }
+impl Foo {
+   //^^^
+    pub fn thing(a: &Self<|>) {
+    }
+}
+"#,
         );
     }
 
     #[test]
     fn goto_definition_on_self_in_trait_impl() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            trait Make {
-                fn new() -> Self;
-            }
-            impl Make for Foo {
-                fn new() -> Self {
-                    Self<|> {}
-                }
-            }
-            ",
-            "impl IMPL_DEF FileId(1) 49..115",
-            "impl Make for Foo {...}",
+        check(
+            r#"
+struct Foo;
+trait Make {
+    fn new() -> Self;
+}
+impl Make for Foo {
+            //^^^
+    fn new() -> Self {
+        Self<|> {}
+    }
+}
+"#,
         );
 
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            trait Make {
-                fn new() -> Self;
-            }
-            impl Make for Foo {
-                fn new() -> Self<|> {
-                    Self {}
-                }
-            }
-            ",
-            "impl IMPL_DEF FileId(1) 49..115",
-            "impl Make for Foo {...}",
+        check(
+            r#"
+struct Foo;
+trait Make {
+    fn new() -> Self;
+}
+impl Make for Foo {
+            //^^^
+    fn new() -> Self<|> {
+        Self {}
+    }
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_when_used_on_definition_name_itself() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo<|> { value: u32 }
-            ",
-            "Foo STRUCT_DEF FileId(1) 0..25 7..10",
-            "struct Foo { value: u32 }|Foo",
+        check(
+            r#"
+struct Foo<|> { value: u32 }
+     //^^^
+            "#,
         );
 
-        check_goto(
+        check(
             r#"
-            //- /lib.rs
-            struct Foo {
-                field<|>: string,
-            }
-            "#,
-            "field RECORD_FIELD_DEF FileId(1) 17..30 17..22",
-            "field: string|field",
+struct Foo {
+    field<|>: string,
+} //^^^^^
+"#,
         );
 
-        check_goto(
-            "
-            //- /lib.rs
-            fn foo_test<|>() { }
-            ",
-            "foo_test FN_DEF FileId(1) 0..17 3..11",
-            "fn foo_test() { }|foo_test",
+        check(
+            r#"
+fn foo_test<|>() { }
+ //^^^^^^^^
+"#,
         );
 
-        check_goto(
-            "
-            //- /lib.rs
-            enum Foo<|> {
-                Variant,
-            }
-            ",
-            "Foo ENUM_DEF FileId(1) 0..25 5..8",
-            "enum Foo {...}|Foo",
-        );
-
-        check_goto(
-            "
-            //- /lib.rs
-            enum Foo {
-                Variant1,
-                Variant2<|>,
-                Variant3,
-            }
-            ",
-            "Variant2 ENUM_VARIANT FileId(1) 29..37 29..37",
-            "Variant2|Variant2",
+        check(
+            r#"
+enum Foo<|> { Variant }
+   //^^^
+"#,
         );
 
-        check_goto(
+        check(
             r#"
-            //- /lib.rs
-            static INNER<|>: &str = "";
-            "#,
-            "INNER STATIC_DEF FileId(1) 0..24 7..12",
-            "static INNER: &str = \"\";|INNER",
+enum Foo {
+    Variant1,
+    Variant2<|>,
+  //^^^^^^^^
+    Variant3,
+}
+"#,
         );
 
-        check_goto(
+        check(
             r#"
-            //- /lib.rs
-            const INNER<|>: &str = "";
-            "#,
-            "INNER CONST_DEF FileId(1) 0..23 6..11",
-            "const INNER: &str = \"\";|INNER",
+static INNER<|>: &str = "";
+     //^^^^^
+"#,
         );
 
-        check_goto(
+        check(
             r#"
-            //- /lib.rs
-            type Thing<|> = Option<()>;
-            "#,
-            "Thing TYPE_ALIAS_DEF FileId(1) 0..24 5..10",
-            "type Thing = Option<()>;|Thing",
+const INNER<|>: &str = "";
+    //^^^^^
+"#,
         );
 
-        check_goto(
+        check(
             r#"
-            //- /lib.rs
-            trait Foo<|> { }
-            "#,
-            "Foo TRAIT_DEF FileId(1) 0..13 6..9",
-            "trait Foo { }|Foo",
+type Thing<|> = Option<()>;
+   //^^^^^
+"#,
         );
 
-        check_goto(
+        check(
             r#"
-            //- /lib.rs
-            mod bar<|> { }
-            "#,
-            "bar MODULE FileId(1) 0..11 4..7",
-            "mod bar { }|bar",
+trait Foo<|> { }
+    //^^^
+"#,
+        );
+
+        check(
+            r#"
+mod bar<|> { }
+  //^^^
+"#,
         );
     }
 
     #[test]
     fn goto_from_macro() {
-        check_goto(
-            "
-            //- /lib.rs
-            macro_rules! id {
-                ($($tt:tt)*) => { $($tt)* }
-            }
-            fn foo() {}
-            id! {
-                fn bar() {
-                    fo<|>o();
-                }
-            }
-            mod confuse_index { fn foo(); }
-            ",
-            "foo FN_DEF FileId(1) 52..63 55..58",
-            "fn foo() {}|foo",
+        check(
+            r#"
+macro_rules! id {
+    ($($tt:tt)*) => { $($tt)* }
+}
+fn foo() {}
+ //^^^
+id! {
+    fn bar() {
+        fo<|>o();
+    }
+}
+mod confuse_index { fn foo(); }
+"#,
         );
     }
 
     #[test]
     fn goto_through_format() {
-        check_goto(
-            "
-            //- /lib.rs
-            #[macro_export]
-            macro_rules! format {
-                ($($arg:tt)*) => ($crate::fmt::format($crate::__export::format_args!($($arg)*)))
-            }
-            #[rustc_builtin_macro]
-            #[macro_export]
-            macro_rules! format_args {
-                ($fmt:expr) => ({ /* compiler built-in */ });
-                ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
-            }
-            pub mod __export {
-                pub use crate::format_args;
-                fn foo() {} // for index confusion
-            }
-            fn foo() -> i8 {}
-            fn test() {
-                format!(\"{}\", fo<|>o())
-            }
-            ",
-            "foo FN_DEF FileId(1) 398..415 401..404",
-            "fn foo() -> i8 {}|foo",
+        check(
+            r#"
+#[macro_export]
+macro_rules! format {
+    ($($arg:tt)*) => ($crate::fmt::format($crate::__export::format_args!($($arg)*)))
+}
+#[rustc_builtin_macro]
+#[macro_export]
+macro_rules! format_args {
+    ($fmt:expr) => ({ /* compiler built-in */ });
+    ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
+}
+pub mod __export {
+    pub use crate::format_args;
+    fn foo() {} // for index confusion
+}
+fn foo() -> i8 {}
+ //^^^
+fn test() {
+    format!("{}", fo<|>o())
+}
+"#,
         );
     }
 
     #[test]
     fn goto_for_type_param() {
-        check_goto(
+        check(
             r#"
-            //- /lib.rs
-            struct Foo<T: Clone> {
-                t: <|>T,
-            }
-            "#,
-            "T TYPE_PARAM FileId(1) 11..19 11..12",
-            "T: Clone|T",
+struct Foo<T: Clone> { t: <|>T }
+         //^
+"#,
         );
     }
 
     #[test]
     fn goto_within_macro() {
-        check_goto(
-            "
-            //- /lib.rs
-            macro_rules! id {
-                ($($tt:tt)*) => ($($tt)*)
-            }
+        check(
+            r#"
+macro_rules! id {
+    ($($tt:tt)*) => ($($tt)*)
+}
 
-            fn foo() {
-                let x = 1;
-                id!({
-                    let y = <|>x;
-                    let z = y;
-                });
-            }
-            ",
-            "x BIND_PAT FileId(1) 69..70",
-            "x",
+fn foo() {
+    let x = 1;
+      //^
+    id!({
+        let y = <|>x;
+        let z = y;
+    });
+}
+"#,
         );
 
-        check_goto(
-            "
-            //- /lib.rs
-            macro_rules! id {
-                ($($tt:tt)*) => ($($tt)*)
-            }
+        check(
+            r#"
+macro_rules! id {
+    ($($tt:tt)*) => ($($tt)*)
+}
 
-            fn foo() {
-                let x = 1;
-                id!({
-                    let y = x;
-                    let z = <|>y;
-                });
-            }
-            ",
-            "y BIND_PAT FileId(1) 98..99",
-            "y",
+fn foo() {
+    let x = 1;
+    id!({
+        let y = x;
+          //^
+        let z = <|>y;
+    });
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_in_local_fn() {
-        check_goto(
-            "
-            //- /lib.rs
-            fn main() {
-                fn foo() {
-                    let x = 92;
-                    <|>x;
-                }
-            }
-            ",
-            "x BIND_PAT FileId(1) 39..40",
-            "x",
+        check(
+            r#"
+fn main() {
+    fn foo() {
+        let x = 92;
+          //^
+        <|>x;
+    }
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_in_local_macro() {
-        check_goto(
-            r"
-            //- /lib.rs
-            fn bar() {
-                macro_rules! foo { () => { () } }
-                <|>foo!();
-            }
-            ",
-            "foo MACRO_CALL FileId(1) 15..48 28..31",
-            "macro_rules! foo { () => { () } }|foo",
+        check(
+            r#"
+fn bar() {
+    macro_rules! foo { () => { () } }
+               //^^^
+    <|>foo!();
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_field_init_shorthand() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo { x: i32 }
-            fn main() {
-                let x = 92;
-                Foo { x<|> };
-            }
-            ",
-            "x BIND_PAT FileId(1) 42..43",
-            "x",
+        check(
+            r#"
+struct Foo { x: i32 }
+fn main() {
+    let x = 92;
+      //^
+    Foo { x<|> };
+}
+"#,
         )
     }
+
+    #[test]
+    fn goto_def_for_enum_variant_field() {
+        check(
+            r#"
+enum Foo {
+    Bar { x: i32 }
+}       //^
+fn baz(foo: Foo) {
+    match foo {
+        Foo::Bar { x<|> } => x
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn goto_def_for_enum_variant_self_pattern_const() {
+        check(
+            r#"
+enum Foo { Bar }
+         //^^^
+impl Foo {
+    fn baz(self) {
+        match self { Self::Bar<|> => {} }
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn goto_def_for_enum_variant_self_pattern_record() {
+        check(
+            r#"
+enum Foo { Bar { val: i32 } }
+         //^^^
+impl Foo {
+    fn baz(self) -> i32 {
+        match self { Self::Bar<|> { val } => {} }
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn goto_def_for_enum_variant_self_expr_const() {
+        check(
+            r#"
+enum Foo { Bar }
+         //^^^
+impl Foo {
+    fn baz(self) { Self::Bar<|>; }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn goto_def_for_enum_variant_self_expr_record() {
+        check(
+            r#"
+enum Foo { Bar { val: i32 } }
+         //^^^
+impl Foo {
+    fn baz(self) { Self::Bar<|> {val: 4}; }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn goto_def_for_type_alias_generic_parameter() {
+        check(
+            r#"
+type Alias<T> = T<|>;
+         //^
+"#,
+        )
+    }
+
+    #[test]
+    fn goto_def_for_macro_container() {
+        check(
+            r#"
+//- /lib.rs
+foo::module<|>::mac!();
+
+//- /foo/lib.rs
+pub mod module {
+      //^^^^^^
+    #[macro_export]
+    macro_rules! _mac { () => { () } }
+    pub use crate::_mac as mac;
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ra_ide/src/goto_implementation.rs b/crates/ra_ide/src/goto_implementation.rs
index 0cec0657e..9acc960fc 100644
--- a/crates/ra_ide/src/goto_implementation.rs
+++ b/crates/ra_ide/src/goto_implementation.rs
@@ -74,135 +74,156 @@ fn impls_for_trait(
 
 #[cfg(test)]
 mod tests {
-    use crate::mock_analysis::analysis_and_position;
+    use ra_db::FileRange;
 
-    fn check_goto(fixture: &str, expected: &[&str]) {
-        let (analysis, pos) = analysis_and_position(fixture);
+    use crate::mock_analysis::MockAnalysis;
 
-        let mut navs = analysis.goto_implementation(pos).unwrap().unwrap().info;
-        assert_eq!(navs.len(), expected.len());
-        navs.sort_by_key(|nav| (nav.file_id(), nav.full_range().start()));
-        navs.into_iter().enumerate().for_each(|(i, nav)| nav.assert_match(expected[i]));
+    fn check(ra_fixture: &str) {
+        let (mock, position) = MockAnalysis::with_files_and_position(ra_fixture);
+        let annotations = mock.annotations();
+        let analysis = mock.analysis();
+
+        let navs = analysis.goto_implementation(position).unwrap().unwrap().info;
+
+        let key = |frange: &FileRange| (frange.file_id, frange.range.start());
+
+        let mut expected = annotations
+            .into_iter()
+            .map(|(range, data)| {
+                assert!(data.is_empty());
+                range
+            })
+            .collect::<Vec<_>>();
+        expected.sort_by_key(key);
+
+        let mut actual = navs
+            .into_iter()
+            .map(|nav| FileRange { file_id: nav.file_id(), range: nav.range() })
+            .collect::<Vec<_>>();
+        actual.sort_by_key(key);
+
+        assert_eq!(expected, actual);
     }
 
     #[test]
     fn goto_implementation_works() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo<|>;
-            impl Foo {}
-            ",
-            &["impl IMPL_DEF FileId(1) 12..23"],
+        check(
+            r#"
+struct Foo<|>;
+impl Foo {}
+   //^^^
+"#,
         );
     }
 
     #[test]
     fn goto_implementation_works_multiple_blocks() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo<|>;
-            impl Foo {}
-            impl Foo {}
-            ",
-            &["impl IMPL_DEF FileId(1) 12..23", "impl IMPL_DEF FileId(1) 24..35"],
+        check(
+            r#"
+struct Foo<|>;
+impl Foo {}
+   //^^^
+impl Foo {}
+   //^^^
+"#,
         );
     }
 
     #[test]
     fn goto_implementation_works_multiple_mods() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo<|>;
-            mod a {
-                impl super::Foo {}
-            }
-            mod b {
-                impl super::Foo {}
-            }
-            ",
-            &["impl IMPL_DEF FileId(1) 24..42", "impl IMPL_DEF FileId(1) 57..75"],
+        check(
+            r#"
+struct Foo<|>;
+mod a {
+    impl super::Foo {}
+       //^^^^^^^^^^
+}
+mod b {
+    impl super::Foo {}
+       //^^^^^^^^^^
+}
+"#,
         );
     }
 
     #[test]
     fn goto_implementation_works_multiple_files() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo<|>;
-            mod a;
-            mod b;
-            //- /a.rs
-            impl crate::Foo {}
-            //- /b.rs
-            impl crate::Foo {}
-            ",
-            &["impl IMPL_DEF FileId(2) 0..18", "impl IMPL_DEF FileId(3) 0..18"],
+        check(
+            r#"
+//- /lib.rs
+struct Foo<|>;
+mod a;
+mod b;
+//- /a.rs
+impl crate::Foo {}
+   //^^^^^^^^^^
+//- /b.rs
+impl crate::Foo {}
+   //^^^^^^^^^^
+"#,
         );
     }
 
     #[test]
     fn goto_implementation_for_trait() {
-        check_goto(
-            "
-            //- /lib.rs
-            trait T<|> {}
-            struct Foo;
-            impl T for Foo {}
-            ",
-            &["impl IMPL_DEF FileId(1) 23..40"],
+        check(
+            r#"
+trait T<|> {}
+struct Foo;
+impl T for Foo {}
+         //^^^
+"#,
         );
     }
 
     #[test]
     fn goto_implementation_for_trait_multiple_files() {
-        check_goto(
-            "
-            //- /lib.rs
-            trait T<|> {};
-            struct Foo;
-            mod a;
-            mod b;
-            //- /a.rs
-            impl crate::T for crate::Foo {}
-            //- /b.rs
-            impl crate::T for crate::Foo {}
-            ",
-            &["impl IMPL_DEF FileId(2) 0..31", "impl IMPL_DEF FileId(3) 0..31"],
+        check(
+            r#"
+//- /lib.rs
+trait T<|> {};
+struct Foo;
+mod a;
+mod b;
+//- /a.rs
+impl crate::T for crate::Foo {}
+                //^^^^^^^^^^
+//- /b.rs
+impl crate::T for crate::Foo {}
+                //^^^^^^^^^^
+            "#,
         );
     }
 
     #[test]
     fn goto_implementation_all_impls() {
-        check_goto(
-            "
-            //- /lib.rs
-            trait T {}
-            struct Foo<|>;
-            impl Foo {}
-            impl T for Foo {}
-            impl T for &Foo {}
-            ",
-            &[
-                "impl IMPL_DEF FileId(1) 23..34",
-                "impl IMPL_DEF FileId(1) 35..52",
-                "impl IMPL_DEF FileId(1) 53..71",
-            ],
+        check(
+            r#"
+//- /lib.rs
+trait T {}
+struct Foo<|>;
+impl Foo {}
+   //^^^
+impl T for Foo {}
+         //^^^
+impl T for &Foo {}
+         //^^^^
+"#,
         );
     }
 
     #[test]
     fn goto_implementation_to_builtin_derive() {
-        check_goto(
-            "
-            //- /lib.rs
-            #[derive(Copy)]
-            struct Foo<|>;
-            ",
-            &["impl IMPL_DEF FileId(1) 0..15"],
+        check(
+            r#"
+  #[derive(Copy)]
+//^^^^^^^^^^^^^^^
+struct Foo<|>;
+
+mod marker {
+    trait Copy {}
+}
+"#,
         );
     }
 }
diff --git a/crates/ra_ide/src/goto_type_definition.rs b/crates/ra_ide/src/goto_type_definition.rs
index 91a3097fb..069cb283e 100644
--- a/crates/ra_ide/src/goto_type_definition.rs
+++ b/crates/ra_ide/src/goto_type_definition.rs
@@ -1,5 +1,5 @@
 use ra_ide_db::RootDatabase;
-use ra_syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
+use ra_syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
 
 use crate::{display::ToNav, FilePosition, NavigationTarget, RangeInfo};
 
@@ -25,8 +25,9 @@ pub(crate) fn goto_type_definition(
     let (ty, node) = sema.ancestors_with_macros(token.parent()).find_map(|node| {
         let ty = match_ast! {
             match node {
-                ast::Expr(expr) => sema.type_of_expr(&expr)?,
-                ast::Pat(pat) => sema.type_of_pat(&pat)?,
+                ast::Expr(it) => sema.type_of_expr(&it)?,
+                ast::Pat(it) => sema.type_of_pat(&it)?,
+                ast::SelfParam(it) => sema.type_of_self(&it)?,
                 _ => return None,
             }
         };
@@ -34,7 +35,7 @@ pub(crate) fn goto_type_definition(
         Some((ty, node))
     })?;
 
-    let adt_def = ty.autoderef(db).find_map(|ty| ty.as_adt())?;
+    let adt_def = ty.autoderef(db).filter_map(|ty| ty.as_adt()).last()?;
 
     let nav = adt_def.to_nav(db);
     Some(RangeInfo::new(node.text_range(), vec![nav]))
@@ -44,7 +45,7 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
     return tokens.max_by_key(priority);
     fn priority(n: &SyntaxToken) -> usize {
         match n.kind() {
-            IDENT | INT_NUMBER => 2,
+            IDENT | INT_NUMBER | T![self] => 2,
             kind if kind.is_trivia() => 0,
             _ => 1,
         }
@@ -53,91 +54,98 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
 
 #[cfg(test)]
 mod tests {
-    use crate::mock_analysis::analysis_and_position;
+    use ra_db::FileRange;
 
-    fn check_goto(fixture: &str, expected: &str) {
-        let (analysis, pos) = analysis_and_position(fixture);
+    use crate::mock_analysis::MockAnalysis;
 
-        let mut navs = analysis.goto_type_definition(pos).unwrap().unwrap().info;
+    fn check(ra_fixture: &str) {
+        let (mock, position) = MockAnalysis::with_files_and_position(ra_fixture);
+        let (expected, data) = mock.annotation();
+        assert!(data.is_empty());
+        let analysis = mock.analysis();
+
+        let mut navs = analysis.goto_type_definition(position).unwrap().unwrap().info;
         assert_eq!(navs.len(), 1);
         let nav = navs.pop().unwrap();
-        nav.assert_match(expected);
+        assert_eq!(expected, FileRange { file_id: nav.file_id(), range: nav.range() });
     }
 
     #[test]
     fn goto_type_definition_works_simple() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            fn foo() {
-                let f: Foo;
-                f<|>
-            }
-            ",
-            "Foo STRUCT_DEF FileId(1) 0..11 7..10",
+        check(
+            r#"
+struct Foo;
+     //^^^
+fn foo() {
+    let f: Foo; f<|>
+}
+"#,
         );
     }
 
     #[test]
     fn goto_type_definition_works_simple_ref() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            fn foo() {
-                let f: &Foo;
-                f<|>
-            }
-            ",
-            "Foo STRUCT_DEF FileId(1) 0..11 7..10",
+        check(
+            r#"
+struct Foo;
+     //^^^
+fn foo() {
+    let f: &Foo; f<|>
+}
+"#,
         );
     }
 
     #[test]
     fn goto_type_definition_works_through_macro() {
-        check_goto(
-            "
-            //- /lib.rs
-            macro_rules! id {
-                ($($tt:tt)*) => { $($tt)* }
-            }
-            struct Foo {}
-            id! {
-                fn bar() {
-                    let f<|> = Foo {};
-                }
-            }
-            ",
-            "Foo STRUCT_DEF FileId(1) 52..65 59..62",
+        check(
+            r#"
+macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
+struct Foo {}
+     //^^^
+id! {
+    fn bar() { let f<|> = Foo {}; }
+}
+"#,
         );
     }
 
     #[test]
     fn goto_type_definition_for_param() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            fn foo(<|>f: Foo) {}
-            ",
-            "Foo STRUCT_DEF FileId(1) 0..11 7..10",
+        check(
+            r#"
+struct Foo;
+     //^^^
+fn foo(<|>f: Foo) {}
+"#,
         );
     }
 
     #[test]
     fn goto_type_definition_for_tuple_field() {
-        check_goto(
-            "
-            //- /lib.rs
-            struct Foo;
-            struct Bar(Foo);
-            fn foo() {
-                let bar = Bar(Foo);
-                bar.<|>0;
-            }
-            ",
-            "Foo STRUCT_DEF FileId(1) 0..11 7..10",
+        check(
+            r#"
+struct Foo;
+     //^^^
+struct Bar(Foo);
+fn foo() {
+    let bar = Bar(Foo);
+    bar.<|>0;
+}
+"#,
         );
     }
+
+    #[test]
+    fn goto_def_for_self_param() {
+        check(
+            r#"
+struct Foo;
+     //^^^
+impl Foo {
+    fn f(&self<|>) {}
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index d96cb5596..a4c97e7f9 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -1,8 +1,6 @@
-use std::iter::once;
-
 use hir::{
-    Adt, AsAssocItem, AssocItemContainer, FieldSource, HasSource, HirDisplay, ModuleDef,
-    ModuleSource, Semantics,
+    Adt, AsAssocItem, AssocItemContainer, Documentation, FieldSource, HasSource, HirDisplay,
+    Module, ModuleDef, ModuleSource, Semantics,
 };
 use itertools::Itertools;
 use ra_db::SourceDatabase;
@@ -10,54 +8,66 @@ use ra_ide_db::{
     defs::{classify_name, classify_name_ref, Definition},
     RootDatabase,
 };
-use ra_syntax::{
-    ast::{self, DocCommentsOwner},
-    match_ast, AstNode,
-    SyntaxKind::*,
-    SyntaxToken, TokenAtOffset,
-};
+use ra_syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
+use stdx::format_to;
+use test_utils::mark;
 
 use crate::{
-    display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel},
-    FilePosition, RangeInfo,
+    display::{macro_label, ShortLabel, ToNav, TryToNav},
+    markup::Markup,
+    runnables::runnable,
+    FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
 };
 
-/// Contains the results when hovering over an item
-#[derive(Debug, Default)]
-pub struct HoverResult {
-    results: Vec<String>,
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct HoverConfig {
+    pub implementations: bool,
+    pub run: bool,
+    pub debug: bool,
+    pub goto_type_def: bool,
 }
 
-impl HoverResult {
-    pub fn new() -> HoverResult {
-        Self::default()
+impl Default for HoverConfig {
+    fn default() -> Self {
+        Self { implementations: true, run: true, debug: true, goto_type_def: true }
     }
+}
 
-    pub fn extend(&mut self, item: Option<String>) {
-        self.results.extend(item);
-    }
+impl HoverConfig {
+    pub const NO_ACTIONS: Self =
+        Self { implementations: false, run: false, debug: false, goto_type_def: false };
 
-    pub fn is_empty(&self) -> bool {
-        self.results.is_empty()
+    pub fn any(&self) -> bool {
+        self.implementations || self.runnable() || self.goto_type_def
     }
 
-    pub fn len(&self) -> usize {
-        self.results.len()
+    pub fn none(&self) -> bool {
+        !self.any()
     }
 
-    pub fn first(&self) -> Option<&str> {
-        self.results.first().map(String::as_str)
+    pub fn runnable(&self) -> bool {
+        self.run || self.debug
     }
+}
 
-    pub fn results(&self) -> &[String] {
-        &self.results
-    }
+#[derive(Debug, Clone)]
+pub enum HoverAction {
+    Runnable(Runnable),
+    Implementaion(FilePosition),
+    GoToType(Vec<HoverGotoTypeData>),
+}
 
-    /// Returns the results converted into markup
-    /// for displaying in a UI
-    pub fn to_markup(&self) -> String {
-        self.results.join("\n\n---\n")
-    }
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct HoverGotoTypeData {
+    pub mod_path: String,
+    pub nav: NavigationTarget,
+}
+
+/// Contains the results when hovering over an item
+#[derive(Debug, Default)]
+pub struct HoverResult {
+    pub markup: Markup,
+    pub actions: Vec<HoverAction>,
 }
 
 // Feature: Hover
@@ -70,23 +80,32 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
     let token = pick_best(file.token_at_offset(position.offset))?;
     let token = sema.descend_into_macros(token);
 
-    let mut res = HoverResult::new();
+    let mut res = HoverResult::default();
 
-    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()))
-            },
+    let node = token.parent();
+    let definition = match_ast! {
+        match node {
+            ast::NameRef(name_ref) => classify_name_ref(&sema, &name_ref).map(|d| d.definition()),
+            ast::Name(name) => classify_name(&sema, &name).map(|d| d.definition()),
             _ => None,
         }
-    } {
-        let range = sema.original_range(&node).range;
-        res.extend(hover_text_from_name_kind(db, name_kind));
+    };
+    if let Some(definition) = definition {
+        if let Some(markup) = hover_for_definition(db, definition) {
+            res.markup = markup;
+            if let Some(action) = show_implementations_action(db, definition) {
+                res.actions.push(action);
+            }
 
-        if !res.is_empty() {
+            if let Some(action) = runnable_action(&sema, definition, position.file_id) {
+                res.actions.push(action);
+            }
+
+            if let Some(action) = goto_type_action(db, definition) {
+                res.actions.push(action);
+            }
+
+            let range = sema.original_range(&node).range;
             return Some(RangeInfo::new(range, res));
         }
     }
@@ -97,35 +116,134 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
 
     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,
+            ast::Expr(it) => sema.type_of_expr(&it)?,
+            ast::Pat(it) => sema.type_of_pat(&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.
+            ast::MacroCall(_it) => return None,
+            _ => return None,
         }
-    }?;
+    };
 
-    res.extend(Some(rust_code_markup(&ty.display(db))));
+    res.markup = Markup::fenced_block(&ty.display(db));
     let range = sema.original_range(&node).range;
     Some(RangeInfo::new(range, res))
 }
 
-fn hover_text(
+fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
+    fn to_action(nav_target: NavigationTarget) -> HoverAction {
+        HoverAction::Implementaion(FilePosition {
+            file_id: nav_target.file_id(),
+            offset: nav_target.range().start(),
+        })
+    }
+
+    match def {
+        Definition::ModuleDef(it) => match it {
+            ModuleDef::Adt(Adt::Struct(it)) => Some(to_action(it.to_nav(db))),
+            ModuleDef::Adt(Adt::Union(it)) => Some(to_action(it.to_nav(db))),
+            ModuleDef::Adt(Adt::Enum(it)) => Some(to_action(it.to_nav(db))),
+            ModuleDef::Trait(it) => Some(to_action(it.to_nav(db))),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
+fn runnable_action(
+    sema: &Semantics<RootDatabase>,
+    def: Definition,
+    file_id: FileId,
+) -> Option<HoverAction> {
+    match def {
+        Definition::ModuleDef(it) => match it {
+            ModuleDef::Module(it) => match it.definition_source(sema.db).value {
+                ModuleSource::Module(it) => runnable(&sema, it.syntax().clone(), file_id)
+                    .map(|it| HoverAction::Runnable(it)),
+                _ => None,
+            },
+            ModuleDef::Function(it) => {
+                let src = it.source(sema.db);
+                if src.file_id != file_id.into() {
+                    mark::hit!(hover_macro_generated_struct_fn_doc_comment);
+                    mark::hit!(hover_macro_generated_struct_fn_doc_attr);
+
+                    return None;
+                }
+
+                runnable(&sema, src.value.syntax().clone(), file_id)
+                    .map(|it| HoverAction::Runnable(it))
+            }
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
+fn goto_type_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
+    match def {
+        Definition::Local(it) => {
+            let mut targets: Vec<ModuleDef> = Vec::new();
+            let mut push_new_def = |item: ModuleDef| {
+                if !targets.contains(&item) {
+                    targets.push(item);
+                }
+            };
+
+            it.ty(db).walk(db, |t| {
+                if let Some(adt) = t.as_adt() {
+                    push_new_def(adt.into());
+                } else if let Some(trait_) = t.as_dyn_trait() {
+                    push_new_def(trait_.into());
+                } else if let Some(traits) = t.as_impl_traits(db) {
+                    traits.into_iter().for_each(|it| push_new_def(it.into()));
+                } else if let Some(trait_) = t.as_associated_type_parent_trait(db) {
+                    push_new_def(trait_.into());
+                }
+            });
+
+            let targets = targets
+                .into_iter()
+                .filter_map(|it| {
+                    Some(HoverGotoTypeData {
+                        mod_path: render_path(
+                            db,
+                            it.module(db)?,
+                            it.name(db).map(|name| name.to_string()),
+                        ),
+                        nav: it.try_to_nav(db)?,
+                    })
+                })
+                .collect();
+
+            Some(HoverAction::GoToType(targets))
+        }
+        _ => None,
+    }
+}
+
+fn hover_markup(
     docs: Option<String>,
     desc: Option<String>,
     mod_path: Option<String>,
-) -> Option<String> {
-    if let Some(desc) = desc {
-        Some(rust_code_markup_with_doc(&desc, docs.as_deref(), mod_path.as_deref()))
-    } else {
-        docs
+) -> Option<Markup> {
+    match desc {
+        Some(desc) => {
+            let mut buf = String::new();
+
+            if let Some(mod_path) = mod_path {
+                if !mod_path.is_empty() {
+                    format_to!(buf, "```rust\n{}\n```\n\n", mod_path);
+                }
+            }
+            format_to!(buf, "```rust\n{}\n```", desc);
+
+            if let Some(doc) = docs {
+                format_to!(buf, "\n___\n\n{}", doc);
+            }
+            Some(buf.into())
+        }
+        None => docs.map(Markup::from),
     }
 }
 
@@ -147,35 +265,35 @@ fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String>
     .map(|name| name.to_string())
 }
 
-fn determine_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> {
-    let mod_path = def.module(db).map(|module| {
-        once(db.crate_graph()[module.krate().into()].display_name.as_ref().map(ToString::to_string))
-            .chain(
-                module
-                    .path_to_root(db)
-                    .into_iter()
-                    .rev()
-                    .map(|it| it.name(db).map(|name| name.to_string())),
-            )
-            .chain(once(definition_owner_name(db, def)))
-            .flatten()
-            .join("::")
-    });
-    mod_path
-}
-
-fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<String> {
-    let mod_path = determine_mod_path(db, &def);
+fn render_path(db: &RootDatabase, module: Module, item_name: Option<String>) -> String {
+    let crate_name =
+        db.crate_graph()[module.krate().into()].display_name.as_ref().map(ToString::to_string);
+    let module_path = module
+        .path_to_root(db)
+        .into_iter()
+        .rev()
+        .flat_map(|it| it.name(db).map(|name| name.to_string()));
+    crate_name.into_iter().chain(module_path).chain(item_name).join("::")
+}
+
+fn definition_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> {
+    def.module(db).map(|module| render_path(db, module, definition_owner_name(db, def)))
+}
+
+fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
+    let mod_path = definition_mod_path(db, &def);
     return match def {
         Definition::Macro(it) => {
             let src = it.source(db);
-            hover_text(src.value.doc_comment_text(), Some(macro_label(&src.value)), mod_path)
+            let docs = Documentation::from_ast(&src.value).map(Into::into);
+            hover_markup(docs, Some(macro_label(&src.value)), mod_path)
         }
         Definition::Field(it) => {
             let src = it.source(db);
             match src.value {
                 FieldSource::Named(it) => {
-                    hover_text(it.doc_comment_text(), it.short_label(), mod_path)
+                    let docs = Documentation::from_ast(&it).map(Into::into);
+                    hover_markup(docs, it.short_label(), mod_path)
                 }
                 _ => None,
             }
@@ -183,7 +301,8 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<Strin
         Definition::ModuleDef(it) => match it {
             ModuleDef::Module(it) => match it.definition_source(db).value {
                 ModuleSource::Module(it) => {
-                    hover_text(it.doc_comment_text(), it.short_label(), mod_path)
+                    let docs = Documentation::from_ast(&it).map(Into::into);
+                    hover_markup(docs, it.short_label(), mod_path)
                 }
                 _ => None,
             },
@@ -196,22 +315,23 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<Strin
             ModuleDef::Static(it) => from_def_source(db, it, mod_path),
             ModuleDef::Trait(it) => from_def_source(db, it, mod_path),
             ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path),
-            ModuleDef::BuiltinType(it) => Some(it.to_string()),
+            ModuleDef::BuiltinType(it) => return Some(it.to_string().into()),
         },
-        Definition::Local(it) => Some(rust_code_markup(&it.ty(db).display(db))),
+        Definition::Local(it) => return Some(Markup::fenced_block(&it.ty(db).display(db))),
         Definition::TypeParam(_) | Definition::SelfType(_) => {
             // FIXME: Hover for generic param
             None
         }
     };
 
-    fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<String>
+    fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
     where
         D: HasSource<Ast = A>,
-        A: ast::DocCommentsOwner + ast::NameOwner + ShortLabel,
+        A: ast::DocCommentsOwner + ast::NameOwner + ShortLabel + ast::AttrsOwner,
     {
         let src = def.source(db);
-        hover_text(src.value.doc_comment_text(), src.value.short_label(), mod_path)
+        let docs = Documentation::from_ast(&src.value).map(Into::into);
+        hover_markup(docs, src.value.short_label(), mod_path)
     }
 }
 
@@ -220,7 +340,7 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
     fn priority(n: &SyntaxToken) -> usize {
         match n.kind() {
             IDENT | INT_NUMBER => 3,
-            L_PAREN | R_PAREN => 2,
+            T!['('] | T![')'] => 2,
             kind if kind.is_trivia() => 0,
             _ => 1,
         }
@@ -229,649 +349,682 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
 
 #[cfg(test)]
 mod tests {
+    use expect::{expect, Expect};
     use ra_db::FileLoader;
-    use ra_syntax::TextRange;
 
-    use crate::mock_analysis::{analysis_and_position, single_file_with_position};
+    use crate::mock_analysis::analysis_and_position;
 
-    fn trim_markup(s: &str) -> &str {
-        s.trim_start_matches("```rust\n").trim_end_matches("\n```")
-    }
+    use super::*;
 
-    fn trim_markup_opt(s: Option<&str>) -> Option<&str> {
-        s.map(trim_markup)
+    fn check_hover_no_result(ra_fixture: &str) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
+        assert!(analysis.hover(position).unwrap().is_none());
     }
 
-    fn check_hover_result(fixture: &str, expected: &[&str]) -> String {
-        let (analysis, position) = analysis_and_position(fixture);
+    fn check(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
         let hover = analysis.hover(position).unwrap().unwrap();
-        let mut results = Vec::from(hover.info.results());
-        results.sort();
-
-        for (markup, expected) in
-            results.iter().zip(expected.iter().chain(std::iter::repeat(&"<missing>")))
-        {
-            assert_eq!(trim_markup(&markup), *expected);
-        }
-
-        assert_eq!(hover.info.len(), expected.len());
 
         let content = analysis.db.file_text(position.file_id);
-        content[hover.range].to_string()
+        let hovered_element = &content[hover.range];
+
+        let actual = format!("*{}*\n{}\n", hovered_element, hover.info.markup);
+        expect.assert_eq(&actual)
     }
 
-    fn check_hover_no_result(fixture: &str) {
-        let (analysis, position) = analysis_and_position(fixture);
-        assert!(analysis.hover(position).unwrap().is_none());
+    fn check_actions(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
+        let hover = analysis.hover(position).unwrap().unwrap();
+        expect.assert_debug_eq(&hover.info.actions)
     }
 
     #[test]
     fn hover_shows_type_of_an_expression() {
-        let (analysis, position) = single_file_with_position(
-            "
-            pub fn foo() -> u32 { 1 }
+        check(
+            r#"
+pub fn foo() -> u32 { 1 }
 
-            fn main() {
-                let foo_test = foo()<|>;
-            }
-            ",
+fn main() {
+    let foo_test = foo()<|>;
+}
+"#,
+            expect![[r#"
+                *foo()*
+                ```rust
+                u32
+                ```
+            "#]],
         );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(hover.range, TextRange::new(95.into(), 100.into()));
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("u32"));
     }
 
     #[test]
     fn hover_shows_long_type_of_an_expression() {
-        check_hover_result(
+        check(
             r#"
-            //- /main.rs
-            struct Scan<A, B, C> {
-                a: A,
-                b: B,
-                c: C,
-            }
+struct Scan<A, B, C> { a: A, b: B, c: C }
+struct Iter<I> { inner: I }
+enum Option<T> { Some(T), None }
 
-            struct FakeIter<I> {
-                inner: I,
-            }
-
-            struct OtherStruct<T> {
-                i: T,
-            }
+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 scan<A, B, C>(a: A, b: B, c: C) -> Iter<Scan<OtherStruct<A>, B, C>> {
+    Iter { 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>>"],
+fn main() {
+    let num: i32 = 55;
+    let closure = |memo: &mut u32, value: &u32, _another: &mut u32| -> Option<u32> {
+        Option::Some(*memo + value)
+    };
+    let number = 5u32;
+    let mut iter<|> = scan(OtherStruct { i: num }, closure, number);
+}
+"#,
+            expect![[r#"
+                *iter*
+                ```rust
+                Iter<Scan<OtherStruct<OtherStruct<i32>>, |&mut u32, &u32, &mut u32| -> Option<u32>, u32>>
+                ```
+            "#]],
         );
     }
 
     #[test]
     fn hover_shows_fn_signature() {
         // Single file with result
-        check_hover_result(
+        check(
             r#"
-            //- /main.rs
-            pub fn foo() -> u32 { 1 }
-
-            fn main() {
-                let foo_test = fo<|>o();
-            }
-        "#,
-            &["pub fn foo() -> u32"],
+pub fn foo() -> u32 { 1 }
+
+fn main() { let foo_test = fo<|>o(); }
+"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                pub fn foo() -> u32
+                ```
+            "#]],
         );
 
         // Multiple candidates but results are ambiguous.
-        check_hover_result(
+        check(
             r#"
-            //- /a.rs
-            pub fn foo() -> u32 { 1 }
+//- /a.rs
+pub fn foo() -> u32 { 1 }
 
-            //- /b.rs
-            pub fn foo() -> &str { "" }
+//- /b.rs
+pub fn foo() -> &str { "" }
 
-            //- /c.rs
-            pub fn foo(a: u32, b: u32) {}
+//- /c.rs
+pub fn foo(a: u32, b: u32) {}
 
-            //- /main.rs
-            mod a;
-            mod b;
-            mod c;
+//- /main.rs
+mod a;
+mod b;
+mod c;
 
-            fn main() {
-                let foo_test = fo<|>o();
-            }
+fn main() { let foo_test = fo<|>o(); }
         "#,
-            &["{unknown}"],
+            expect![[r#"
+                *foo*
+                ```rust
+                {unknown}
+                ```
+            "#]],
         );
     }
 
     #[test]
     fn hover_shows_fn_signature_with_type_params() {
-        check_hover_result(
+        check(
             r#"
-            //- /main.rs
-            pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str { }
+pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str { }
 
-            fn main() {
-                let foo_test = fo<|>o();
-            }
+fn main() { let foo_test = fo<|>o(); }
         "#,
-            &["pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str"],
+            expect![[r#"
+                *foo*
+                ```rust
+                pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str
+                ```
+            "#]],
         );
     }
 
     #[test]
     fn hover_shows_fn_signature_on_fn_name() {
-        check_hover_result(
+        check(
             r#"
-            //- /main.rs
-            pub fn foo<|>(a: u32, b: u32) -> u32 {}
-
-            fn main() {
-            }
-        "#,
-            &["pub fn foo(a: u32, b: u32) -> u32"],
+pub fn foo<|>(a: u32, b: u32) -> u32 {}
+
+fn main() { }
+"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                pub fn foo(a: u32, b: u32) -> u32
+                ```
+            "#]],
         );
     }
 
     #[test]
     fn hover_shows_struct_field_info() {
         // Hovering over the field when instantiating
-        check_hover_result(
+        check(
             r#"
-            //- /main.rs
-            struct Foo {
-                field_a: u32,
-            }
+struct Foo { field_a: u32 }
 
-            fn main() {
-                let foo = Foo {
-                    field_a<|>: 0,
-                };
-            }
-        "#,
-            &["Foo\n```\n\n```rust\nfield_a: u32"],
+fn main() {
+    let foo = Foo { field_a<|>: 0, };
+}
+"#,
+            expect![[r#"
+                *field_a*
+                ```rust
+                Foo
+                ```
+
+                ```rust
+                field_a: u32
+                ```
+            "#]],
         );
 
         // Hovering over the field in the definition
-        check_hover_result(
+        check(
             r#"
-            //- /main.rs
-            struct Foo {
-                field_a<|>: u32,
-            }
+struct Foo { field_a<|>: u32 }
 
-            fn main() {
-                let foo = Foo {
-                    field_a: 0,
-                };
-            }
-        "#,
-            &["Foo\n```\n\n```rust\nfield_a: u32"],
+fn main() {
+    let foo = Foo { field_a: 0 };
+}
+"#,
+            expect![[r#"
+                *field_a*
+                ```rust
+                Foo
+                ```
+
+                ```rust
+                field_a: u32
+                ```
+            "#]],
         );
     }
 
     #[test]
     fn hover_const_static() {
-        check_hover_result(
-            r#"
-            //- /main.rs
-            const foo<|>: u32 = 0;
-        "#,
-            &["const foo: u32"],
+        check(
+            r#"const foo<|>: u32 = 0;"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                const foo: u32
+                ```
+            "#]],
         );
-
-        check_hover_result(
-            r#"
-            //- /main.rs
-            static foo<|>: u32 = 0;
-        "#,
-            &["static foo: u32"],
+        check(
+            r#"static foo<|>: u32 = 0;"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                static foo: u32
+                ```
+            "#]],
         );
     }
 
     #[test]
     fn hover_default_generic_types() {
-        check_hover_result(
+        check(
             r#"
-//- /main.rs
-struct Test<K, T = u8> {
-    k: K,
-    t: T,
-}
+struct Test<K, T = u8> { k: K, t: T }
 
 fn main() {
-    let zz<|> = Test { t: 23, k: 33 };
+    let zz<|> = Test { t: 23u8, k: 33 };
 }"#,
-            &["Test<i32, u8>"],
+            expect![[r#"
+                *zz*
+                ```rust
+                Test<i32, u8>
+                ```
+            "#]],
         );
     }
 
     #[test]
     fn hover_some() {
-        let (analysis, position) = single_file_with_position(
-            "
-            enum Option<T> { Some(T) }
-            use Option::Some;
-
-            fn main() {
-                So<|>me(12);
-            }
-            ",
+        check(
+            r#"
+enum Option<T> { Some(T) }
+use Option::Some;
+
+fn main() { So<|>me(12); }
+"#,
+            expect![[r#"
+                *Some*
+                ```rust
+                Option
+                ```
+
+                ```rust
+                Some
+                ```
+            "#]],
         );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("Option\n```\n\n```rust\nSome"));
-
-        let (analysis, position) = single_file_with_position(
-            "
-            enum Option<T> { Some(T) }
-            use Option::Some;
 
-            fn main() {
-                let b<|>ar = Some(12);
-            }
-            ",
+        check(
+            r#"
+enum Option<T> { Some(T) }
+use Option::Some;
+
+fn main() { let b<|>ar = Some(12); }
+"#,
+            expect![[r#"
+                *bar*
+                ```rust
+                Option<i32>
+                ```
+            "#]],
         );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("Option<i32>"));
     }
 
     #[test]
     fn hover_enum_variant() {
-        check_hover_result(
+        check(
             r#"
-            //- /main.rs
-            enum Option<T> {
-                /// The None variant
-                Non<|>e
-            }
-        "#,
-            &["
-Option
-```
-
-```rust
-None
-```
-___
-
-The None variant
-            "
-            .trim()],
+enum Option<T> {
+    /// The None variant
+    Non<|>e
+}
+"#,
+            expect![[r#"
+                *None*
+                ```rust
+                Option
+                ```
+
+                ```rust
+                None
+                ```
+                ___
+
+                The None variant
+            "#]],
         );
 
-        check_hover_result(
+        check(
             r#"
-            //- /main.rs
-            enum Option<T> {
-                /// The Some variant
-                Some(T)
-            }
-            fn main() {
-                let s = Option::Som<|>e(12);
-            }
-        "#,
-            &["
-Option
-```
-
-```rust
-Some
-```
-___
-
-The Some variant
-            "
-            .trim()],
+enum Option<T> {
+    /// The Some variant
+    Some(T)
+}
+fn main() {
+    let s = Option::Som<|>e(12);
+}
+"#,
+            expect![[r#"
+                *Some*
+                ```rust
+                Option
+                ```
+
+                ```rust
+                Some
+                ```
+                ___
+
+                The Some variant
+            "#]],
         );
     }
 
     #[test]
     fn hover_for_local_variable() {
-        let (analysis, position) = single_file_with_position("fn func(foo: i32) { fo<|>o; }");
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
+        check(
+            r#"fn func(foo: i32) { fo<|>o; }"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                i32
+                ```
+            "#]],
+        )
     }
 
     #[test]
     fn hover_for_local_variable_pat() {
-        let (analysis, position) = single_file_with_position("fn func(fo<|>o: i32) {}");
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
+        check(
+            r#"fn func(fo<|>o: i32) {}"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                i32
+                ```
+            "#]],
+        )
     }
 
     #[test]
     fn hover_local_var_edge() {
-        let (analysis, position) = single_file_with_position(
-            "
-fn func(foo: i32) { if true { <|>foo; }; }
-",
-        );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
+        check(
+            r#"fn func(foo: i32) { if true { <|>foo; }; }"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                i32
+                ```
+            "#]],
+        )
     }
 
     #[test]
     fn hover_for_param_edge() {
-        let (analysis, position) = single_file_with_position("fn func(<|>foo: i32) {}");
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
+        check(
+            r#"fn func(<|>foo: i32) {}"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                i32
+                ```
+            "#]],
+        )
     }
 
     #[test]
     fn test_hover_infer_associated_method_result() {
-        let (analysis, position) = single_file_with_position(
-            "
-            struct Thing { x: u32 }
+        check(
+            r#"
+struct Thing { x: u32 }
 
-            impl Thing {
-                fn new() -> Thing {
-                    Thing { x: 0 }
-                }
-            }
+impl Thing {
+    fn new() -> Thing { Thing { x: 0 } }
+}
 
-            fn main() {
-                let foo_<|>test = Thing::new();
-            }
-            ",
-        );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("Thing"));
+fn main() { let foo_<|>test = Thing::new(); }
+            "#,
+            expect![[r#"
+                *foo_test*
+                ```rust
+                Thing
+                ```
+            "#]],
+        )
     }
 
     #[test]
     fn test_hover_infer_associated_method_exact() {
-        let (analysis, position) = single_file_with_position(
-            "
-            mod wrapper {
-                struct Thing { x: u32 }
+        check(
+            r#"
+mod wrapper {
+    struct Thing { x: u32 }
 
-                impl Thing {
-                    fn new() -> Thing {
-                        Thing { x: 0 }
-                    }
-                }
-            }
+    impl Thing {
+        fn new() -> Thing { Thing { x: 0 } }
+    }
+}
 
-            fn main() {
-                let foo_test = wrapper::Thing::new<|>();
-            }
-            ",
-        );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(
-            trim_markup_opt(hover.info.first()),
-            Some("wrapper::Thing\n```\n\n```rust\nfn new() -> Thing")
-        );
+fn main() { let foo_test = wrapper::Thing::new<|>(); }
+"#,
+            expect![[r#"
+                *new*
+                ```rust
+                wrapper::Thing
+                ```
+
+                ```rust
+                fn new() -> Thing
+                ```
+            "#]],
+        )
     }
 
     #[test]
     fn test_hover_infer_associated_const_in_pattern() {
-        let (analysis, position) = single_file_with_position(
-            "
-            struct X;
-            impl X {
-                const C: u32 = 1;
-            }
+        check(
+            r#"
+struct X;
+impl X {
+    const C: u32 = 1;
+}
 
-            fn main() {
-                match 1 {
-                    X::C<|> => {},
-                    2 => {},
-                    _ => {}
-                };
-            }
-            ",
-        );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("const C: u32"));
+fn main() {
+    match 1 {
+        X::C<|> => {},
+        2 => {},
+        _ => {}
+    };
+}
+"#,
+            expect![[r#"
+                *C*
+                ```rust
+                const C: u32
+                ```
+            "#]],
+        )
     }
 
     #[test]
     fn test_hover_self() {
-        let (analysis, position) = single_file_with_position(
-            "
-            struct Thing { x: u32 }
-            impl Thing {
-                fn new() -> Self {
-                    Self<|> { x: 0 }
-                }
-            }
-        ",
-        );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("Thing"));
-
-        /* FIXME: revive these tests
-                let (analysis, position) = single_file_with_position(
-                    "
-                    struct Thing { x: u32 }
-                    impl Thing {
-                        fn new() -> Self<|> {
-                            Self { x: 0 }
-                        }
-                    }
-                    ",
-                );
-
-                let hover = analysis.hover(position).unwrap().unwrap();
-                assert_eq!(trim_markup_opt(hover.info.first()), Some("Thing"));
-
-                let (analysis, position) = single_file_with_position(
-                    "
-                    enum Thing { A }
-                    impl Thing {
-                        pub fn new() -> Self<|> {
-                            Thing::A
-                        }
-                    }
-                    ",
-                );
-                let hover = analysis.hover(position).unwrap().unwrap();
-                assert_eq!(trim_markup_opt(hover.info.first()), Some("enum Thing"));
-
-                let (analysis, position) = single_file_with_position(
-                    "
-                    enum Thing { A }
-                    impl Thing {
-                        pub fn thing(a: Self<|>) {
-                        }
-                    }
-                    ",
-                );
-                let hover = analysis.hover(position).unwrap().unwrap();
-                assert_eq!(trim_markup_opt(hover.info.first()), Some("enum Thing"));
-        */
-    }
+        check(
+            r#"
+struct Thing { x: u32 }
+impl Thing {
+    fn new() -> Self { Self<|> { x: 0 } }
+}
+"#,
+            expect![[r#"
+                *Self { x: 0 }*
+                ```rust
+                Thing
+                ```
+            "#]],
+        )
+    } /* FIXME: revive these tests
+              let (analysis, position) = analysis_and_position(
+                  "
+                  struct Thing { x: u32 }
+                  impl Thing {
+                      fn new() -> Self<|> {
+                          Self { x: 0 }
+                      }
+                  }
+                  ",
+              );
+
+              let hover = analysis.hover(position).unwrap().unwrap();
+              assert_eq!(trim_markup(&hover.info.markup.as_str()), ("Thing"));
+
+              let (analysis, position) = analysis_and_position(
+                  "
+                  enum Thing { A }
+                  impl Thing {
+                      pub fn new() -> Self<|> {
+                          Thing::A
+                      }
+                  }
+                  ",
+              );
+              let hover = analysis.hover(position).unwrap().unwrap();
+              assert_eq!(trim_markup(&hover.info.markup.as_str()), ("enum Thing"));
+
+              let (analysis, position) = analysis_and_position(
+                  "
+                  enum Thing { A }
+                  impl Thing {
+                      pub fn thing(a: Self<|>) {
+                      }
+                  }
+                  ",
+              );
+              let hover = analysis.hover(position).unwrap().unwrap();
+              assert_eq!(trim_markup(&hover.info.markup.as_str()), ("enum Thing"));
+      */
 
     #[test]
     fn test_hover_shadowing_pat() {
-        let (analysis, position) = single_file_with_position(
-            "
-            fn x() {}
+        check(
+            r#"
+fn x() {}
 
-            fn y() {
-                let x = 0i32;
-                x<|>;
-            }
-            ",
-        );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
+fn y() {
+    let x = 0i32;
+    x<|>;
+}
+"#,
+            expect![[r#"
+                *x*
+                ```rust
+                i32
+                ```
+            "#]],
+        )
     }
 
     #[test]
     fn test_hover_macro_invocation() {
-        let (analysis, position) = single_file_with_position(
-            "
-            macro_rules! foo {
-                () => {}
-            }
-
-            fn f() {
-                fo<|>o!();
-            }
-            ",
-        );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("macro_rules! foo"));
+        check(
+            r#"
+macro_rules! foo { () => {} }
+
+fn f() { fo<|>o!(); }
+"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                macro_rules! foo
+                ```
+            "#]],
+        )
     }
 
     #[test]
     fn test_hover_tuple_field() {
-        let (analysis, position) = single_file_with_position(
-            "
-            struct TS(String, i32<|>);
-            ",
-        );
-        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
+        check(
+            r#"struct TS(String, i32<|>);"#,
+            expect![[r#"
+                *i32*
+                i32
+            "#]],
+        )
     }
 
     #[test]
     fn test_hover_through_macro() {
-        let hover_on = check_hover_result(
-            "
-            //- /lib.rs
-            macro_rules! id {
-                ($($tt:tt)*) => { $($tt)* }
-            }
-            fn foo() {}
-            id! {
-                fn bar() {
-                    fo<|>o();
-                }
-            }
-            ",
-            &["fn foo()"],
+        check(
+            r#"
+macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
+fn foo() {}
+id! {
+    fn bar() { fo<|>o(); }
+}
+"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                fn foo()
+                ```
+            "#]],
         );
-
-        assert_eq!(hover_on, "foo")
     }
 
     #[test]
     fn test_hover_through_expr_in_macro() {
-        let hover_on = check_hover_result(
-            "
-            //- /lib.rs
-            macro_rules! id {
-                ($($tt:tt)*) => { $($tt)* }
-            }
-            fn foo(bar:u32) {
-                let a = id!(ba<|>r);
-            }
-            ",
-            &["u32"],
+        check(
+            r#"
+macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
+fn foo(bar:u32) { let a = id!(ba<|>r); }
+"#,
+            expect![[r#"
+                *bar*
+                ```rust
+                u32
+                ```
+            "#]],
         );
-
-        assert_eq!(hover_on, "bar")
     }
 
     #[test]
     fn test_hover_through_expr_in_macro_recursive() {
-        let hover_on = check_hover_result(
-            "
-            //- /lib.rs
-            macro_rules! id_deep {
-                ($($tt:tt)*) => { $($tt)* }
-            }
-            macro_rules! id {
-                ($($tt:tt)*) => { id_deep!($($tt)*) }
-            }
-            fn foo(bar:u32) {
-                let a = id!(ba<|>r);
-            }
-            ",
-            &["u32"],
+        check(
+            r#"
+macro_rules! id_deep { ($($tt:tt)*) => { $($tt)* } }
+macro_rules! id { ($($tt:tt)*) => { id_deep!($($tt)*) } }
+fn foo(bar:u32) { let a = id!(ba<|>r); }
+"#,
+            expect![[r#"
+                *bar*
+                ```rust
+                u32
+                ```
+            "#]],
         );
-
-        assert_eq!(hover_on, "bar")
     }
 
     #[test]
     fn test_hover_through_func_in_macro_recursive() {
-        let hover_on = check_hover_result(
-            "
-            //- /lib.rs
-            macro_rules! id_deep {
-                ($($tt:tt)*) => { $($tt)* }
-            }
-            macro_rules! id {
-                ($($tt:tt)*) => { id_deep!($($tt)*) }
-            }
-            fn bar() -> u32 {
-                0
-            }
-            fn foo() {
-                let a = id!([0u32, bar(<|>)] );
-            }
-            ",
-            &["u32"],
+        check(
+            r#"
+macro_rules! id_deep { ($($tt:tt)*) => { $($tt)* } }
+macro_rules! id { ($($tt:tt)*) => { id_deep!($($tt)*) } }
+fn bar() -> u32 { 0 }
+fn foo() { let a = id!([0u32, bar(<|>)] ); }
+"#,
+            expect![[r#"
+                *bar()*
+                ```rust
+                u32
+                ```
+            "#]],
         );
-
-        assert_eq!(hover_on, "bar()")
     }
 
     #[test]
     fn test_hover_through_literal_string_in_macro() {
-        let hover_on = check_hover_result(
+        check(
             r#"
-            //- /lib.rs
-            macro_rules! arr {
-                ($($tt:tt)*) => { [$($tt)*)] }
-            }
-            fn foo() {
-                let mastered_for_itunes = "";
-                let _ = arr!("Tr<|>acks", &mastered_for_itunes);
-            }
-            "#,
-            &["&str"],
+macro_rules! arr { ($($tt:tt)*) => { [$($tt)*)] } }
+fn foo() {
+    let mastered_for_itunes = "";
+    let _ = arr!("Tr<|>acks", &mastered_for_itunes);
+}
+"#,
+            expect![[r#"
+                *"Tracks"*
+                ```rust
+                &str
+                ```
+            "#]],
         );
-
-        assert_eq!(hover_on, "\"Tracks\"");
     }
 
     #[test]
     fn test_hover_through_assert_macro() {
-        let hover_on = check_hover_result(
+        check(
             r#"
-            //- /lib.rs
-            #[rustc_builtin_macro]
-            macro_rules! assert {}
+#[rustc_builtin_macro]
+macro_rules! assert {}
 
-            fn bar() -> bool { true }
-            fn foo() {
-                assert!(ba<|>r());
-            }
-            "#,
-            &["fn bar() -> bool"],
+fn bar() -> bool { true }
+fn foo() {
+    assert!(ba<|>r());
+}
+"#,
+            expect![[r#"
+                *bar*
+                ```rust
+                fn bar() -> bool
+                ```
+            "#]],
         );
-
-        assert_eq!(hover_on, "bar");
     }
 
     #[test]
     fn test_hover_through_literal_string_in_builtin_macro() {
         check_hover_no_result(
             r#"
-            //- /lib.rs
             #[rustc_builtin_macro]
             macro_rules! format {}
 
@@ -884,71 +1037,1351 @@ fn func(foo: i32) { if true { <|>foo; }; }
 
     #[test]
     fn test_hover_non_ascii_space_doc() {
-        check_hover_result(
+        check(
             "
-            //- /lib.rs
-            ///　<- `\u{3000}` here
-            fn foo() {
-            }
+///　<- `\u{3000}` here
+fn foo() { }
 
-            fn bar() {
-                fo<|>o();
-            }
-            ",
-            &["fn foo()\n```\n___\n\n<- `\u{3000}` here"],
+fn bar() { fo<|>o(); }
+",
+            expect![[r#"
+                *foo*
+                ```rust
+                fn foo()
+                ```
+                ___
+
+                <- `　` here
+            "#]],
         );
     }
 
     #[test]
     fn test_hover_function_show_qualifiers() {
-        check_hover_result(
-            "
-            //- /lib.rs
-            async fn foo<|>() {}
-            ",
-            &["async fn foo()"],
+        check(
+            r#"async fn foo<|>() {}"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                async fn foo()
+                ```
+            "#]],
         );
-        check_hover_result(
-            "
-            //- /lib.rs
-            pub const unsafe fn foo<|>() {}
-            ",
-            &["pub const unsafe fn foo()"],
+        check(
+            r#"pub const unsafe fn foo<|>() {}"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                pub const unsafe fn foo()
+                ```
+            "#]],
         );
-        check_hover_result(
-            r#"
-            //- /lib.rs
-            pub(crate) async unsafe extern "C" fn foo<|>() {}
-            "#,
-            &[r#"pub(crate) async unsafe extern "C" fn foo()"#],
+        check(
+            r#"pub(crate) async unsafe extern "C" fn foo<|>() {}"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                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"],
+        check_actions(
+            r"unsafe trait foo<|>() {}",
+            expect![[r#"
+                [
+                    Implementaion(
+                        FilePosition {
+                            file_id: FileId(
+                                1,
+                            ),
+                            offset: 13,
+                        },
+                    ),
+                ]
+            "#]],
         );
     }
 
     #[test]
     fn test_hover_mod_with_same_name_as_function() {
-        check_hover_result(
-            "
-            //- /lib.rs
-            use self::m<|>y::Bar;
+        check(
+            r#"
+use self::m<|>y::Bar;
+mod my { pub struct Bar; }
+
+fn my() {}
+"#,
+            expect![[r#"
+                *my*
+                ```rust
+                mod my
+                ```
+            "#]],
+        );
+    }
 
-            mod my {
-                pub struct Bar;
-            }
+    #[test]
+    fn test_hover_struct_doc_comment() {
+        check(
+            r#"
+/// bar docs
+struct Bar;
+
+fn foo() { let bar = Ba<|>r; }
+"#,
+            expect![[r#"
+                *Bar*
+                ```rust
+                struct Bar
+                ```
+                ___
+
+                bar docs
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_struct_doc_attr() {
+        check(
+            r#"
+#[doc = "bar docs"]
+struct Bar;
+
+fn foo() { let bar = Ba<|>r; }
+"#,
+            expect![[r#"
+                *Bar*
+                ```rust
+                struct Bar
+                ```
+                ___
+
+                bar docs
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_struct_doc_attr_multiple_and_mixed() {
+        check(
+            r#"
+/// bar docs 0
+#[doc = "bar docs 1"]
+#[doc = "bar docs 2"]
+struct Bar;
+
+fn foo() { let bar = Ba<|>r; }
+"#,
+            expect![[r#"
+                *Bar*
+                ```rust
+                struct Bar
+                ```
+                ___
+
+                bar docs 0
+
+                bar docs 1
+
+                bar docs 2
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_macro_generated_struct_fn_doc_comment() {
+        mark::check!(hover_macro_generated_struct_fn_doc_comment);
+
+        check(
+            r#"
+macro_rules! bar {
+    () => {
+        struct Bar;
+        impl Bar {
+            /// Do the foo
+            fn foo(&self) {}
+        }
+    }
+}
+
+bar!();
+
+fn foo() { let bar = Bar; bar.fo<|>o(); }
+"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                Bar
+                ```
+
+                ```rust
+                fn foo(&self)
+                ```
+                ___
+
+                 Do the foo
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_macro_generated_struct_fn_doc_attr() {
+        mark::check!(hover_macro_generated_struct_fn_doc_attr);
+
+        check(
+            r#"
+macro_rules! bar {
+    () => {
+        struct Bar;
+        impl Bar {
+            #[doc = "Do the foo"]
+            fn foo(&self) {}
+        }
+    }
+}
+
+bar!();
+
+fn foo() { let bar = Bar; bar.fo<|>o(); }
+"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                Bar
+                ```
+
+                ```rust
+                fn foo(&self)
+                ```
+                ___
+
+                Do the foo
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_trait_has_impl_action() {
+        check_actions(
+            r#"trait foo<|>() {}"#,
+            expect![[r#"
+                [
+                    Implementaion(
+                        FilePosition {
+                            file_id: FileId(
+                                1,
+                            ),
+                            offset: 6,
+                        },
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_struct_has_impl_action() {
+        check_actions(
+            r"struct foo<|>() {}",
+            expect![[r#"
+                [
+                    Implementaion(
+                        FilePosition {
+                            file_id: FileId(
+                                1,
+                            ),
+                            offset: 7,
+                        },
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_union_has_impl_action() {
+        check_actions(
+            r#"union foo<|>() {}"#,
+            expect![[r#"
+                [
+                    Implementaion(
+                        FilePosition {
+                            file_id: FileId(
+                                1,
+                            ),
+                            offset: 6,
+                        },
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_enum_has_impl_action() {
+        check_actions(
+            r"enum foo<|>() { A, B }",
+            expect![[r#"
+                [
+                    Implementaion(
+                        FilePosition {
+                            file_id: FileId(
+                                1,
+                            ),
+                            offset: 5,
+                        },
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_test_has_action() {
+        check_actions(
+            r#"
+#[test]
+fn foo_<|>test() {}
+"#,
+            expect![[r#"
+                [
+                    Runnable(
+                        Runnable {
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..24,
+                                name: "foo_test",
+                                kind: FN_DEF,
+                                focus_range: Some(
+                                    11..19,
+                                ),
+                                container_name: None,
+                                description: None,
+                                docs: None,
+                            },
+                            kind: Test {
+                                test_id: Path(
+                                    "foo_test",
+                                ),
+                                attr: TestAttr {
+                                    ignore: false,
+                                },
+                            },
+                            cfg_exprs: [],
+                        },
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_test_mod_has_action() {
+        check_actions(
+            r#"
+mod tests<|> {
+    #[test]
+    fn foo_test() {}
+}
+"#,
+            expect![[r#"
+                [
+                    Runnable(
+                        Runnable {
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..46,
+                                name: "tests",
+                                kind: MODULE,
+                                focus_range: Some(
+                                    4..9,
+                                ),
+                                container_name: None,
+                                description: None,
+                                docs: None,
+                            },
+                            kind: TestMod {
+                                path: "tests",
+                            },
+                            cfg_exprs: [],
+                        },
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_struct_has_goto_type_action() {
+        check_actions(
+            r#"
+struct S{ f1: u32 }
+
+fn main() { let s<|>t = S{ f1:0 }; }
+            "#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "S",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..19,
+                                    name: "S",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        7..8,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_generic_struct_has_goto_type_actions() {
+        check_actions(
+            r#"
+struct Arg(u32);
+struct S<T>{ f1: T }
+
+fn main() { let s<|>t = S{ f1:Arg(0) }; }
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "S",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 17..37,
+                                    name: "S",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        24..25,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "Arg",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..16,
+                                    name: "Arg",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        7..10,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct Arg",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_generic_struct_has_flattened_goto_type_actions() {
+        check_actions(
+            r#"
+struct Arg(u32);
+struct S<T>{ f1: T }
+
+fn main() { let s<|>t = S{ f1: S{ f1: Arg(0) } }; }
+            "#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "S",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 17..37,
+                                    name: "S",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        24..25,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "Arg",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..16,
+                                    name: "Arg",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        7..10,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct Arg",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_tuple_has_goto_type_actions() {
+        check_actions(
+            r#"
+struct A(u32);
+struct B(u32);
+mod M {
+    pub struct C(u32);
+}
+
+fn main() { let s<|>t = (A(1), B(2), M::C(3) ); }
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "A",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..14,
+                                    name: "A",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        7..8,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct A",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "B",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 15..29,
+                                    name: "B",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        22..23,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct B",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "M::C",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 42..60,
+                                    name: "C",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        53..54,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "pub struct C",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_return_impl_trait_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo {}
+fn foo() -> impl Foo {}
+
+fn main() { let s<|>t = foo(); }
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..12,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_generic_return_impl_trait_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo<T> {}
+struct S;
+fn foo() -> impl Foo<S> {}
+
+fn main() { let s<|>t = foo(); }
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..15,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "S",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 16..25,
+                                    name: "S",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        23..24,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_return_impl_traits_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo {}
+trait Bar {}
+fn foo() -> impl Foo + Bar {}
+
+fn main() { let s<|>t = foo(); }
+            "#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..12,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "Bar",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 13..25,
+                                    name: "Bar",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        19..22,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Bar",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_generic_return_impl_traits_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo<T> {}
+trait Bar<T> {}
+struct S1 {}
+struct S2 {}
+
+fn foo() -> impl Foo<S1> + Bar<S2> {}
+
+fn main() { let s<|>t = foo(); }
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..15,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "Bar",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 16..31,
+                                    name: "Bar",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        22..25,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Bar",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "S1",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 32..44,
+                                    name: "S1",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        39..41,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S1",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "S2",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 45..57,
+                                    name: "S2",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        52..54,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S2",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_arg_impl_trait_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo {}
+fn foo(ar<|>g: &impl Foo) {}
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..12,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_arg_impl_traits_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo {}
+trait Bar<T> {}
+struct S{}
+
+fn foo(ar<|>g: &impl Foo + Bar<S>) {}
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..12,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "Bar",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 13..28,
+                                    name: "Bar",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        19..22,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Bar",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "S",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 29..39,
+                                    name: "S",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        36..37,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_arg_generic_impl_trait_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo<T> {}
+struct S {}
+fn foo(ar<|>g: &impl Foo<S>) {}
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..15,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "S",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 16..27,
+                                    name: "S",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        23..24,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_dyn_return_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo {}
+struct S;
+impl Foo for S {}
+
+struct B<T>{}
+fn foo() -> B<dyn Foo> {}
+
+fn main() { let s<|>t = foo(); }
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "B",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 42..55,
+                                    name: "B",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        49..50,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct B",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..12,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_dyn_arg_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo {}
+fn foo(ar<|>g: &dyn Foo) {}
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..12,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_generic_dyn_arg_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo<T> {}
+struct S {}
+fn foo(ar<|>g: &dyn Foo<S>) {}
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..15,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "S",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 16..27,
+                                    name: "S",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        23..24,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_goto_type_action_links_order() {
+        check_actions(
+            r#"
+trait ImplTrait<T> {}
+trait DynTrait<T> {}
+struct B<T> {}
+struct S {}
+
+fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
+            "#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "ImplTrait",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..21,
+                                    name: "ImplTrait",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..15,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait ImplTrait",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "B",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 43..57,
+                                    name: "B",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        50..51,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct B",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "DynTrait",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 22..42,
+                                    name: "DynTrait",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        28..36,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait DynTrait",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                            HoverGotoTypeData {
+                                mod_path: "S",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 58..69,
+                                    name: "S",
+                                    kind: STRUCT_DEF,
+                                    focus_range: Some(
+                                        65..66,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "struct S",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_hover_associated_type_has_goto_type_action() {
+        check_actions(
+            r#"
+trait Foo {
+    type Item;
+    fn get(self) -> Self::Item {}
+}
 
-            fn my() {}
-            ",
-            &["mod my"],
+struct Bar{}
+struct S{}
+
+impl Foo for S { type Item = Bar; }
+
+fn test() -> impl Foo { S {} }
+
+fn main() { let s<|>t = test().get(); }
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        1,
+                                    ),
+                                    full_range: 0..62,
+                                    name: "Foo",
+                                    kind: TRAIT_DEF,
+                                    focus_range: Some(
+                                        6..9,
+                                    ),
+                                    container_name: None,
+                                    description: Some(
+                                        "trait Foo",
+                                    ),
+                                    docs: None,
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
         );
     }
 }
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 75bd3c96b..3cbae8a45 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -3,7 +3,7 @@ use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
     ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
-    match_ast, Direction, NodeOrToken, SmolStr, SyntaxKind, TextRange,
+    match_ast, Direction, NodeOrToken, SmolStr, SyntaxKind, TextRange, T,
 };
 
 use crate::{FileId, FunctionSignature};
@@ -112,7 +112,7 @@ fn get_chaining_hints(
     // Ignoring extra whitespace and comments
     let next = tokens.next()?.kind();
     let next_next = tokens.next()?.kind();
-    if next == SyntaxKind::WHITESPACE && next_next == SyntaxKind::DOT {
+    if next == SyntaxKind::WHITESPACE && next_next == T![.] {
         let ty = sema.type_of_expr(&expr)?;
         if ty.is_unknown() {
             return None;
@@ -149,11 +149,10 @@ fn get_param_name_hints(
         ast::Expr::MethodCallExpr(expr) => expr.arg_list()?.args(),
         _ => return None,
     };
-    let args_count = args.clone().count();
 
     let fn_signature = get_fn_signature(sema, &expr)?;
     let n_params_to_skip =
-        if fn_signature.has_self_param && fn_signature.parameter_names.len() > args_count {
+        if fn_signature.has_self_param && matches!(&expr, ast::Expr::MethodCallExpr(_)) {
             1
         } else {
             0
@@ -259,6 +258,7 @@ fn should_show_param_name_hint(
     if param_name.is_empty()
         || Some(param_name) == fn_signature.name.as_ref().map(|s| s.trim_start_matches('_'))
         || is_argument_similar_to_param_name(sema, argument, param_name)
+        || param_name.starts_with("ra_fixture")
     {
         return false;
     }
@@ -271,7 +271,7 @@ fn should_show_param_name_hint(
 
     // avoid displaying hints for common functions like map, filter, etc.
     // or other obvious words used in std
-    parameters_len != 1 || !is_obvious_param(param_name)
+    !(parameters_len == 1 && is_obvious_param(param_name))
 }
 
 fn is_argument_similar_to_param_name(
@@ -313,10 +313,8 @@ fn get_string_representation(expr: &ast::Expr) -> Option<String> {
 }
 
 fn is_obvious_param(param_name: &str) -> bool {
-    let is_obvious_param_name = match param_name {
-        "predicate" | "value" | "pat" | "rhs" | "other" => true,
-        _ => false,
-    };
+    let is_obvious_param_name =
+        matches!(param_name, "predicate" | "value" | "pat" | "rhs" | "other");
     param_name.len() == 1 || is_obvious_param_name
 }
 
@@ -326,13 +324,13 @@ fn get_fn_signature(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<
             // FIXME: Type::as_callable is broken for closures
             let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
             match callable_def {
-                hir::CallableDef::FunctionId(it) => {
+                hir::CallableDefId::FunctionId(it) => {
                     Some(FunctionSignature::from_hir(sema.db, it.into()))
                 }
-                hir::CallableDef::StructId(it) => {
+                hir::CallableDefId::StructId(it) => {
                     FunctionSignature::from_struct(sema.db, it.into())
                 }
-                hir::CallableDef::EnumVariantId(it) => {
+                hir::CallableDefId::EnumVariantId(it) => {
                     FunctionSignature::from_enum_variant(sema.db, it.into())
                 }
             }
@@ -347,581 +345,252 @@ fn get_fn_signature(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<
 
 #[cfg(test)]
 mod tests {
-    use crate::inlay_hints::InlayHintsConfig;
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
+    use test_utils::extract_annotations;
+
+    use crate::{inlay_hints::InlayHintsConfig, mock_analysis::single_file};
 
-    use crate::mock_analysis::single_file;
+    fn check(ra_fixture: &str) {
+        check_with_config(InlayHintsConfig::default(), ra_fixture);
+    }
+
+    fn check_with_config(config: InlayHintsConfig, ra_fixture: &str) {
+        let (analysis, file_id) = single_file(ra_fixture);
+        let expected = extract_annotations(&*analysis.file_text(file_id).unwrap());
+        let inlay_hints = analysis.inlay_hints(file_id, &config).unwrap();
+        let actual =
+            inlay_hints.into_iter().map(|it| (it.range, it.label.to_string())).collect::<Vec<_>>();
+        assert_eq!(expected, actual);
+    }
+
+    fn check_expect(config: InlayHintsConfig, ra_fixture: &str, expect: Expect) {
+        let (analysis, file_id) = single_file(ra_fixture);
+        let inlay_hints = analysis.inlay_hints(file_id, &config).unwrap();
+        expect.assert_debug_eq(&inlay_hints)
+    }
 
     #[test]
     fn param_hints_only() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
+            InlayHintsConfig {
+                parameter_hints: true,
+                type_hints: false,
+                chaining_hints: false,
+                max_length: None,
+            },
             r#"
-            fn foo(a: i32, b: i32) -> i32 { a + b }
-            fn main() {
-                let _x = foo(4, 4);
-            }"#,
+fn foo(a: i32, b: i32) -> i32 { a + b }
+fn main() {
+    let _x = foo(
+        4,
+      //^ a
+        4,
+      //^ b
+    );
+}"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 106..107,
-                kind: ParameterHint,
-                label: "a",
-            },
-            InlayHint {
-                range: 109..110,
-                kind: ParameterHint,
-                label: "b",
-            },
-        ]"###);
     }
 
     #[test]
     fn hints_disabled() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
+            InlayHintsConfig {
+                type_hints: false,
+                parameter_hints: false,
+                chaining_hints: false,
+                max_length: None,
+            },
             r#"
-            fn foo(a: i32, b: i32) -> i32 { a + b }
-            fn main() {
-                let _x = foo(4, 4);
-            }"#,
+fn foo(a: i32, b: i32) -> i32 { a + b }
+fn main() {
+    let _x = foo(4, 4);
+}"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: false, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"[]"###);
     }
 
     #[test]
     fn type_hints_only() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
+            InlayHintsConfig {
+                type_hints: true,
+                parameter_hints: false,
+                chaining_hints: false,
+                max_length: None,
+            },
             r#"
-            fn foo(a: i32, b: i32) -> i32 { a + b }
-            fn main() {
-                let _x = foo(4, 4);
-            }"#,
+fn foo(a: i32, b: i32) -> i32 { a + b }
+fn main() {
+    let _x = foo(4, 4);
+      //^^ i32
+}"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 97..99,
-                kind: TypeHint,
-                label: "i32",
-            },
-        ]"###);
     }
+
     #[test]
     fn default_generic_types_should_not_be_displayed() {
-        let (analysis, file_id) = single_file(
+        check(
             r#"
-struct Test<K, T = u8> {
-    k: K,
-    t: T,
-}
+struct Test<K, T = u8> { k: K, t: T }
 
 fn main() {
-    let zz = Test { t: 23, k: 33 };
+    let zz = Test { t: 23u8, k: 33 };
+      //^^ Test<i32>
     let zz_ref = &zz;
+      //^^^^^^ &Test<i32>
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 69..71,
-                kind: TypeHint,
-                label: "Test<i32>",
-            },
-            InlayHint {
-                range: 105..111,
-                kind: TypeHint,
-                label: "&Test<i32>",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn let_statement() {
-        let (analysis, file_id) = single_file(
+        check(
             r#"
 #[derive(PartialEq)]
-enum CustomOption<T> {
-    None,
-    Some(T),
-}
+enum Option<T> { None, Some(T) }
 
 #[derive(PartialEq)]
-struct Test {
-    a: CustomOption<u32>,
-    b: u8,
-}
+struct Test { a: Option<u32>, b: u8 }
 
 fn main() {
     struct InnerStruct {}
 
     let test = 54;
+      //^^^^ i32
     let test: i32 = 33;
     let mut test = 33;
+      //^^^^^^^^ i32
     let _ = 22;
     let test = "test";
+      //^^^^ &str
     let test = InnerStruct {};
 
-    let test = vec![222];
-    let test: Vec<_> = (0..3).collect();
-    let test = (0..3).collect::<Vec<i128>>();
-    let test = (0..3).collect::<Vec<_>>();
-
-    let mut test = Vec::new();
-    test.push(333);
+    let test = unresolved();
 
     let test = (42, 'a');
-    let (a, (b, c, (d, e), f)) = (2, (3, 4, (6.6, 7.7), 5));
+      //^^^^ (i32, char)
+    let (a,    (b,     (c,)) = (2, (3, (9.2,));
+       //^ i32  ^ i32   ^ f64
     let &x = &92;
+       //^ i32
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 193..197,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 236..244,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 275..279,
-                kind: TypeHint,
-                label: "&str",
-            },
-            InlayHint {
-                range: 539..543,
-                kind: TypeHint,
-                label: "(i32, char)",
-            },
-            InlayHint {
-                range: 566..567,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 570..571,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 573..574,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 577..578,
-                kind: TypeHint,
-                label: "f64",
-            },
-            InlayHint {
-                range: 580..581,
-                kind: TypeHint,
-                label: "f64",
-            },
-            InlayHint {
-                range: 584..585,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 627..628,
-                kind: TypeHint,
-                label: "i32",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn closure_parameters() {
-        let (analysis, file_id) = single_file(
+        check(
             r#"
 fn main() {
     let mut start = 0;
-    (0..2).for_each(|increment| {
-        start += increment;
-    });
+      //^^^^^^^^^ i32
+    (0..2).for_each(|increment| { start += increment; });
+                   //^^^^^^^^^ i32
 
-    let multiply = |a, b, c, d| a * b * c * d;
-    let _: i32 = multiply(1, 2, 3, 4);
+    let multiply =
+      //^^^^^^^^ |…| -> i32
+      | a,     b| a * b
+      //^ i32  ^ i32
+    ;
+
+    let _: i32 = multiply(1, 2);
     let multiply_ref = &multiply;
+      //^^^^^^^^^^^^ &|…| -> i32
 
     let return_42 = || 42;
+      //^^^^^^^^^ || -> i32
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 21..30,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 57..66,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 115..123,
-                kind: TypeHint,
-                label: "|…| -> i32",
-            },
-            InlayHint {
-                range: 127..128,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 130..131,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 133..134,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 136..137,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 201..213,
-                kind: TypeHint,
-                label: "&|…| -> i32",
-            },
-            InlayHint {
-                range: 236..245,
-                kind: TypeHint,
-                label: "|| -> i32",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn for_expression() {
-        let (analysis, file_id) = single_file(
+        check(
             r#"
 fn main() {
     let mut start = 0;
-    for increment in 0..2 {
-        start += increment;
-    }
+      //^^^^^^^^^ i32
+    for increment in 0..2 { start += increment; }
+      //^^^^^^^^^ i32
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 21..30,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 44..53,
-                kind: TypeHint,
-                label: "i32",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn if_expr() {
-        let (analysis, file_id) = single_file(
+        check(
             r#"
-#[derive(PartialEq)]
-enum CustomOption<T> {
-    None,
-    Some(T),
-}
-
-#[derive(PartialEq)]
-struct Test {
-    a: CustomOption<u32>,
-    b: u8,
-}
+enum Option<T> { None, Some(T) }
+use Option::*;
 
-use CustomOption::*;
+struct Test { a: Option<u32>, b: u8 }
 
 fn main() {
     let test = Some(Test { a: Some(3), b: 1 });
+      //^^^^ Option<Test>
     if let None = &test {};
     if let test = &test {};
+         //^^^^ &Option<Test>
     if let Some(test) = &test {};
-    if let Some(Test { a, b }) = &test {};
-    if let Some(Test { a: x, b: y }) = &test {};
-    if let Some(Test { a: Some(x), b: y }) = &test {};
-    if let Some(Test { a: None, b: y }) = &test {};
+              //^^^^ &Test
+    if let Some(Test { a,             b }) = &test {};
+                     //^ &Option<u32> ^ &u8
+    if let Some(Test { a: x,             b: y }) = &test {};
+                        //^ &Option<u32>    ^ &u8
+    if let Some(Test { a: Some(x),  b: y }) = &test {};
+                             //^ &u32  ^ &u8
+    if let Some(Test { a: None,  b: y }) = &test {};
+                                  //^ &u8
     if let Some(Test { b: y, .. }) = &test {};
-
+                        //^ &u8
     if test == None {}
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 188..192,
-                kind: TypeHint,
-                label: "CustomOption<Test>",
-            },
-            InlayHint {
-                range: 267..271,
-                kind: TypeHint,
-                label: "&CustomOption<Test>",
-            },
-            InlayHint {
-                range: 300..304,
-                kind: TypeHint,
-                label: "&Test",
-            },
-            InlayHint {
-                range: 341..342,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 344..345,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 387..388,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 393..394,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 441..442,
-                kind: TypeHint,
-                label: "&u32",
-            },
-            InlayHint {
-                range: 448..449,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 500..501,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 543..544,
-                kind: TypeHint,
-                label: "&u8",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn while_expr() {
-        let (analysis, file_id) = single_file(
+        check(
             r#"
-#[derive(PartialEq)]
-enum CustomOption<T> {
-    None,
-    Some(T),
-}
+enum Option<T> { None, Some(T) }
+use Option::*;
 
-#[derive(PartialEq)]
-struct Test {
-    a: CustomOption<u32>,
-    b: u8,
-}
-
-use CustomOption::*;
+struct Test { a: Option<u32>, b: u8 }
 
 fn main() {
     let test = Some(Test { a: Some(3), b: 1 });
-    while let None = &test {};
-    while let test = &test {};
-    while let Some(test) = &test {};
-    while let Some(Test { a, b }) = &test {};
-    while let Some(Test { a: x, b: y }) = &test {};
-    while let Some(Test { a: Some(x), b: y }) = &test {};
-    while let Some(Test { a: None, b: y }) = &test {};
-    while let Some(Test { b: y, .. }) = &test {};
-
-    while test == None {}
+      //^^^^ Option<Test>
+    while let Some(Test { a: Some(x),  b: y }) = &test {};
+                                //^ &u32  ^ &u8
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 188..192,
-                kind: TypeHint,
-                label: "CustomOption<Test>",
-            },
-            InlayHint {
-                range: 273..277,
-                kind: TypeHint,
-                label: "&CustomOption<Test>",
-            },
-            InlayHint {
-                range: 309..313,
-                kind: TypeHint,
-                label: "&Test",
-            },
-            InlayHint {
-                range: 353..354,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 356..357,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 402..403,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 408..409,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 459..460,
-                kind: TypeHint,
-                label: "&u32",
-            },
-            InlayHint {
-                range: 466..467,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 521..522,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 567..568,
-                kind: TypeHint,
-                label: "&u8",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn match_arm_list() {
-        let (analysis, file_id) = single_file(
+        check(
             r#"
-#[derive(PartialEq)]
-enum CustomOption<T> {
-    None,
-    Some(T),
-}
-
-#[derive(PartialEq)]
-struct Test {
-    a: CustomOption<u32>,
-    b: u8,
-}
+enum Option<T> { None, Some(T) }
+use Option::*;
 
-use CustomOption::*;
+struct Test { a: Option<u32>, b: u8 }
 
 fn main() {
     match Some(Test { a: Some(3), b: 1 }) {
         None => (),
         test => (),
-        Some(test) => (),
-        Some(Test { a, b }) => (),
-        Some(Test { a: x, b: y }) => (),
+      //^^^^ Option<Test>
         Some(Test { a: Some(x), b: y }) => (),
-        Some(Test { a: None, b: y }) => (),
-        Some(Test { b: y, .. }) => (),
+                          //^ u32  ^ u8
         _ => {}
     }
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 252..256,
-                kind: TypeHint,
-                label: "CustomOption<Test>",
-            },
-            InlayHint {
-                range: 277..281,
-                kind: TypeHint,
-                label: "Test",
-            },
-            InlayHint {
-                range: 310..311,
-                kind: TypeHint,
-                label: "CustomOption<u32>",
-            },
-            InlayHint {
-                range: 313..314,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 348..349,
-                kind: TypeHint,
-                label: "CustomOption<u32>",
-            },
-            InlayHint {
-                range: 354..355,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 394..395,
-                kind: TypeHint,
-                label: "u32",
-            },
-            InlayHint {
-                range: 401..402,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 445..446,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 480..481,
-                kind: TypeHint,
-                label: "u8",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn hint_truncation() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
             r#"
 struct Smol<T>(T);
 
@@ -929,52 +598,25 @@ struct VeryLongOuterName<T>(T);
 
 fn main() {
     let a = Smol(0u32);
+      //^ Smol<u32>
     let b = VeryLongOuterName(0usize);
+      //^ VeryLongOuterName<…>
     let c = Smol(Smol(0u32))
+      //^ Smol<Smol<…>>
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 74..75,
-                kind: TypeHint,
-                label: "Smol<u32>",
-            },
-            InlayHint {
-                range: 98..99,
-                kind: TypeHint,
-                label: "VeryLongOuterName<…>",
-            },
-            InlayHint {
-                range: 137..138,
-                kind: TypeHint,
-                label: "Smol<Smol<…>>",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn function_call_parameter_hint() {
-        let (analysis, file_id) = single_file(
+        check(
             r#"
-enum CustomOption<T> {
-    None,
-    Some(T),
-}
-use CustomOption::*;
+enum Option<T> { None, Some(T) }
+use Option::*;
 
 struct FileId {}
 struct SmolStr {}
 
-impl From<&str> for SmolStr {
-    fn from(_: &str) -> Self {
-        unimplemented!()
-    }
-}
-
 struct TextRange {}
 struct SyntaxKind {}
 struct NavigationTarget {}
@@ -982,18 +624,15 @@ struct NavigationTarget {}
 struct Test {}
 
 impl Test {
-    fn method(&self, mut param: i32) -> i32 {
-        param * 2
-    }
+    fn method(&self, mut param: i32) -> i32 { param * 2 }
 
     fn from_syntax(
         file_id: FileId,
         name: SmolStr,
-        focus_range: CustomOption<TextRange>,
+        focus_range: Option<TextRange>,
         full_range: TextRange,
         kind: SyntaxKind,
-        docs: CustomOption<String>,
-        description: CustomOption<String>,
+        docs: Option<String>,
     ) -> NavigationTarget {
         NavigationTarget {}
     }
@@ -1005,108 +644,36 @@ fn test_func(mut foo: i32, bar: i32, msg: &str, _: i32, last: i32) -> i32 {
 
 fn main() {
     let not_literal = 1;
-    let _: i32 = test_func(1, 2, "hello", 3, not_literal);
+      //^^^^^^^^^^^ i32
+    let _: i32 = test_func(1,    2,      "hello", 3,  not_literal);
+                         //^ foo ^ bar   ^^^^^^^ msg  ^^^^^^^^^^^ last
     let t: Test = Test {};
     t.method(123);
-    Test::method(&t, 3456);
-
+           //^^^ param
+    Test::method(&t,      3456);
+               //^^ &self ^^^^ param
     Test::from_syntax(
         FileId {},
+      //^^^^^^^^^ file_id
         "impl".into(),
+      //^^^^^^^^^^^^^ name
         None,
+      //^^^^ focus_range
         TextRange {},
+      //^^^^^^^^^^^^ full_range
         SyntaxKind {},
+      //^^^^^^^^^^^^^ kind
         None,
-        None,
+      //^^^^ docs
     );
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 798..809,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 842..843,
-                kind: ParameterHint,
-                label: "foo",
-            },
-            InlayHint {
-                range: 845..846,
-                kind: ParameterHint,
-                label: "bar",
-            },
-            InlayHint {
-                range: 848..855,
-                kind: ParameterHint,
-                label: "msg",
-            },
-            InlayHint {
-                range: 860..871,
-                kind: ParameterHint,
-                label: "last",
-            },
-            InlayHint {
-                range: 914..917,
-                kind: ParameterHint,
-                label: "param",
-            },
-            InlayHint {
-                range: 937..939,
-                kind: ParameterHint,
-                label: "&self",
-            },
-            InlayHint {
-                range: 941..945,
-                kind: ParameterHint,
-                label: "param",
-            },
-            InlayHint {
-                range: 980..989,
-                kind: ParameterHint,
-                label: "file_id",
-            },
-            InlayHint {
-                range: 999..1012,
-                kind: ParameterHint,
-                label: "name",
-            },
-            InlayHint {
-                range: 1022..1026,
-                kind: ParameterHint,
-                label: "focus_range",
-            },
-            InlayHint {
-                range: 1036..1048,
-                kind: ParameterHint,
-                label: "full_range",
-            },
-            InlayHint {
-                range: 1058..1071,
-                kind: ParameterHint,
-                label: "kind",
-            },
-            InlayHint {
-                range: 1081..1085,
-                kind: ParameterHint,
-                label: "docs",
-            },
-            InlayHint {
-                range: 1095..1099,
-                kind: ParameterHint,
-                label: "description",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn omitted_parameters_hints_heuristics() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
             r#"
 fn map(f: i32) {}
 fn filter(predicate: i32) {}
@@ -1188,22 +755,15 @@ fn main() {
     let _: f64 = a.abs_sub(b);
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
-        []
-        "###
-        );
     }
 
     #[test]
     fn unit_structs_have_no_type_hints() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
             r#"
-enum CustomResult<T, E> {
-    Ok(T),
-    Err(E),
-}
-use CustomResult::*;
+enum Result<T, E> { Ok(T), Err(E) }
+use Result::*;
 
 struct SyntheticSyntax;
 
@@ -1214,133 +774,155 @@ fn main() {
     }
 }"#,
         );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
-        []
-        "###
-        );
     }
 
     #[test]
     fn chaining_hints_ignore_comments() {
-        let (analysis, file_id) = single_file(
+        check_expect(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
             r#"
-            struct A(B);
-            impl A { fn into_b(self) -> B { self.0 } }
-            struct B(C);
-            impl B { fn into_c(self) -> C { self.0 } }
-            struct C;
-
-            fn main() {
-                let c = A(B(C))
-                    .into_b() // This is a comment
-                    .into_c();
-            }"#,
+struct A(B);
+impl A { fn into_b(self) -> B { self.0 } }
+struct B(C);
+impl B { fn into_c(self) -> C { self.0 } }
+struct C;
+
+fn main() {
+    let c = A(B(C))
+        .into_b() // This is a comment
+        .into_c();
+}
+"#,
+            expect![[r#"
+                [
+                    InlayHint {
+                        range: 147..172,
+                        kind: ChainingHint,
+                        label: "B",
+                    },
+                    InlayHint {
+                        range: 147..154,
+                        kind: ChainingHint,
+                        label: "A",
+                    },
+                ]
+            "#]],
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 232..269,
-                kind: ChainingHint,
-                label: "B",
-            },
-            InlayHint {
-                range: 232..239,
-                kind: ChainingHint,
-                label: "A",
-            },
-        ]"###);
     }
 
     #[test]
     fn chaining_hints_without_newlines() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
             r#"
-            struct A(B);
-            impl A { fn into_b(self) -> B { self.0 } }
-            struct B(C);
-            impl B { fn into_c(self) -> C { self.0 } }
-            struct C;
-
-            fn main() {
-                let c = A(B(C)).into_b().into_c();
-            }"#,
+struct A(B);
+impl A { fn into_b(self) -> B { self.0 } }
+struct B(C);
+impl B { fn into_c(self) -> C { self.0 } }
+struct C;
+
+fn main() {
+    let c = A(B(C)).into_b().into_c();
+}"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"[]"###);
     }
 
     #[test]
     fn struct_access_chaining_hints() {
-        let (analysis, file_id) = single_file(
+        check_expect(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
             r#"
-            struct A { pub b: B }
-            struct B { pub c: C }
-            struct C(pub bool);
-            struct D;
+struct A { pub b: B }
+struct B { pub c: C }
+struct C(pub bool);
+struct D;
 
-            impl D {
-                fn foo(&self) -> i32 { 42 }
-            }
+impl D {
+    fn foo(&self) -> i32 { 42 }
+}
 
-            fn main() {
-                let x = A { b: B { c: C(true) } }
-                    .b
-                    .c
-                    .0;
-                let x = D
-                    .foo();
-            }"#,
+fn main() {
+    let x = A { b: B { c: C(true) } }
+        .b
+        .c
+        .0;
+    let x = D
+        .foo();
+}"#,
+            expect![[r#"
+                [
+                    InlayHint {
+                        range: 143..190,
+                        kind: ChainingHint,
+                        label: "C",
+                    },
+                    InlayHint {
+                        range: 143..179,
+                        kind: ChainingHint,
+                        label: "B",
+                    },
+                ]
+            "#]],
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 252..323,
-                kind: ChainingHint,
-                label: "C",
-            },
-            InlayHint {
-                range: 252..300,
-                kind: ChainingHint,
-                label: "B",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn generic_chaining_hints() {
-        let (analysis, file_id) = single_file(
+        check_expect(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
             r#"
-            struct A<T>(T);
-            struct B<T>(T);
-            struct C<T>(T);
-            struct X<T,R>(T, R);
-
-            impl<T> A<T> {
-                fn new(t: T) -> Self { A(t) }
-                fn into_b(self) -> B<T> { B(self.0) }
-            }
-            impl<T> B<T> {
-                fn into_c(self) -> C<T> { C(self.0) }
-            }
-            fn main() {
-                let c = A::new(X(42, true))
-                    .into_b()
-                    .into_c();
-            }"#,
+struct A<T>(T);
+struct B<T>(T);
+struct C<T>(T);
+struct X<T,R>(T, R);
+
+impl<T> A<T> {
+    fn new(t: T) -> Self { A(t) }
+    fn into_b(self) -> B<T> { B(self.0) }
+}
+impl<T> B<T> {
+    fn into_c(self) -> C<T> { C(self.0) }
+}
+fn main() {
+    let c = A::new(X(42, true))
+        .into_b()
+        .into_c();
+}
+"#,
+            expect![[r#"
+                [
+                    InlayHint {
+                        range: 246..283,
+                        kind: ChainingHint,
+                        label: "B<X<i32, bool>>",
+                    },
+                    InlayHint {
+                        range: 246..265,
+                        kind: ChainingHint,
+                        label: "A<X<i32, bool>>",
+                    },
+                ]
+            "#]],
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 403..452,
-                kind: ChainingHint,
-                label: "B<X<i32, bool>>",
-            },
-            InlayHint {
-                range: 403..422,
-                kind: ChainingHint,
-                label: "A<X<i32, bool>>",
-            },
-        ]"###);
     }
 }
diff --git a/crates/ra_ide/src/join_lines.rs b/crates/ra_ide/src/join_lines.rs
index 5036c1fb0..6907c09e8 100644
--- a/crates/ra_ide/src/join_lines.rs
+++ b/crates/ra_ide/src/join_lines.rs
@@ -165,10 +165,7 @@ fn join_single_use_tree(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Opti
 }
 
 fn is_trailing_comma(left: SyntaxKind, right: SyntaxKind) -> bool {
-    match (left, right) {
-        (T![,], T![')']) | (T![,], T![']']) => true,
-        _ => false,
-    }
+    matches!((left, right), (T![,], T![')']) | (T![,], T![']']))
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 12d5716e8..5d1f64e19 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -17,6 +17,7 @@ macro_rules! eprintln {
 
 pub mod mock_analysis;
 
+mod markup;
 mod prime_caches;
 mod status;
 mod completion;
@@ -47,7 +48,7 @@ use std::sync::Arc;
 use ra_cfg::CfgOptions;
 use ra_db::{
     salsa::{self, ParallelDatabase},
-    CheckCanceled, Env, FileLoader, SourceDatabase,
+    CheckCanceled, Env, FileLoader, FileSet, SourceDatabase, VfsPath,
 };
 use ra_ide_db::{
     symbol_index::{self, FileSymbol},
@@ -59,6 +60,7 @@ use crate::display::ToNav;
 
 pub use crate::{
     call_hierarchy::CallItem,
+    call_info::CallInfo,
     completion::{
         CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat,
     },
@@ -66,29 +68,31 @@ pub use crate::{
     display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
     expand_macro::ExpandedMacro,
     folding_ranges::{Fold, FoldKind},
-    hover::HoverResult,
+    hover::{HoverAction, HoverConfig, HoverGotoTypeData, HoverResult},
     inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
+    markup::Markup,
     references::{Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult},
     runnables::{Runnable, RunnableKind, TestId},
-    ssr::SsrError,
     syntax_highlighting::{
         Highlight, HighlightModifier, HighlightModifiers, HighlightTag, HighlightedRange,
     },
 };
 
-pub use hir::Documentation;
-pub use ra_assists::{AssistConfig, AssistId};
+pub use hir::{Documentation, Semantics};
+pub use ra_assists::{Assist, AssistConfig, AssistId, AssistKind, ResolvedAssist};
 pub use ra_db::{
-    Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRootId,
+    Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRoot,
+    SourceRootId,
 };
 pub use ra_ide_db::{
-    change::{AnalysisChange, LibraryData},
+    change::AnalysisChange,
     line_index::{LineCol, LineIndex},
     search::SearchScope,
     source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
     symbol_index::Query,
     RootDatabase,
 };
+pub use ra_ssr::SsrError;
 pub use ra_text_edit::{Indel, TextEdit};
 
 pub type Cancelable<T> = Result<T, Canceled>;
@@ -128,28 +132,12 @@ impl<T> RangeInfo<T> {
     }
 }
 
-/// Contains information about a call site. Specifically the
-/// `FunctionSignature`and current parameter.
-#[derive(Debug)]
-pub struct CallInfo {
-    pub signature: FunctionSignature,
-    pub active_parameter: Option<usize>,
-}
-
 /// `AnalysisHost` stores the current state of the world.
 #[derive(Debug)]
 pub struct AnalysisHost {
     db: RootDatabase,
 }
 
-#[derive(Debug)]
-pub struct Assist {
-    pub id: AssistId,
-    pub label: String,
-    pub group_label: Option<String>,
-    pub source_change: SourceChange,
-}
-
 impl AnalysisHost {
     pub fn new(lru_capacity: Option<usize>) -> AnalysisHost {
         AnalysisHost { db: RootDatabase::new(lru_capacity) }
@@ -220,11 +208,14 @@ impl Analysis {
     // `AnalysisHost` for creating a fully-featured analysis.
     pub fn from_single_file(text: String) -> (Analysis, FileId) {
         let mut host = AnalysisHost::default();
-        let source_root = SourceRootId(0);
+        let file_id = FileId(0);
+        let mut file_set = FileSet::default();
+        file_set.insert(file_id, VfsPath::new_virtual_path("/main.rs".to_string()));
+        let source_root = SourceRoot::new_local(file_set);
+
         let mut change = AnalysisChange::new();
-        change.add_root(source_root, true);
+        change.set_roots(vec![source_root]);
         let mut crate_graph = CrateGraph::default();
-        let file_id = FileId(0);
         // FIXME: cfg options
         // Default to enable test for single file.
         let mut cfg_options = CfgOptions::default();
@@ -236,9 +227,8 @@ impl Analysis {
             cfg_options,
             Env::default(),
             Default::default(),
-            Default::default(),
         );
-        change.add_file(source_root, file_id, "main.rs".into(), Arc::new(text));
+        change.change_file(file_id, Some(Arc::new(text)));
         change.set_crate_graph(crate_graph);
         host.apply_change(change);
         (host.analysis(), file_id)
@@ -390,7 +380,9 @@ impl Analysis {
         position: FilePosition,
         search_scope: Option<SearchScope>,
     ) -> Cancelable<Option<ReferenceSearchResult>> {
-        self.with_db(|db| references::find_all_refs(db, position, search_scope).map(|it| it.info))
+        self.with_db(|db| {
+            references::find_all_refs(&Semantics::new(db), position, search_scope).map(|it| it.info)
+        })
     }
 
     /// Returns a short text describing element at position.
@@ -448,12 +440,14 @@ impl Analysis {
 
     /// Computes syntax highlighting for the given file
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None))
+        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None, false))
     }
 
     /// Computes syntax highlighting for the given file range.
     pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, frange.file_id, Some(frange.range)))
+        self.with_db(|db| {
+            syntax_highlighting::highlight(db, frange.file_id, Some(frange.range), false)
+        })
     }
 
     /// Computes syntax highlighting for the given file.
@@ -470,20 +464,23 @@ impl Analysis {
         self.with_db(|db| completion::completions(db, config, position).map(Into::into))
     }
 
-    /// Computes assists (aka code actions aka intentions) for the given
+    /// Computes resolved assists with source changes for the given position.
+    pub fn resolved_assists(
+        &self,
+        config: &AssistConfig,
+        frange: FileRange,
+    ) -> Cancelable<Vec<ResolvedAssist>> {
+        self.with_db(|db| ra_assists::Assist::resolved(db, config, frange))
+    }
+
+    /// Computes unresolved assists (aka code actions aka intentions) for the given
     /// position.
-    pub fn assists(&self, config: &AssistConfig, frange: FileRange) -> Cancelable<Vec<Assist>> {
-        self.with_db(|db| {
-            ra_assists::Assist::resolved(db, config, frange)
-                .into_iter()
-                .map(|assist| Assist {
-                    id: assist.assist.id,
-                    label: assist.assist.label,
-                    group_label: assist.assist.group.map(|it| it.0),
-                    source_change: assist.source_change,
-                })
-                .collect()
-        })
+    pub fn unresolved_assists(
+        &self,
+        config: &AssistConfig,
+        frange: FileRange,
+    ) -> Cancelable<Vec<Assist>> {
+        self.with_db(|db| Assist::unresolved(db, config, frange))
     }
 
     /// Computes the set of diagnostics for the given file.
@@ -508,7 +505,7 @@ impl Analysis {
     ) -> Cancelable<Result<SourceChange, SsrError>> {
         self.with_db(|db| {
             let edits = ssr::parse_search_replace(query, parse_only, db)?;
-            Ok(SourceChange::source_file_edits(edits))
+            Ok(SourceChange::from(edits))
         })
     }
 
diff --git a/crates/ra_ide/src/markup.rs b/crates/ra_ide/src/markup.rs
new file mode 100644
index 000000000..60c193c40
--- /dev/null
+++ b/crates/ra_ide/src/markup.rs
@@ -0,0 +1,38 @@
+//! Markdown formatting.
+//!
+//! Sometimes, we want to display a "rich text" in the UI. At the moment, we use
+//! markdown for this purpose. It doesn't feel like a right option, but that's
+//! what is used by LSP, so let's keep it simple.
+use std::fmt;
+
+#[derive(Default, Debug)]
+pub struct Markup {
+    text: String,
+}
+
+impl From<Markup> for String {
+    fn from(markup: Markup) -> Self {
+        markup.text
+    }
+}
+
+impl From<String> for Markup {
+    fn from(text: String) -> Self {
+        Markup { text }
+    }
+}
+
+impl fmt::Display for Markup {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.text, f)
+    }
+}
+
+impl Markup {
+    pub fn as_str(&self) -> &str {
+        self.text.as_str()
+    }
+    pub fn fenced_block(contents: &impl fmt::Display) -> Markup {
+        format!("```rust\n{}\n```", contents).into()
+    }
+}
diff --git a/crates/ra_ide/src/matching_brace.rs b/crates/ra_ide/src/matching_brace.rs
index 407a9636d..742d70c9c 100644
--- a/crates/ra_ide/src/matching_brace.rs
+++ b/crates/ra_ide/src/matching_brace.rs
@@ -1,8 +1,12 @@
-use ra_syntax::{ast::AstNode, SourceFile, SyntaxKind, TextSize, T};
+use ra_syntax::{
+    ast::{self, AstNode},
+    SourceFile, SyntaxKind, TextSize, T,
+};
+use test_utils::mark;
 
 // Feature: Matching Brace
 //
-// If the cursor is on any brace (`<>(){}[]`) which is a part of a brace-pair,
+// If the cursor is on any brace (`<>(){}[]||`) which is a part of a brace-pair,
 // moves cursor to the matching brace. It uses the actual parser to determine
 // braces, so it won't confuse generics with comparisons.
 //
@@ -13,8 +17,8 @@ use ra_syntax::{ast::AstNode, SourceFile, SyntaxKind, TextSize, T};
 // |===
 pub fn matching_brace(file: &SourceFile, offset: TextSize) -> Option<TextSize> {
     const BRACES: &[SyntaxKind] =
-        &[T!['{'], T!['}'], T!['['], T![']'], T!['('], T![')'], T![<], T![>]];
-    let (brace_node, brace_idx) = file
+        &[T!['{'], T!['}'], T!['['], T![']'], T!['('], T![')'], T![<], T![>], T![|], T![|]];
+    let (brace_token, brace_idx) = file
         .syntax()
         .token_at_offset(offset)
         .filter_map(|node| {
@@ -22,9 +26,16 @@ pub fn matching_brace(file: &SourceFile, offset: TextSize) -> Option<TextSize> {
             Some((node, idx))
         })
         .next()?;
-    let parent = brace_node.parent();
+    let parent = brace_token.parent();
+    if brace_token.kind() == T![|] && !ast::ParamList::can_cast(parent.kind()) {
+        mark::hit!(pipes_not_braces);
+        return None;
+    }
     let matching_kind = BRACES[brace_idx ^ 1];
-    let matching_node = parent.children_with_tokens().find(|node| node.kind() == matching_kind)?;
+    let matching_node = parent
+        .children_with_tokens()
+        .filter_map(|it| it.into_token())
+        .find(|node| node.kind() == matching_kind && node != &brace_token)?;
     Some(matching_node.text_range().start())
 }
 
@@ -48,5 +59,15 @@ mod tests {
         }
 
         do_check("struct Foo { a: i32, }<|>", "struct Foo <|>{ a: i32, }");
+        do_check("fn main() { |x: i32|<|> x * 2;}", "fn main() { <|>|x: i32| x * 2;}");
+        do_check("fn main() { <|>|x: i32| x * 2;}", "fn main() { |x: i32<|>| x * 2;}");
+
+        {
+            mark::check!(pipes_not_braces);
+            do_check(
+                "fn main() { match 92 { 1 | 2 |<|> 3 => 92 } }",
+                "fn main() { match 92 { 1 | 2 |<|> 3 => 92 } }",
+            );
+        }
     }
 }
diff --git a/crates/ra_ide/src/mock_analysis.rs b/crates/ra_ide/src/mock_analysis.rs
index ad78d2d93..b28054688 100644
--- a/crates/ra_ide/src/mock_analysis.rs
+++ b/crates/ra_ide/src/mock_analysis.rs
@@ -1,87 +1,24 @@
 //! FIXME: write short doc here
-
-use std::str::FromStr;
 use std::sync::Arc;
 
 use ra_cfg::CfgOptions;
-use ra_db::{CrateName, Env, RelativePathBuf};
-use test_utils::{extract_offset, extract_range, parse_fixture, FixtureEntry, CURSOR_MARKER};
+use ra_db::{CrateName, Env, FileSet, SourceRoot, VfsPath};
+use test_utils::{
+    extract_annotations, extract_range_or_offset, Fixture, RangeOrOffset, CURSOR_MARKER,
+};
 
 use crate::{
     Analysis, AnalysisChange, AnalysisHost, CrateGraph, Edition, FileId, FilePosition, FileRange,
-    SourceRootId,
 };
 
-#[derive(Debug)]
-enum MockFileData {
-    Plain { path: String, content: String },
-    Fixture(FixtureEntry),
-}
-
-impl MockFileData {
-    fn new(path: String, content: String) -> Self {
-        // `Self::Plain` causes a false warning: 'variant is never constructed: `Plain` '
-        // see https://github.com/rust-lang/rust/issues/69018
-        MockFileData::Plain { path, content }
-    }
-
-    fn path(&self) -> &str {
-        match self {
-            MockFileData::Plain { path, .. } => path.as_str(),
-            MockFileData::Fixture(f) => f.meta.path().as_str(),
-        }
-    }
-
-    fn content(&self) -> &str {
-        match self {
-            MockFileData::Plain { content, .. } => content,
-            MockFileData::Fixture(f) => f.text.as_str(),
-        }
-    }
-
-    fn cfg_options(&self) -> CfgOptions {
-        match self {
-            MockFileData::Fixture(f) => {
-                f.meta.cfg_options().map_or_else(Default::default, |o| o.clone())
-            }
-            _ => CfgOptions::default(),
-        }
-    }
-
-    fn edition(&self) -> Edition {
-        match self {
-            MockFileData::Fixture(f) => {
-                f.meta.edition().map_or(Edition::Edition2018, |v| Edition::from_str(v).unwrap())
-            }
-            _ => Edition::Edition2018,
-        }
-    }
-
-    fn env(&self) -> Env {
-        match self {
-            MockFileData::Fixture(f) => Env::from(f.meta.env()),
-            _ => Env::default(),
-        }
-    }
-}
-
-impl From<FixtureEntry> for MockFileData {
-    fn from(fixture: FixtureEntry) -> Self {
-        Self::Fixture(fixture)
-    }
-}
-
 /// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis
 /// from a set of in-memory files.
 #[derive(Debug, Default)]
 pub struct MockAnalysis {
-    files: Vec<MockFileData>,
+    files: Vec<Fixture>,
 }
 
 impl MockAnalysis {
-    pub fn new() -> MockAnalysis {
-        MockAnalysis::default()
-    }
     /// Creates `MockAnalysis` using a fixture data in the following format:
     ///
     /// ```not_rust
@@ -92,106 +29,107 @@ impl MockAnalysis {
     /// //- /foo.rs
     /// struct Baz;
     /// ```
-    pub fn with_files(fixture: &str) -> MockAnalysis {
-        let mut res = MockAnalysis::new();
-        for entry in parse_fixture(fixture) {
-            res.add_file_fixture(entry);
-        }
+    pub fn with_files(ra_fixture: &str) -> MockAnalysis {
+        let (res, pos) = MockAnalysis::with_fixture(ra_fixture);
+        assert!(pos.is_none());
         res
     }
 
     /// Same as `with_files`, but requires that a single file contains a `<|>` marker,
     /// whose position is also returned.
     pub fn with_files_and_position(fixture: &str) -> (MockAnalysis, FilePosition) {
+        let (res, position) = MockAnalysis::with_fixture(fixture);
+        let (file_id, range_or_offset) = position.expect("expected a marker (<|>)");
+        let offset = match range_or_offset {
+            RangeOrOffset::Range(_) => panic!(),
+            RangeOrOffset::Offset(it) => it,
+        };
+        (res, FilePosition { file_id, offset })
+    }
+
+    fn with_fixture(fixture: &str) -> (MockAnalysis, Option<(FileId, RangeOrOffset)>) {
         let mut position = None;
-        let mut res = MockAnalysis::new();
-        for entry in parse_fixture(fixture) {
+        let mut res = MockAnalysis::default();
+        for mut entry in Fixture::parse(fixture) {
             if entry.text.contains(CURSOR_MARKER) {
                 assert!(position.is_none(), "only one marker (<|>) per fixture is allowed");
-                position = Some(res.add_file_fixture_with_position(entry));
+                let (range_or_offset, text) = extract_range_or_offset(&entry.text);
+                entry.text = text;
+                let file_id = res.add_file_fixture(entry);
+                position = Some((file_id, range_or_offset));
             } else {
                 res.add_file_fixture(entry);
             }
         }
-        let position = position.expect("expected a marker (<|>)");
         (res, position)
     }
 
-    pub fn add_file_fixture(&mut self, fixture: FixtureEntry) -> FileId {
-        let file_id = self.next_id();
-        self.files.push(MockFileData::from(fixture));
+    fn add_file_fixture(&mut self, fixture: Fixture) -> FileId {
+        let file_id = FileId((self.files.len() + 1) as u32);
+        self.files.push(fixture);
         file_id
     }
 
-    pub fn add_file_fixture_with_position(&mut self, mut fixture: FixtureEntry) -> FilePosition {
-        let (offset, text) = extract_offset(&fixture.text);
-        fixture.text = text;
-        let file_id = self.next_id();
-        self.files.push(MockFileData::from(fixture));
-        FilePosition { file_id, offset }
-    }
-
-    pub fn add_file(&mut self, path: &str, text: &str) -> FileId {
-        let file_id = self.next_id();
-        self.files.push(MockFileData::new(path.to_string(), text.to_string()));
+    pub fn id_of(&self, path: &str) -> FileId {
+        let (file_id, _) =
+            self.files().find(|(_, data)| path == data.path).expect("no file in this mock");
         file_id
     }
-    pub fn add_file_with_position(&mut self, path: &str, text: &str) -> FilePosition {
-        let (offset, text) = extract_offset(text);
-        let file_id = self.next_id();
-        self.files.push(MockFileData::new(path.to_string(), text));
-        FilePosition { file_id, offset }
+    pub fn annotations(&self) -> Vec<(FileRange, String)> {
+        self.files()
+            .flat_map(|(file_id, fixture)| {
+                let annotations = extract_annotations(&fixture.text);
+                annotations
+                    .into_iter()
+                    .map(move |(range, data)| (FileRange { file_id, range }, data))
+            })
+            .collect()
     }
-    pub fn add_file_with_range(&mut self, path: &str, text: &str) -> FileRange {
-        let (range, text) = extract_range(text);
-        let file_id = self.next_id();
-        self.files.push(MockFileData::new(path.to_string(), text));
-        FileRange { file_id, range }
+    pub fn files(&self) -> impl Iterator<Item = (FileId, &Fixture)> + '_ {
+        self.files.iter().enumerate().map(|(idx, fixture)| (FileId(idx as u32 + 1), fixture))
     }
-    pub fn id_of(&self, path: &str) -> FileId {
-        let (idx, _) = self
-            .files
-            .iter()
-            .enumerate()
-            .find(|(_, data)| path == data.path())
-            .expect("no file in this mock");
-        FileId(idx as u32 + 1)
+    pub fn annotation(&self) -> (FileRange, String) {
+        let mut all = self.annotations();
+        assert_eq!(all.len(), 1);
+        all.pop().unwrap()
     }
     pub fn analysis_host(self) -> AnalysisHost {
         let mut host = AnalysisHost::default();
-        let source_root = SourceRootId(0);
         let mut change = AnalysisChange::new();
-        change.add_root(source_root, true);
+        let mut file_set = FileSet::default();
         let mut crate_graph = CrateGraph::default();
         let mut root_crate = None;
         for (i, data) in self.files.into_iter().enumerate() {
-            let path = data.path();
+            let path = data.path;
             assert!(path.starts_with('/'));
-            let path = RelativePathBuf::from_path(&path[1..]).unwrap();
-            let cfg_options = data.cfg_options();
+
+            let mut cfg = CfgOptions::default();
+            data.cfg_atoms.iter().for_each(|it| cfg.insert_atom(it.into()));
+            data.cfg_key_values.iter().for_each(|(k, v)| cfg.insert_key_value(k.into(), v.into()));
+            let edition: Edition =
+                data.edition.and_then(|it| it.parse().ok()).unwrap_or(Edition::Edition2018);
+
             let file_id = FileId(i as u32 + 1);
-            let edition = data.edition();
-            let env = data.env();
+            let env = Env::from(data.env.iter());
             if path == "/lib.rs" || path == "/main.rs" {
                 root_crate = Some(crate_graph.add_crate_root(
                     file_id,
                     edition,
                     None,
-                    cfg_options,
+                    cfg,
                     env,
                     Default::default(),
-                    Default::default(),
                 ));
             } else if path.ends_with("/lib.rs") {
-                let crate_name = path.parent().unwrap().file_name().unwrap();
+                let base = &path[..path.len() - "/lib.rs".len()];
+                let crate_name = &base[base.rfind('/').unwrap() + '/'.len_utf8()..];
                 let other_crate = crate_graph.add_crate_root(
                     file_id,
                     edition,
-                    Some(CrateName::new(crate_name).unwrap()),
-                    cfg_options,
+                    Some(crate_name.to_string()),
+                    cfg,
                     env,
                     Default::default(),
-                    Default::default(),
                 );
                 if let Some(root_crate) = root_crate {
                     crate_graph
@@ -199,19 +137,18 @@ impl MockAnalysis {
                         .unwrap();
                 }
             }
-            change.add_file(source_root, file_id, path, Arc::new(data.content().to_owned()));
+            let path = VfsPath::new_virtual_path(path.to_string());
+            file_set.insert(file_id, path);
+            change.change_file(file_id, Some(Arc::new(data.text).to_owned()));
         }
         change.set_crate_graph(crate_graph);
+        change.set_roots(vec![SourceRoot::new_local(file_set)]);
         host.apply_change(change);
         host
     }
     pub fn analysis(self) -> Analysis {
         self.analysis_host().analysis()
     }
-
-    fn next_id(&self) -> FileId {
-        FileId((self.files.len() + 1) as u32)
-    }
 }
 
 /// Creates analysis from a multi-file fixture, returns positions marked with <|>.
@@ -222,21 +159,18 @@ pub fn analysis_and_position(ra_fixture: &str) -> (Analysis, FilePosition) {
 
 /// Creates analysis for a single file.
 pub fn single_file(ra_fixture: &str) -> (Analysis, FileId) {
-    let mut mock = MockAnalysis::new();
-    let file_id = mock.add_file("/main.rs", ra_fixture);
+    let mock = MockAnalysis::with_files(ra_fixture);
+    let file_id = mock.id_of("/main.rs");
     (mock.analysis(), file_id)
 }
 
-/// Creates analysis for a single file, returns position marked with <|>.
-pub fn single_file_with_position(ra_fixture: &str) -> (Analysis, FilePosition) {
-    let mut mock = MockAnalysis::new();
-    let pos = mock.add_file_with_position("/main.rs", ra_fixture);
-    (mock.analysis(), pos)
-}
-
 /// Creates analysis for a single file, returns range marked with a pair of <|>.
-pub fn single_file_with_range(ra_fixture: &str) -> (Analysis, FileRange) {
-    let mut mock = MockAnalysis::new();
-    let pos = mock.add_file_with_range("/main.rs", ra_fixture);
-    (mock.analysis(), pos)
+pub fn analysis_and_range(ra_fixture: &str) -> (Analysis, FileRange) {
+    let (res, position) = MockAnalysis::with_fixture(ra_fixture);
+    let (file_id, range_or_offset) = position.expect("expected a marker (<|>)");
+    let range = match range_or_offset {
+        RangeOrOffset::Range(it) => it,
+        RangeOrOffset::Offset(_) => panic!(),
+    };
+    (res.analysis(), FileRange { file_id, range })
 }
diff --git a/crates/ra_ide/src/parent_module.rs b/crates/ra_ide/src/parent_module.rs
index fa1535da5..e3e0c7639 100644
--- a/crates/ra_ide/src/parent_module.rs
+++ b/crates/ra_ide/src/parent_module.rs
@@ -125,12 +125,12 @@ mod tests {
     #[test]
     fn test_resolve_crate_root() {
         let mock = MockAnalysis::with_files(
-            "
-        //- /bar.rs
-        mod foo;
-        //- /foo.rs
-        // empty <|>
-    ",
+            r#"
+//- /bar.rs
+mod foo;
+//- /foo.rs
+// empty
+"#,
         );
         let root_file = mock.id_of("/bar.rs");
         let mod_file = mock.id_of("/foo.rs");
@@ -145,7 +145,6 @@ mod tests {
             CfgOptions::default(),
             Env::default(),
             Default::default(),
-            Default::default(),
         );
         let mut change = AnalysisChange::new();
         change.set_crate_graph(crate_graph);
diff --git a/crates/ra_ide/src/prime_caches.rs b/crates/ra_ide/src/prime_caches.rs
index 90bf7d25f..c5ab5a1d8 100644
--- a/crates/ra_ide/src/prime_caches.rs
+++ b/crates/ra_ide/src/prime_caches.rs
@@ -7,6 +7,6 @@ use crate::{FileId, RootDatabase};
 
 pub(crate) fn prime_caches(db: &RootDatabase, files: Vec<FileId>) {
     for file in files {
-        let _ = crate::syntax_highlighting::highlight(db, file, None);
+        let _ = crate::syntax_highlighting::highlight(db, file, None, false);
     }
 }
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index bb40d2043..c2b0d5efe 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -86,12 +86,11 @@ impl IntoIterator for ReferenceSearchResult {
 }
 
 pub(crate) fn find_all_refs(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
     position: FilePosition,
     search_scope: Option<SearchScope>,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
     let _p = profile("find_all_refs");
-    let sema = Semantics::new(db);
     let syntax = sema.parse(position.file_id).syntax().clone();
 
     let (opt_name, search_kind) = if let Some(name) =
@@ -108,15 +107,15 @@ pub(crate) fn find_all_refs(
     let RangeInfo { range, info: def } = find_name(&sema, &syntax, position, opt_name)?;
 
     let references = def
-        .find_usages(db, search_scope)
+        .find_usages(sema, search_scope)
         .into_iter()
         .filter(|r| search_kind == ReferenceKind::Other || search_kind == r.kind)
         .collect();
 
-    let decl_range = def.try_to_nav(db)?.range();
+    let decl_range = def.try_to_nav(sema.db)?.range();
 
     let declaration = Declaration {
-        nav: def.try_to_nav(db)?,
+        nav: def.try_to_nav(sema.db)?,
         kind: ReferenceKind::Other,
         access: decl_access(&def, &syntax, decl_range),
     };
@@ -191,244 +190,249 @@ fn get_struct_def_name_for_struct_literal_search(
 #[cfg(test)]
 mod tests {
     use crate::{
-        mock_analysis::{analysis_and_position, single_file_with_position, MockAnalysis},
+        mock_analysis::{analysis_and_position, MockAnalysis},
         Declaration, Reference, ReferenceSearchResult, SearchScope,
     };
 
     #[test]
     fn test_struct_literal_after_space() {
-        let code = r#"
-    struct Foo <|>{
-        a: i32,
-    }
-    impl Foo {
-        fn f() -> i32 { 42 }
-    }
-    fn main() {
-        let f: Foo;
-        f = Foo {a: Foo::f()};
-    }"#;
-
-        let refs = get_all_refs(code);
+        let refs = get_all_refs(
+            r#"
+struct Foo <|>{
+    a: i32,
+}
+impl Foo {
+    fn f() -> i32 { 42 }
+}
+fn main() {
+    let f: Foo;
+    f = Foo {a: Foo::f()};
+}
+"#,
+        );
         check_result(
             refs,
-            "Foo STRUCT_DEF FileId(1) 5..39 12..15 Other",
-            &["FileId(1) 138..141 StructLiteral"],
+            "Foo STRUCT_DEF FileId(1) 0..26 7..10 Other",
+            &["FileId(1) 101..104 StructLiteral"],
         );
     }
 
     #[test]
-    fn test_struct_literal_befor_space() {
-        let code = r#"
-    struct Foo<|> {}
-        fn main() {
-        let f: Foo;
-        f = Foo {};
-    }"#;
-
-        let refs = get_all_refs(code);
+    fn test_struct_literal_before_space() {
+        let refs = get_all_refs(
+            r#"
+struct Foo<|> {}
+    fn main() {
+    let f: Foo;
+    f = Foo {};
+}
+"#,
+        );
         check_result(
             refs,
-            "Foo STRUCT_DEF FileId(1) 5..18 12..15 Other",
-            &["FileId(1) 54..57 Other", "FileId(1) 71..74 StructLiteral"],
+            "Foo STRUCT_DEF FileId(1) 0..13 7..10 Other",
+            &["FileId(1) 41..44 Other", "FileId(1) 54..57 StructLiteral"],
         );
     }
 
     #[test]
     fn test_struct_literal_with_generic_type() {
-        let code = r#"
-    struct Foo<T> <|>{}
-        fn main() {
-        let f: Foo::<i32>;
-        f = Foo {};
-    }"#;
-
-        let refs = get_all_refs(code);
+        let refs = get_all_refs(
+            r#"
+struct Foo<T> <|>{}
+    fn main() {
+    let f: Foo::<i32>;
+    f = Foo {};
+}
+"#,
+        );
         check_result(
             refs,
-            "Foo STRUCT_DEF FileId(1) 5..21 12..15 Other",
-            &["FileId(1) 81..84 StructLiteral"],
+            "Foo STRUCT_DEF FileId(1) 0..16 7..10 Other",
+            &["FileId(1) 64..67 StructLiteral"],
         );
     }
 
     #[test]
     fn test_struct_literal_for_tuple() {
-        let code = r#"
-    struct Foo<|>(i32);
+        let refs = get_all_refs(
+            r#"
+struct Foo<|>(i32);
 
-    fn main() {
-        let f: Foo;
-        f = Foo(1);
-    }"#;
-
-        let refs = get_all_refs(code);
+fn main() {
+    let f: Foo;
+    f = Foo(1);
+}
+"#,
+        );
         check_result(
             refs,
-            "Foo STRUCT_DEF FileId(1) 5..21 12..15 Other",
-            &["FileId(1) 71..74 StructLiteral"],
+            "Foo STRUCT_DEF FileId(1) 0..16 7..10 Other",
+            &["FileId(1) 54..57 StructLiteral"],
         );
     }
 
     #[test]
     fn test_find_all_refs_for_local() {
-        let code = r#"
-    fn main() {
-        let mut i = 1;
-        let j = 1;
-        i = i<|> + j;
+        let refs = get_all_refs(
+            r#"
+fn main() {
+    let mut i = 1;
+    let j = 1;
+    i = i<|> + j;
 
-        {
-            i = 0;
-        }
-
-        i = 5;
-    }"#;
+    {
+        i = 0;
+    }
 
-        let refs = get_all_refs(code);
+    i = 5;
+}"#,
+        );
         check_result(
             refs,
-            "i BIND_PAT FileId(1) 33..34 Other Write",
+            "i BIND_PAT FileId(1) 24..25 Other Write",
             &[
-                "FileId(1) 67..68 Other Write",
-                "FileId(1) 71..72 Other Read",
-                "FileId(1) 101..102 Other Write",
-                "FileId(1) 127..128 Other Write",
+                "FileId(1) 50..51 Other Write",
+                "FileId(1) 54..55 Other Read",
+                "FileId(1) 76..77 Other Write",
+                "FileId(1) 94..95 Other Write",
             ],
         );
     }
 
     #[test]
     fn search_filters_by_range() {
-        let code = r#"
-            fn foo() {
-                let spam<|> = 92;
-                spam + spam
-            }
-            fn bar() {
-                let spam = 92;
-                spam + spam
-            }
-        "#;
-        let refs = get_all_refs(code);
+        let refs = get_all_refs(
+            r#"
+fn foo() {
+    let spam<|> = 92;
+    spam + spam
+}
+fn bar() {
+    let spam = 92;
+    spam + spam
+}
+"#,
+        );
         check_result(
             refs,
-            "spam BIND_PAT FileId(1) 44..48 Other",
-            &["FileId(1) 71..75 Other Read", "FileId(1) 78..82 Other Read"],
+            "spam BIND_PAT FileId(1) 19..23 Other",
+            &["FileId(1) 34..38 Other Read", "FileId(1) 41..45 Other Read"],
         );
     }
 
     #[test]
     fn test_find_all_refs_for_param_inside() {
-        let code = r#"
-    fn foo(i : u32) -> u32 {
-        i<|>
-    }"#;
-
-        let refs = get_all_refs(code);
-        check_result(refs, "i BIND_PAT FileId(1) 12..13 Other", &["FileId(1) 38..39 Other Read"]);
+        let refs = get_all_refs(
+            r#"
+fn foo(i : u32) -> u32 {
+    i<|>
+}
+"#,
+        );
+        check_result(refs, "i BIND_PAT FileId(1) 7..8 Other", &["FileId(1) 29..30 Other Read"]);
     }
 
     #[test]
     fn test_find_all_refs_for_fn_param() {
-        let code = r#"
-    fn foo(i<|> : u32) -> u32 {
-        i
-    }"#;
-
-        let refs = get_all_refs(code);
-        check_result(refs, "i BIND_PAT FileId(1) 12..13 Other", &["FileId(1) 38..39 Other Read"]);
+        let refs = get_all_refs(
+            r#"
+fn foo(i<|> : u32) -> u32 {
+    i
+}
+"#,
+        );
+        check_result(refs, "i BIND_PAT FileId(1) 7..8 Other", &["FileId(1) 29..30 Other Read"]);
     }
 
     #[test]
     fn test_find_all_refs_field_name() {
-        let code = r#"
-            //- /lib.rs
-            struct Foo {
-                pub spam<|>: u32,
-            }
-
-            fn main(s: Foo) {
-                let f = s.spam;
-            }
-        "#;
+        let refs = get_all_refs(
+            r#"
+//- /lib.rs
+struct Foo {
+    pub spam<|>: u32,
+}
 
-        let refs = get_all_refs(code);
+fn main(s: Foo) {
+    let f = s.spam;
+}
+"#,
+        );
         check_result(
             refs,
-            "spam RECORD_FIELD_DEF FileId(1) 66..79 70..74 Other",
-            &["FileId(1) 152..156 Other Read"],
+            "spam RECORD_FIELD_DEF FileId(1) 17..30 21..25 Other",
+            &["FileId(1) 67..71 Other Read"],
         );
     }
 
     #[test]
     fn test_find_all_refs_impl_item_name() {
-        let code = r#"
-            //- /lib.rs
-            struct Foo;
-            impl Foo {
-                fn f<|>(&self) {  }
-            }
-        "#;
-
-        let refs = get_all_refs(code);
-        check_result(refs, "f FN_DEF FileId(1) 88..104 91..92 Other", &[]);
+        let refs = get_all_refs(
+            r#"
+struct Foo;
+impl Foo {
+    fn f<|>(&self) {  }
+}
+"#,
+        );
+        check_result(refs, "f FN_DEF FileId(1) 27..43 30..31 Other", &[]);
     }
 
     #[test]
     fn test_find_all_refs_enum_var_name() {
-        let code = r#"
-            //- /lib.rs
-            enum Foo {
-                A,
-                B<|>,
-                C,
-            }
-        "#;
-
-        let refs = get_all_refs(code);
-        check_result(refs, "B ENUM_VARIANT FileId(1) 83..84 83..84 Other", &[]);
+        let refs = get_all_refs(
+            r#"
+enum Foo {
+    A,
+    B<|>,
+    C,
+}
+"#,
+        );
+        check_result(refs, "B ENUM_VARIANT FileId(1) 22..23 22..23 Other", &[]);
     }
 
     #[test]
     fn test_find_all_refs_two_modules() {
-        let code = r#"
-            //- /lib.rs
-            pub mod foo;
-            pub mod bar;
-
-            fn f() {
-                let i = foo::Foo { n: 5 };
-            }
-
-            //- /foo.rs
-            use crate::bar;
+        let (analysis, pos) = analysis_and_position(
+            r#"
+//- /lib.rs
+pub mod foo;
+pub mod bar;
+
+fn f() {
+    let i = foo::Foo { n: 5 };
+}
 
-            pub struct Foo {
-                pub n: u32,
-            }
+//- /foo.rs
+use crate::bar;
 
-            fn f() {
-                let i = bar::Bar { n: 5 };
-            }
+pub struct Foo {
+    pub n: u32,
+}
 
-            //- /bar.rs
-            use crate::foo;
+fn f() {
+    let i = bar::Bar { n: 5 };
+}
 
-            pub struct Bar {
-                pub n: u32,
-            }
+//- /bar.rs
+use crate::foo;
 
-            fn f() {
-                let i = foo::Foo<|> { n: 5 };
-            }
-        "#;
+pub struct Bar {
+    pub n: u32,
+}
 
-        let (analysis, pos) = analysis_and_position(code);
+fn f() {
+    let i = foo::Foo<|> { n: 5 };
+}
+"#,
+        );
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
         check_result(
             refs,
-            "Foo STRUCT_DEF FileId(2) 16..50 27..30 Other",
-            &["FileId(1) 52..55 StructLiteral", "FileId(3) 77..80 StructLiteral"],
+            "Foo STRUCT_DEF FileId(2) 17..51 28..31 Other",
+            &["FileId(1) 53..56 StructLiteral", "FileId(3) 79..82 StructLiteral"],
         );
     }
 
@@ -437,53 +441,53 @@ mod tests {
     // which is the whole `foo.rs`, and the second one is in `use foo::Foo`.
     #[test]
     fn test_find_all_refs_decl_module() {
-        let code = r#"
-            //- /lib.rs
-            mod foo<|>;
+        let (analysis, pos) = analysis_and_position(
+            r#"
+//- /lib.rs
+mod foo<|>;
 
-            use foo::Foo;
+use foo::Foo;
 
-            fn f() {
-                let i = Foo { n: 5 };
-            }
-
-            //- /foo.rs
-            pub struct Foo {
-                pub n: u32,
-            }
-        "#;
+fn f() {
+    let i = Foo { n: 5 };
+}
 
-        let (analysis, pos) = analysis_and_position(code);
+//- /foo.rs
+pub struct Foo {
+    pub n: u32,
+}
+"#,
+        );
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        check_result(refs, "foo SOURCE_FILE FileId(2) 0..35 Other", &["FileId(1) 13..16 Other"]);
+        check_result(refs, "foo SOURCE_FILE FileId(2) 0..35 Other", &["FileId(1) 14..17 Other"]);
     }
 
     #[test]
     fn test_find_all_refs_super_mod_vis() {
-        let code = r#"
-            //- /lib.rs
-            mod foo;
-
-            //- /foo.rs
-            mod some;
-            use some::Foo;
+        let (analysis, pos) = analysis_and_position(
+            r#"
+//- /lib.rs
+mod foo;
 
-            fn f() {
-                let i = Foo { n: 5 };
-            }
+//- /foo.rs
+mod some;
+use some::Foo;
 
-            //- /foo/some.rs
-            pub(super) struct Foo<|> {
-                pub n: u32,
-            }
-        "#;
+fn f() {
+    let i = Foo { n: 5 };
+}
 
-        let (analysis, pos) = analysis_and_position(code);
+//- /foo/some.rs
+pub(super) struct Foo<|> {
+    pub n: u32,
+}
+"#,
+        );
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
         check_result(
             refs,
             "Foo STRUCT_DEF FileId(3) 0..41 18..21 Other",
-            &["FileId(2) 20..23 Other", "FileId(2) 46..49 StructLiteral"],
+            &["FileId(2) 20..23 Other", "FileId(2) 47..50 StructLiteral"],
         );
     }
 
@@ -510,7 +514,7 @@ mod tests {
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
         check_result(
             refs,
-            "quux FN_DEF FileId(1) 18..34 25..29 Other",
+            "quux FN_DEF FileId(1) 19..35 26..30 Other",
             &["FileId(2) 16..20 StructLiteral", "FileId(3) 16..20 StructLiteral"],
         );
 
@@ -518,100 +522,105 @@ mod tests {
             analysis.find_all_refs(pos, Some(SearchScope::single_file(bar))).unwrap().unwrap();
         check_result(
             refs,
-            "quux FN_DEF FileId(1) 18..34 25..29 Other",
+            "quux FN_DEF FileId(1) 19..35 26..30 Other",
             &["FileId(3) 16..20 StructLiteral"],
         );
     }
 
     #[test]
     fn test_find_all_refs_macro_def() {
-        let code = r#"
-        #[macro_export]
-        macro_rules! m1<|> { () => (()) }
-
-        fn foo() {
-            m1();
-            m1();
-        }"#;
-
-        let refs = get_all_refs(code);
+        let refs = get_all_refs(
+            r#"
+#[macro_export]
+macro_rules! m1<|> { () => (()) }
+
+fn foo() {
+    m1();
+    m1();
+}
+"#,
+        );
         check_result(
             refs,
-            "m1 MACRO_CALL FileId(1) 9..63 46..48 Other",
-            &["FileId(1) 96..98 StructLiteral", "FileId(1) 114..116 StructLiteral"],
+            "m1 MACRO_CALL FileId(1) 0..46 29..31 Other",
+            &["FileId(1) 63..65 StructLiteral", "FileId(1) 73..75 StructLiteral"],
         );
     }
 
     #[test]
     fn test_basic_highlight_read_write() {
-        let code = r#"
-        fn foo() {
-            let mut i<|> = 0;
-            i = i + 1;
-        }"#;
-
-        let refs = get_all_refs(code);
+        let refs = get_all_refs(
+            r#"
+fn foo() {
+    let mut i<|> = 0;
+    i = i + 1;
+}
+"#,
+        );
         check_result(
             refs,
-            "i BIND_PAT FileId(1) 40..41 Other Write",
-            &["FileId(1) 59..60 Other Write", "FileId(1) 63..64 Other Read"],
+            "i BIND_PAT FileId(1) 23..24 Other Write",
+            &["FileId(1) 34..35 Other Write", "FileId(1) 38..39 Other Read"],
         );
     }
 
     #[test]
     fn test_basic_highlight_field_read_write() {
-        let code = r#"
-        struct S {
-            f: u32,
-        }
-
-        fn foo() {
-            let mut s = S{f: 0};
-            s.f<|> = 0;
-        }"#;
+        let refs = get_all_refs(
+            r#"
+struct S {
+    f: u32,
+}
 
-        let refs = get_all_refs(code);
+fn foo() {
+    let mut s = S{f: 0};
+    s.f<|> = 0;
+}
+"#,
+        );
         check_result(
             refs,
-            "f RECORD_FIELD_DEF FileId(1) 32..38 32..33 Other",
-            &["FileId(1) 96..97 Other Read", "FileId(1) 117..118 Other Write"],
+            "f RECORD_FIELD_DEF FileId(1) 15..21 15..16 Other",
+            &["FileId(1) 55..56 Other Read", "FileId(1) 68..69 Other Write"],
         );
     }
 
     #[test]
     fn test_basic_highlight_decl_no_write() {
-        let code = r#"
-        fn foo() {
-            let i<|>;
-            i = 1;
-        }"#;
-
-        let refs = get_all_refs(code);
-        check_result(refs, "i BIND_PAT FileId(1) 36..37 Other", &["FileId(1) 51..52 Other Write"]);
+        let refs = get_all_refs(
+            r#"
+fn foo() {
+    let i<|>;
+    i = 1;
+}
+"#,
+        );
+        check_result(refs, "i BIND_PAT FileId(1) 19..20 Other", &["FileId(1) 26..27 Other Write"]);
     }
 
     #[test]
     fn test_find_struct_function_refs_outside_module() {
-        let code = r#"
-        mod foo {
-            pub struct Foo;
+        let refs = get_all_refs(
+            r#"
+mod foo {
+    pub struct Foo;
 
-            impl Foo {
-                pub fn new<|>() -> Foo {
-                    Foo
-                }
-            }
+    impl Foo {
+        pub fn new<|>() -> Foo {
+            Foo
         }
+    }
+}
 
-        fn main() {
-            let _f = foo::Foo::new();
-        }"#;
-
-        let refs = get_all_refs(code);
+fn main() {
+    let _f = foo::Foo::new();
+}
+"#,
+        );
         check_result(
             refs,
-            "new FN_DEF FileId(1) 87..150 94..97 Other",
-            &["FileId(1) 227..230 StructLiteral"],
+            "new FN_DEF FileId(1) 54..101 61..64 Other",
+            &["FileId(1) 146..149 StructLiteral"],
         );
     }
 
@@ -637,13 +646,13 @@ mod tests {
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
         check_result(
             refs,
-            "f FN_DEF FileId(1) 25..34 28..29 Other",
-            &["FileId(2) 11..12 Other", "FileId(2) 27..28 StructLiteral"],
+            "f FN_DEF FileId(1) 26..35 29..30 Other",
+            &["FileId(2) 11..12 Other", "FileId(2) 28..29 StructLiteral"],
         );
     }
 
-    fn get_all_refs(text: &str) -> ReferenceSearchResult {
-        let (analysis, position) = single_file_with_position(text);
+    fn get_all_refs(ra_fixture: &str) -> ReferenceSearchResult {
+        let (analysis, position) = analysis_and_position(ra_fixture);
         analysis.find_all_refs(position, None).unwrap().unwrap()
     }
 
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 28c6349b1..8735ec53c 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -1,11 +1,14 @@
 //! FIXME: write short doc here
 
-use hir::{ModuleSource, Semantics};
-use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
-use ra_ide_db::RootDatabase;
+use hir::{Module, ModuleDef, ModuleSource, Semantics};
+use ra_db::SourceDatabaseExt;
+use ra_ide_db::{
+    defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
+    RootDatabase,
+};
 use ra_syntax::{
-    algo::find_node_at_offset, ast, ast::TypeAscriptionOwner, lex_single_valid_syntax_kind,
-    AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
+    algo::find_node_at_offset, ast, ast::NameOwner, ast::TypeAscriptionOwner,
+    lex_single_valid_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
 };
 use ra_text_edit::TextEdit;
 use std::convert::TryInto;
@@ -21,35 +24,53 @@ pub(crate) fn rename(
     position: FilePosition,
     new_name: &str,
 ) -> Option<RangeInfo<SourceChange>> {
+    let sema = Semantics::new(db);
+
     match lex_single_valid_syntax_kind(new_name)? {
         SyntaxKind::IDENT | SyntaxKind::UNDERSCORE => (),
-        SyntaxKind::SELF_KW => return rename_to_self(db, position),
+        SyntaxKind::SELF_KW => return rename_to_self(&sema, position),
         _ => return None,
     }
 
-    let sema = Semantics::new(db);
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
-    if let Some((ast_name, ast_module)) = find_name_and_module_at_offset(syntax, position) {
-        let range = ast_name.syntax().text_range();
-        rename_mod(&sema, &ast_name, &ast_module, position, new_name)
-            .map(|info| RangeInfo::new(range, info))
+    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
+        rename_mod(&sema, position, module, new_name)
     } else if let Some(self_token) =
         syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
     {
-        rename_self_to_param(db, position, self_token, new_name)
+        rename_self_to_param(&sema, position, self_token, new_name)
     } else {
-        rename_reference(sema.db, position, new_name)
+        rename_reference(&sema, position, new_name)
     }
 }
 
-fn find_name_and_module_at_offset(
-    syntax: &SyntaxNode,
+fn find_module_at_offset(
+    sema: &Semantics<RootDatabase>,
     position: FilePosition,
-) -> Option<(ast::Name, ast::Module)> {
-    let ast_name = find_node_at_offset::<ast::Name>(syntax, position.offset)?;
-    let ast_module = ast::Module::cast(ast_name.syntax().parent()?)?;
-    Some((ast_name, ast_module))
+    syntax: &SyntaxNode,
+) -> Option<Module> {
+    let ident = syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::IDENT)?;
+
+    let module = match_ast! {
+        match (ident.parent()) {
+            ast::NameRef(name_ref) => {
+                match classify_name_ref(sema, &name_ref)? {
+                    NameRefClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
+                    _ => return None,
+                }
+            },
+            ast::Name(name) => {
+                match classify_name(&sema, &name)? {
+                    NameClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
+                    _ => return None,
+                }
+            },
+            _ => return None,
+        }
+    };
+
+    Some(module)
 }
 
 fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFileEdit {
@@ -78,61 +99,53 @@ fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFil
 
 fn rename_mod(
     sema: &Semantics<RootDatabase>,
-    ast_name: &ast::Name,
-    ast_module: &ast::Module,
     position: FilePosition,
+    module: Module,
     new_name: &str,
-) -> Option<SourceChange> {
+) -> Option<RangeInfo<SourceChange>> {
     let mut source_file_edits = Vec::new();
     let mut file_system_edits = Vec::new();
-    if let Some(module) = sema.to_def(ast_module) {
-        let src = module.definition_source(sema.db);
-        let file_id = src.file_id.original_file(sema.db);
-        match src.value {
-            ModuleSource::SourceFile(..) => {
-                let mod_path: RelativePathBuf = sema.db.file_relative_path(file_id);
-                // mod is defined in path/to/dir/mod.rs
-                let dst_path = if mod_path.file_stem() == Some("mod") {
-                    mod_path
-                        .parent()
-                        .and_then(|p| p.parent())
-                        .or_else(|| Some(RelativePath::new("")))
-                        .map(|p| p.join(new_name).join("mod.rs"))
-                } else {
-                    Some(mod_path.with_file_name(new_name).with_extension("rs"))
-                };
-                if let Some(path) = dst_path {
-                    let move_file = FileSystemEdit::MoveFile {
-                        src: file_id,
-                        dst_source_root: sema.db.file_source_root(position.file_id),
-                        dst_path: path,
-                    };
-                    file_system_edits.push(move_file);
-                }
-            }
-            ModuleSource::Module(..) => {}
+
+    let src = module.definition_source(sema.db);
+    let file_id = src.file_id.original_file(sema.db);
+    match src.value {
+        ModuleSource::SourceFile(..) => {
+            // mod is defined in path/to/dir/mod.rs
+            let dst = if module.is_mod_rs(sema.db) {
+                format!("../{}/mod.rs", new_name)
+            } else {
+                format!("{}.rs", new_name)
+            };
+            let move_file = FileSystemEdit::MoveFile { src: file_id, anchor: file_id, dst };
+            file_system_edits.push(move_file);
         }
+        ModuleSource::Module(..) => {}
     }
 
-    let edit = SourceFileEdit {
-        file_id: position.file_id,
-        edit: TextEdit::replace(ast_name.syntax().text_range(), new_name.into()),
-    };
-    source_file_edits.push(edit);
-
-    if let Some(RangeInfo { range: _, info: refs }) = find_all_refs(sema.db, position, None) {
-        let ref_edits = refs
-            .references
-            .into_iter()
-            .map(|reference| source_edit_from_reference(reference, new_name));
-        source_file_edits.extend(ref_edits);
+    if let Some(src) = module.declaration_source(sema.db) {
+        let file_id = src.file_id.original_file(sema.db);
+        let name = src.value.name()?;
+        let edit = SourceFileEdit {
+            file_id,
+            edit: TextEdit::replace(name.syntax().text_range(), new_name.into()),
+        };
+        source_file_edits.push(edit);
     }
 
-    Some(SourceChange::from_edits(source_file_edits, file_system_edits))
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)?;
+    let ref_edits = refs
+        .references
+        .into_iter()
+        .map(|reference| source_edit_from_reference(reference, new_name));
+    source_file_edits.extend(ref_edits);
+
+    Some(RangeInfo::new(range, SourceChange::from_edits(source_file_edits, file_system_edits)))
 }
 
-fn rename_to_self(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<SourceChange>> {
-    let sema = Semantics::new(db);
+fn rename_to_self(
+    sema: &Semantics<RootDatabase>,
+    position: FilePosition,
+) -> Option<RangeInfo<SourceChange>> {
     let source_file = sema.parse(position.file_id);
     let syn = source_file.syntax();
 
@@ -147,7 +160,7 @@ fn rename_to_self(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo
         _ => return None, // not renaming other types
     };
 
-    let RangeInfo { range, info: refs } = find_all_refs(db, position, None)?;
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)?;
 
     let param_range = first_param.syntax().text_range();
     let (param_ref, usages): (Vec<Reference>, Vec<Reference>) = refs
@@ -171,7 +184,7 @@ fn rename_to_self(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo
         ),
     });
 
-    Some(RangeInfo::new(range, SourceChange::source_file_edits(edits)))
+    Some(RangeInfo::new(range, SourceChange::from(edits)))
 }
 
 fn text_edit_from_self_param(
@@ -199,16 +212,15 @@ fn text_edit_from_self_param(
 }
 
 fn rename_self_to_param(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
     position: FilePosition,
     self_token: SyntaxToken,
     new_name: &str,
 ) -> Option<RangeInfo<SourceChange>> {
-    let sema = Semantics::new(db);
     let source_file = sema.parse(position.file_id);
     let syn = source_file.syntax();
 
-    let text = db.file_text(position.file_id);
+    let text = sema.db.file_text(position.file_id);
     let fn_def = find_node_at_offset::<ast::FnDef>(syn, position.offset)?;
     let search_range = fn_def.syntax().text_range();
 
@@ -234,15 +246,15 @@ fn rename_self_to_param(
     let range = ast::SelfParam::cast(self_token.parent())
         .map_or(self_token.text_range(), |p| p.syntax().text_range());
 
-    Some(RangeInfo::new(range, SourceChange::source_file_edits(edits)))
+    Some(RangeInfo::new(range, SourceChange::from(edits)))
 }
 
 fn rename_reference(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
     position: FilePosition,
     new_name: &str,
 ) -> Option<RangeInfo<SourceChange>> {
-    let RangeInfo { range, info: refs } = find_all_refs(db, position, None)?;
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)?;
 
     let edit = refs
         .into_iter()
@@ -253,57 +265,56 @@ fn rename_reference(
         return None;
     }
 
-    Some(RangeInfo::new(range, SourceChange::source_file_edits(edit)))
+    Some(RangeInfo::new(range, SourceChange::from(edit)))
 }
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
     use ra_text_edit::TextEditBuilder;
+    use stdx::trim_indent;
     use test_utils::{assert_eq_text, mark};
 
-    use crate::{
-        mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
-    };
+    use crate::{mock_analysis::analysis_and_position, FileId};
+
+    fn check(new_name: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
+        let ra_fixture_after = &trim_indent(ra_fixture_after);
+        let (analysis, position) = analysis_and_position(ra_fixture_before);
+        let source_change = analysis.rename(position, new_name).unwrap();
+        let mut text_edit_builder = TextEditBuilder::default();
+        let mut file_id: Option<FileId> = None;
+        if let Some(change) = source_change {
+            for edit in change.info.source_file_edits {
+                file_id = Some(edit.file_id);
+                for indel in edit.edit.into_iter() {
+                    text_edit_builder.replace(indel.delete, indel.insert);
+                }
+            }
+        }
+        let mut result = analysis.file_text(file_id.unwrap()).unwrap().to_string();
+        text_edit_builder.finish().apply(&mut result);
+        assert_eq_text!(ra_fixture_after, &*result);
+    }
+
+    fn check_expect(new_name: &str, ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
+        let source_change = analysis.rename(position, new_name).unwrap().unwrap();
+        expect.assert_debug_eq(&source_change)
+    }
 
     #[test]
     fn test_rename_to_underscore() {
-        test_rename(
-            r#"
-    fn main() {
-        let i<|> = 1;
-    }"#,
-            "_",
-            r#"
-    fn main() {
-        let _ = 1;
-    }"#,
-        );
+        check("_", r#"fn main() { let i<|> = 1; }"#, r#"fn main() { let _ = 1; }"#);
     }
 
     #[test]
     fn test_rename_to_raw_identifier() {
-        test_rename(
-            r#"
-    fn main() {
-        let i<|> = 1;
-    }"#,
-            "r#fn",
-            r#"
-    fn main() {
-        let r#fn = 1;
-    }"#,
-        );
+        check("r#fn", r#"fn main() { let i<|> = 1; }"#, r#"fn main() { let r#fn = 1; }"#);
     }
 
     #[test]
     fn test_rename_to_invalid_identifier() {
-        let (analysis, position) = single_file_with_position(
-            "
-    fn main() {
-        let i<|> = 1;
-    }",
-        );
+        let (analysis, position) = analysis_and_position(r#"fn main() { let i<|> = 1; }"#);
         let new_name = "invalid!";
         let source_change = analysis.rename(position, new_name).unwrap();
         assert!(source_change.is_none());
@@ -311,682 +322,689 @@ mod tests {
 
     #[test]
     fn test_rename_for_local() {
-        test_rename(
+        check(
+            "k",
             r#"
-    fn main() {
-        let mut i = 1;
-        let j = 1;
-        i = i<|> + j;
+fn main() {
+    let mut i = 1;
+    let j = 1;
+    i = i<|> + j;
 
-        {
-            i = 0;
-        }
+    { i = 0; }
 
-        i = 5;
-    }"#,
-            "k",
+    i = 5;
+}
+"#,
             r#"
-    fn main() {
-        let mut k = 1;
-        let j = 1;
-        k = k + j;
+fn main() {
+    let mut k = 1;
+    let j = 1;
+    k = k + j;
 
-        {
-            k = 0;
-        }
+    { k = 0; }
 
-        k = 5;
-    }"#,
+    k = 5;
+}
+"#,
         );
     }
 
     #[test]
     fn test_rename_for_macro_args() {
-        test_rename(
-            r#"
-    macro_rules! foo {($i:ident) => {$i} }
-    fn main() {
-        let a<|> = "test";
-        foo!(a);
-    }"#,
+        check(
             "b",
             r#"
-    macro_rules! foo {($i:ident) => {$i} }
-    fn main() {
-        let b = "test";
-        foo!(b);
-    }"#,
+macro_rules! foo {($i:ident) => {$i} }
+fn main() {
+    let a<|> = "test";
+    foo!(a);
+}
+"#,
+            r#"
+macro_rules! foo {($i:ident) => {$i} }
+fn main() {
+    let b = "test";
+    foo!(b);
+}
+"#,
         );
     }
 
     #[test]
     fn test_rename_for_macro_args_rev() {
-        test_rename(
-            r#"
-    macro_rules! foo {($i:ident) => {$i} }
-    fn main() {
-        let a = "test";
-        foo!(a<|>);
-    }"#,
+        check(
             "b",
             r#"
-    macro_rules! foo {($i:ident) => {$i} }
-    fn main() {
-        let b = "test";
-        foo!(b);
-    }"#,
+macro_rules! foo {($i:ident) => {$i} }
+fn main() {
+    let a = "test";
+    foo!(a<|>);
+}
+"#,
+            r#"
+macro_rules! foo {($i:ident) => {$i} }
+fn main() {
+    let b = "test";
+    foo!(b);
+}
+"#,
         );
     }
 
     #[test]
     fn test_rename_for_macro_define_fn() {
-        test_rename(
-            r#"
-    macro_rules! define_fn {($id:ident) => { fn $id{} }}
-    define_fn!(foo);
-    fn main() {
-        fo<|>o();
-    }"#,
+        check(
             "bar",
             r#"
-    macro_rules! define_fn {($id:ident) => { fn $id{} }}
-    define_fn!(bar);
-    fn main() {
-        bar();
-    }"#,
+macro_rules! define_fn {($id:ident) => { fn $id{} }}
+define_fn!(foo);
+fn main() {
+    fo<|>o();
+}
+"#,
+            r#"
+macro_rules! define_fn {($id:ident) => { fn $id{} }}
+define_fn!(bar);
+fn main() {
+    bar();
+}
+"#,
         );
     }
 
     #[test]
     fn test_rename_for_macro_define_fn_rev() {
-        test_rename(
-            r#"
-    macro_rules! define_fn {($id:ident) => { fn $id{} }}
-    define_fn!(fo<|>o);
-    fn main() {
-        foo();
-    }"#,
+        check(
             "bar",
             r#"
-    macro_rules! define_fn {($id:ident) => { fn $id{} }}
-    define_fn!(bar);
-    fn main() {
-        bar();
-    }"#,
+macro_rules! define_fn {($id:ident) => { fn $id{} }}
+define_fn!(fo<|>o);
+fn main() {
+    foo();
+}
+"#,
+            r#"
+macro_rules! define_fn {($id:ident) => { fn $id{} }}
+define_fn!(bar);
+fn main() {
+    bar();
+}
+"#,
         );
     }
 
     #[test]
     fn test_rename_for_param_inside() {
-        test_rename(
-            r#"
-    fn foo(i : u32) -> u32 {
-        i<|>
-    }"#,
-            "j",
-            r#"
-    fn foo(j : u32) -> u32 {
-        j
-    }"#,
-        );
+        check("j", r#"fn foo(i : u32) -> u32 { i<|> }"#, r#"fn foo(j : u32) -> u32 { j }"#);
     }
 
     #[test]
     fn test_rename_refs_for_fn_param() {
-        test_rename(
-            r#"
-    fn foo(i<|> : u32) -> u32 {
-        i
-    }"#,
-            "new_name",
-            r#"
-    fn foo(new_name : u32) -> u32 {
-        new_name
-    }"#,
-        );
+        check("j", r#"fn foo(i<|> : u32) -> u32 { i }"#, r#"fn foo(j : u32) -> u32 { j }"#);
     }
 
     #[test]
     fn test_rename_for_mut_param() {
-        test_rename(
-            r#"
-    fn foo(mut i<|> : u32) -> u32 {
-        i
-    }"#,
-            "new_name",
-            r#"
-    fn foo(mut new_name : u32) -> u32 {
-        new_name
-    }"#,
-        );
+        check("j", r#"fn foo(mut i<|> : u32) -> u32 { i }"#, r#"fn foo(mut j : u32) -> u32 { j }"#);
     }
 
     #[test]
     fn test_rename_struct_field() {
-        test_rename(
+        check(
+            "j",
             r#"
-    struct Foo {
-        i<|>: i32,
-    }
+struct Foo { i<|>: i32 }
 
-    impl Foo {
-        fn new(i: i32) -> Self {
-            Self { i: i }
-        }
+impl Foo {
+    fn new(i: i32) -> Self {
+        Self { i: i }
     }
-    "#,
-            "j",
+}
+"#,
             r#"
-    struct Foo {
-        j: i32,
-    }
+struct Foo { j: i32 }
 
-    impl Foo {
-        fn new(i: i32) -> Self {
-            Self { j: i }
-        }
+impl Foo {
+    fn new(i: i32) -> Self {
+        Self { j: i }
     }
-    "#,
+}
+"#,
         );
     }
 
     #[test]
     fn test_rename_struct_field_for_shorthand() {
         mark::check!(test_rename_struct_field_for_shorthand);
-        test_rename(
+        check(
+            "j",
             r#"
-    struct Foo {
-        i<|>: i32,
-    }
+struct Foo { i<|>: i32 }
 
-    impl Foo {
-        fn new(i: i32) -> Self {
-            Self { i }
-        }
+impl Foo {
+    fn new(i: i32) -> Self {
+        Self { i }
     }
-    "#,
-            "j",
+}
+"#,
             r#"
-    struct Foo {
-        j: i32,
-    }
+struct Foo { j: i32 }
 
-    impl Foo {
-        fn new(i: i32) -> Self {
-            Self { j: i }
-        }
+impl Foo {
+    fn new(i: i32) -> Self {
+        Self { j: i }
     }
-    "#,
+}
+"#,
         );
     }
 
     #[test]
     fn test_rename_local_for_field_shorthand() {
         mark::check!(test_rename_local_for_field_shorthand);
-        test_rename(
+        check(
+            "j",
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    impl Foo {
-        fn new(i<|>: i32) -> Self {
-            Self { i }
-        }
+impl Foo {
+    fn new(i<|>: i32) -> Self {
+        Self { i }
     }
-    "#,
-            "j",
+}
+"#,
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    impl Foo {
-        fn new(j: i32) -> Self {
-            Self { i: j }
-        }
+impl Foo {
+    fn new(j: i32) -> Self {
+        Self { i: j }
     }
-    "#,
+}
+"#,
         );
     }
 
     #[test]
     fn test_field_shorthand_correct_struct() {
-        test_rename(
-            r#"
-    struct Foo {
-        i<|>: i32,
-    }
-
-    struct Bar {
-        i: i32,
-    }
-
-    impl Bar {
-        fn new(i: i32) -> Self {
-            Self { i }
-        }
-    }
-    "#,
+        check(
             "j",
             r#"
-    struct Foo {
-        j: i32,
-    }
+struct Foo { i<|>: i32 }
+struct Bar { i: i32 }
 
-    struct Bar {
-        i: i32,
+impl Bar {
+    fn new(i: i32) -> Self {
+        Self { i }
     }
+}
+"#,
+            r#"
+struct Foo { j: i32 }
+struct Bar { i: i32 }
 
-    impl Bar {
-        fn new(i: i32) -> Self {
-            Self { i }
-        }
+impl Bar {
+    fn new(i: i32) -> Self {
+        Self { i }
     }
-    "#,
+}
+"#,
         );
     }
 
     #[test]
     fn test_shadow_local_for_struct_shorthand() {
-        test_rename(
+        check(
+            "j",
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    fn baz(i<|>: i32) -> Self {
-         let x = Foo { i };
-         {
-             let i = 0;
-             Foo { i }
-         }
+fn baz(i<|>: i32) -> Self {
+     let x = Foo { i };
+     {
+         let i = 0;
+         Foo { i }
      }
-    "#,
-            "j",
+}
+"#,
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    fn baz(j: i32) -> Self {
-         let x = Foo { i: j };
-         {
-             let i = 0;
-             Foo { i }
-         }
+fn baz(j: i32) -> Self {
+     let x = Foo { i: j };
+     {
+         let i = 0;
+         Foo { i }
      }
-    "#,
+}
+"#,
         );
     }
 
     #[test]
     fn test_rename_mod() {
-        let (analysis, position) = analysis_and_position(
-            "
-            //- /lib.rs
-            mod bar;
-
-            //- /bar.rs
-            mod foo<|>;
-
-            //- /bar/foo.rs
-            // emtpy
-            ",
+        check_expect(
+            "foo2",
+            r#"
+//- /lib.rs
+mod bar;
+
+//- /bar.rs
+mod foo<|>;
+
+//- /bar/foo.rs
+// empty
+"#,
+            expect![[r#"
+                RangeInfo {
+                    range: 4..7,
+                    info: SourceChange {
+                        source_file_edits: [
+                            SourceFileEdit {
+                                file_id: FileId(
+                                    2,
+                                ),
+                                edit: TextEdit {
+                                    indels: [
+                                        Indel {
+                                            insert: "foo2",
+                                            delete: 4..7,
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                        file_system_edits: [
+                            MoveFile {
+                                src: FileId(
+                                    3,
+                                ),
+                                anchor: FileId(
+                                    3,
+                                ),
+                                dst: "foo2.rs",
+                            },
+                        ],
+                        is_snippet: false,
+                    },
+                }
+            "#]],
         );
-        let new_name = "foo2";
-        let source_change = analysis.rename(position, new_name).unwrap();
-        assert_debug_snapshot!(&source_change,
-@r###"
-        Some(
-            RangeInfo {
-                range: 4..7,
-                info: SourceChange {
-                    source_file_edits: [
-                        SourceFileEdit {
-                            file_id: FileId(
-                                2,
-                            ),
-                            edit: TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 4..7,
-                                    },
-                                ],
+    }
+
+    #[test]
+    fn test_rename_mod_in_use_tree() {
+        check_expect(
+            "quux",
+            r#"
+//- /main.rs
+pub mod foo;
+pub mod bar;
+fn main() {}
+
+//- /foo.rs
+pub struct FooContent;
+
+//- /bar.rs
+use crate::foo<|>::FooContent;
+"#,
+            expect![[r#"
+                RangeInfo {
+                    range: 11..14,
+                    info: SourceChange {
+                        source_file_edits: [
+                            SourceFileEdit {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                edit: TextEdit {
+                                    indels: [
+                                        Indel {
+                                            insert: "quux",
+                                            delete: 8..11,
+                                        },
+                                    ],
+                                },
                             },
-                        },
-                    ],
-                    file_system_edits: [
-                        MoveFile {
-                            src: FileId(
-                                3,
-                            ),
-                            dst_source_root: SourceRootId(
-                                0,
-                            ),
-                            dst_path: "bar/foo2.rs",
-                        },
-                    ],
-                    is_snippet: false,
-                },
-            },
-        )
-        "###);
+                            SourceFileEdit {
+                                file_id: FileId(
+                                    3,
+                                ),
+                                edit: TextEdit {
+                                    indels: [
+                                        Indel {
+                                            insert: "quux",
+                                            delete: 11..14,
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                        file_system_edits: [
+                            MoveFile {
+                                src: FileId(
+                                    2,
+                                ),
+                                anchor: FileId(
+                                    2,
+                                ),
+                                dst: "quux.rs",
+                            },
+                        ],
+                        is_snippet: false,
+                    },
+                }
+            "#]],
+        );
     }
 
     #[test]
     fn test_rename_mod_in_dir() {
-        let (analysis, position) = analysis_and_position(
-            "
-            //- /lib.rs
-            mod fo<|>o;
-            //- /foo/mod.rs
-            // emtpy
-            ",
-        );
-        let new_name = "foo2";
-        let source_change = analysis.rename(position, new_name).unwrap();
-        assert_debug_snapshot!(&source_change,
-        @r###"
-        Some(
-            RangeInfo {
-                range: 4..7,
-                info: SourceChange {
-                    source_file_edits: [
-                        SourceFileEdit {
-                            file_id: FileId(
-                                1,
-                            ),
-                            edit: TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 4..7,
-                                    },
-                                ],
+        check_expect(
+            "foo2",
+            r#"
+//- /lib.rs
+mod fo<|>o;
+//- /foo/mod.rs
+// emtpy
+"#,
+            expect![[r#"
+                RangeInfo {
+                    range: 4..7,
+                    info: SourceChange {
+                        source_file_edits: [
+                            SourceFileEdit {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                edit: TextEdit {
+                                    indels: [
+                                        Indel {
+                                            insert: "foo2",
+                                            delete: 4..7,
+                                        },
+                                    ],
+                                },
                             },
-                        },
-                    ],
-                    file_system_edits: [
-                        MoveFile {
-                            src: FileId(
-                                2,
-                            ),
-                            dst_source_root: SourceRootId(
-                                0,
-                            ),
-                            dst_path: "foo2/mod.rs",
-                        },
-                    ],
-                    is_snippet: false,
-                },
-            },
-        )
-        "###
-               );
+                        ],
+                        file_system_edits: [
+                            MoveFile {
+                                src: FileId(
+                                    2,
+                                ),
+                                anchor: FileId(
+                                    2,
+                                ),
+                                dst: "../foo2/mod.rs",
+                            },
+                        ],
+                        is_snippet: false,
+                    },
+                }
+            "#]],
+        );
     }
 
     #[test]
-    fn test_module_rename_in_path() {
-        test_rename(
+    fn test_rename_unusually_nested_mod() {
+        check_expect(
+            "bar",
             r#"
-    mod <|>foo {
-        pub fn bar() {}
+//- /lib.rs
+mod outer { mod fo<|>o; }
+
+//- /outer/foo.rs
+// emtpy
+"#,
+            expect![[r#"
+                RangeInfo {
+                    range: 16..19,
+                    info: SourceChange {
+                        source_file_edits: [
+                            SourceFileEdit {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                edit: TextEdit {
+                                    indels: [
+                                        Indel {
+                                            insert: "bar",
+                                            delete: 16..19,
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                        file_system_edits: [
+                            MoveFile {
+                                src: FileId(
+                                    2,
+                                ),
+                                anchor: FileId(
+                                    2,
+                                ),
+                                dst: "bar.rs",
+                            },
+                        ],
+                        is_snippet: false,
+                    },
+                }
+            "#]],
+        );
     }
 
-    fn main() {
-        foo::bar();
-    }"#,
+    #[test]
+    fn test_module_rename_in_path() {
+        check(
             "baz",
             r#"
-    mod baz {
-        pub fn bar() {}
-    }
+mod <|>foo { pub fn bar() {} }
 
-    fn main() {
-        baz::bar();
-    }"#,
+fn main() { foo::bar(); }
+"#,
+            r#"
+mod baz { pub fn bar() {} }
+
+fn main() { baz::bar(); }
+"#,
         );
     }
 
     #[test]
     fn test_rename_mod_filename_and_path() {
-        let (analysis, position) = analysis_and_position(
-            "
-            //- /lib.rs
-            mod bar;
-            fn f() {
-                bar::foo::fun()
-            }
-
-            //- /bar.rs
-            pub mod foo<|>;
+        check_expect(
+            "foo2",
+            r#"
+//- /lib.rs
+mod bar;
+fn f() {
+    bar::foo::fun()
+}
 
-            //- /bar/foo.rs
-            // pub fn fun() {}
-            ",
-        );
-        let new_name = "foo2";
-        let source_change = analysis.rename(position, new_name).unwrap();
-        assert_debug_snapshot!(&source_change,
-@r###"
-        Some(
-            RangeInfo {
-                range: 8..11,
-                info: SourceChange {
-                    source_file_edits: [
-                        SourceFileEdit {
-                            file_id: FileId(
-                                2,
-                            ),
-                            edit: TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 8..11,
-                                    },
-                                ],
+//- /bar.rs
+pub mod foo<|>;
+
+//- /bar/foo.rs
+// pub fn fun() {}
+"#,
+            expect![[r#"
+                RangeInfo {
+                    range: 8..11,
+                    info: SourceChange {
+                        source_file_edits: [
+                            SourceFileEdit {
+                                file_id: FileId(
+                                    2,
+                                ),
+                                edit: TextEdit {
+                                    indels: [
+                                        Indel {
+                                            insert: "foo2",
+                                            delete: 8..11,
+                                        },
+                                    ],
+                                },
                             },
-                        },
-                        SourceFileEdit {
-                            file_id: FileId(
-                                1,
-                            ),
-                            edit: TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 27..30,
-                                    },
-                                ],
+                            SourceFileEdit {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                edit: TextEdit {
+                                    indels: [
+                                        Indel {
+                                            insert: "foo2",
+                                            delete: 27..30,
+                                        },
+                                    ],
+                                },
                             },
-                        },
-                    ],
-                    file_system_edits: [
-                        MoveFile {
-                            src: FileId(
-                                3,
-                            ),
-                            dst_source_root: SourceRootId(
-                                0,
-                            ),
-                            dst_path: "bar/foo2.rs",
-                        },
-                    ],
-                    is_snippet: false,
-                },
-            },
-        )
-        "###);
+                        ],
+                        file_system_edits: [
+                            MoveFile {
+                                src: FileId(
+                                    3,
+                                ),
+                                anchor: FileId(
+                                    3,
+                                ),
+                                dst: "foo2.rs",
+                            },
+                        ],
+                        is_snippet: false,
+                    },
+                }
+            "#]],
+        );
     }
 
     #[test]
     fn test_enum_variant_from_module_1() {
-        test_rename(
+        check(
+            "Baz",
             r#"
-    mod foo {
-        pub enum Foo {
-            Bar<|>,
-        }
-    }
+mod foo {
+    pub enum Foo { Bar<|> }
+}
 
-    fn func(f: foo::Foo) {
-        match f {
-            foo::Foo::Bar => {}
-        }
+fn func(f: foo::Foo) {
+    match f {
+        foo::Foo::Bar => {}
     }
-    "#,
-            "Baz",
+}
+"#,
             r#"
-    mod foo {
-        pub enum Foo {
-            Baz,
-        }
-    }
+mod foo {
+    pub enum Foo { Baz }
+}
 
-    fn func(f: foo::Foo) {
-        match f {
-            foo::Foo::Baz => {}
-        }
+fn func(f: foo::Foo) {
+    match f {
+        foo::Foo::Baz => {}
     }
-    "#,
+}
+"#,
         );
     }
 
     #[test]
     fn test_enum_variant_from_module_2() {
-        test_rename(
+        check(
+            "baz",
             r#"
-    mod foo {
-        pub struct Foo {
-            pub bar<|>: uint,
-        }
-    }
+mod foo {
+    pub struct Foo { pub bar<|>: uint }
+}
 
-    fn foo(f: foo::Foo) {
-        let _ = f.bar;
-    }
-    "#,
-            "baz",
+fn foo(f: foo::Foo) {
+    let _ = f.bar;
+}
+"#,
             r#"
-    mod foo {
-        pub struct Foo {
-            pub baz: uint,
-        }
-    }
+mod foo {
+    pub struct Foo { pub baz: uint }
+}
 
-    fn foo(f: foo::Foo) {
-        let _ = f.baz;
-    }
-    "#,
+fn foo(f: foo::Foo) {
+    let _ = f.baz;
+}
+"#,
         );
     }
 
     #[test]
     fn test_parameter_to_self() {
-        test_rename(
+        check(
+            "self",
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    impl Foo {
-        fn f(foo<|>: &mut Foo) -> i32 {
-            foo.i
-        }
+impl Foo {
+    fn f(foo<|>: &mut Foo) -> i32 {
+        foo.i
     }
-    "#,
-            "self",
+}
+"#,
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    impl Foo {
-        fn f(&mut self) -> i32 {
-            self.i
-        }
+impl Foo {
+    fn f(&mut self) -> i32 {
+        self.i
     }
-    "#,
+}
+"#,
         );
     }
 
     #[test]
     fn test_self_to_parameter() {
-        test_rename(
+        check(
+            "foo",
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    impl Foo {
-        fn f(&mut <|>self) -> i32 {
-            self.i
-        }
+impl Foo {
+    fn f(&mut <|>self) -> i32 {
+        self.i
     }
-    "#,
-            "foo",
+}
+"#,
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    impl Foo {
-        fn f(foo: &mut Foo) -> i32 {
-            foo.i
-        }
+impl Foo {
+    fn f(foo: &mut Foo) -> i32 {
+        foo.i
     }
-    "#,
+}
+"#,
         );
     }
 
     #[test]
     fn test_self_in_path_to_parameter() {
-        test_rename(
+        check(
+            "foo",
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    impl Foo {
-        fn f(&self) -> i32 {
-            let self_var = 1;
-            self<|>.i
-        }
+impl Foo {
+    fn f(&self) -> i32 {
+        let self_var = 1;
+        self<|>.i
     }
-    "#,
-            "foo",
+}
+"#,
             r#"
-    struct Foo {
-        i: i32,
-    }
+struct Foo { i: i32 }
 
-    impl Foo {
-        fn f(foo: &Foo) -> i32 {
-            let self_var = 1;
-            foo.i
-        }
+impl Foo {
+    fn f(foo: &Foo) -> i32 {
+        let self_var = 1;
+        foo.i
     }
-    "#,
+}
+"#,
         );
     }
-
-    fn test_rename(text: &str, new_name: &str, expected: &str) {
-        let (analysis, position) = single_file_with_position(text);
-        let source_change = analysis.rename(position, new_name).unwrap();
-        let mut text_edit_builder = TextEditBuilder::default();
-        let mut file_id: Option<FileId> = None;
-        if let Some(change) = source_change {
-            for edit in change.info.source_file_edits {
-                file_id = Some(edit.file_id);
-                for indel in edit.edit.into_iter() {
-                    text_edit_builder.replace(indel.delete, indel.insert);
-                }
-            }
-        }
-        let mut result = analysis.file_text(file_id.unwrap()).unwrap().to_string();
-        text_edit_builder.finish().apply(&mut result);
-        assert_eq_text!(expected, &*result);
-    }
 }
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index 286d45eee..ed15d6494 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -1,31 +1,31 @@
+use std::fmt;
+
 use hir::{AsAssocItem, Attrs, HirFileId, InFile, Semantics};
 use itertools::Itertools;
+use ra_cfg::CfgExpr;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
-    ast::{self, AstNode, AttrsOwner, ModuleItemOwner, NameOwner},
-    match_ast, SyntaxNode, TextRange,
+    ast::{self, AstNode, AttrsOwner, DocCommentsOwner, ModuleItemOwner, NameOwner},
+    match_ast, SyntaxNode,
 };
 
-use crate::FileId;
-use ast::DocCommentsOwner;
-use ra_cfg::CfgExpr;
-use std::fmt::Display;
+use crate::{display::ToNav, FileId, NavigationTarget};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Runnable {
-    pub range: TextRange,
+    pub nav: NavigationTarget,
     pub kind: RunnableKind,
     pub cfg_exprs: Vec<CfgExpr>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum TestId {
     Name(String),
     Path(String),
 }
 
-impl Display for TestId {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl fmt::Display for TestId {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             TestId::Name(name) => write!(f, "{}", name),
             TestId::Path(path) => write!(f, "{}", path),
@@ -33,7 +33,7 @@ impl Display for TestId {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum RunnableKind {
     Test { test_id: TestId, attr: TestAttr },
     TestMod { path: String },
@@ -42,6 +42,42 @@ pub enum RunnableKind {
     Bin,
 }
 
+#[derive(Debug, Eq, PartialEq)]
+pub struct RunnableAction {
+    pub run_title: &'static str,
+    pub debugee: bool,
+}
+
+const TEST: RunnableAction = RunnableAction { run_title: "▶\u{fe0e} Run Test", debugee: true };
+const DOCTEST: RunnableAction =
+    RunnableAction { run_title: "▶\u{fe0e} Run Doctest", debugee: false };
+const BENCH: RunnableAction = RunnableAction { run_title: "▶\u{fe0e} Run Bench", debugee: true };
+const BIN: RunnableAction = RunnableAction { run_title: "▶\u{fe0e} Run", debugee: true };
+
+impl Runnable {
+    // test package::module::testname
+    pub fn label(&self, target: Option<String>) -> String {
+        match &self.kind {
+            RunnableKind::Test { test_id, .. } => format!("test {}", test_id),
+            RunnableKind::TestMod { path } => format!("test-mod {}", path),
+            RunnableKind::Bench { test_id } => format!("bench {}", test_id),
+            RunnableKind::DocTest { test_id, .. } => format!("doctest {}", test_id),
+            RunnableKind::Bin => {
+                target.map_or_else(|| "run binary".to_string(), |t| format!("run {}", t))
+            }
+        }
+    }
+
+    pub fn action(&self) -> &'static RunnableAction {
+        match &self.kind {
+            RunnableKind::Test { .. } | RunnableKind::TestMod { .. } => &TEST,
+            RunnableKind::DocTest { .. } => &DOCTEST,
+            RunnableKind::Bench { .. } => &BENCH,
+            RunnableKind::Bin => &BIN,
+        }
+    }
+}
+
 // Feature: Run
 //
 // Shows a popup suggesting to run a test/benchmark/binary **at the current cursor
@@ -59,7 +95,11 @@ pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
     source_file.syntax().descendants().filter_map(|i| runnable(&sema, i, file_id)).collect()
 }
 
-fn runnable(sema: &Semantics<RootDatabase>, item: SyntaxNode, file_id: FileId) -> Option<Runnable> {
+pub(crate) fn runnable(
+    sema: &Semantics<RootDatabase>,
+    item: SyntaxNode,
+    file_id: FileId,
+) -> Option<Runnable> {
     match_ast! {
         match item {
             ast::FnDef(it) => runnable_fn(sema, it, file_id),
@@ -131,10 +171,19 @@ fn runnable_fn(
     let cfg_exprs =
         attrs.by_key("cfg").tt_values().map(|subtree| ra_cfg::parse_cfg(subtree)).collect();
 
-    Some(Runnable { range: fn_def.syntax().text_range(), kind, cfg_exprs })
+    let nav = if let RunnableKind::DocTest { .. } = kind {
+        NavigationTarget::from_doc_commented(
+            sema.db,
+            InFile::new(file_id.into(), &fn_def),
+            InFile::new(file_id.into(), &fn_def),
+        )
+    } else {
+        NavigationTarget::from_named(sema.db, InFile::new(file_id.into(), &fn_def))
+    };
+    Some(Runnable { nav, kind, cfg_exprs })
 }
 
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 pub struct TestAttr {
     pub ignore: bool,
 }
@@ -183,7 +232,6 @@ fn runnable_mod(
     if !has_test_function {
         return None;
     }
-    let range = module.syntax().text_range();
     let module_def = sema.to_def(&module)?;
 
     let path = module_def
@@ -197,366 +245,586 @@ fn runnable_mod(
     let cfg_exprs =
         attrs.by_key("cfg").tt_values().map(|subtree| ra_cfg::parse_cfg(subtree)).collect();
 
-    Some(Runnable { range, kind: RunnableKind::TestMod { path }, cfg_exprs })
+    let nav = module_def.to_nav(sema.db);
+    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg_exprs })
 }
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
     use crate::mock_analysis::analysis_and_position;
 
+    use super::{RunnableAction, BENCH, BIN, DOCTEST, TEST};
+
+    fn check(
+        ra_fixture: &str,
+        // FIXME: fold this into `expect` as well
+        actions: &[&RunnableAction],
+        expect: Expect,
+    ) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
+        let runnables = analysis.runnables(position.file_id).unwrap();
+        expect.assert_debug_eq(&runnables);
+        assert_eq!(
+            actions,
+            runnables.into_iter().map(|it| it.action()).collect::<Vec<_>>().as_slice()
+        );
+    }
+
     #[test]
     fn test_runnables() {
-        let (analysis, pos) = analysis_and_position(
+        check(
             r#"
-        //- /lib.rs
-        <|> //empty
-        fn main() {}
-
-        #[test]
-        fn test_foo() {}
-
-        #[test]
-        #[ignore]
-        fn test_foo() {}
-        "#,
-        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                range: 1..21,
-                kind: Bin,
-                cfg_exprs: [],
-            },
-            Runnable {
-                range: 22..46,
-                kind: Test {
-                    test_id: Path(
-                        "test_foo",
-                    ),
-                    attr: TestAttr {
-                        ignore: false,
+//- /lib.rs
+<|>
+fn main() {}
+
+#[test]
+fn test_foo() {}
+
+#[test]
+#[ignore]
+fn test_foo() {}
+
+#[bench]
+fn bench() {}
+"#,
+            &[&BIN, &TEST, &TEST, &BENCH],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 1..13,
+                            name: "main",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                4..8,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Bin,
+                        cfg_exprs: [],
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 15..39,
+                            name: "test_foo",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                26..34,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "test_foo",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg_exprs: [],
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 41..75,
+                            name: "test_foo",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                62..70,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "test_foo",
+                            ),
+                            attr: TestAttr {
+                                ignore: true,
+                            },
+                        },
+                        cfg_exprs: [],
                     },
-                },
-                cfg_exprs: [],
-            },
-            Runnable {
-                range: 47..81,
-                kind: Test {
-                    test_id: Path(
-                        "test_foo",
-                    ),
-                    attr: TestAttr {
-                        ignore: true,
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 77..99,
+                            name: "bench",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                89..94,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Bench {
+                            test_id: Path(
+                                "bench",
+                            ),
+                        },
+                        cfg_exprs: [],
                     },
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
+                ]
+            "#]],
+        );
     }
 
     #[test]
     fn test_runnables_doc_test() {
-        let (analysis, pos) = analysis_and_position(
+        check(
             r#"
-        //- /lib.rs
-        <|> //empty
-        fn main() {}
-
-        /// ```
-        /// let x = 5;
-        /// ```
-        fn foo() {}
-        "#,
+//- /lib.rs
+<|>
+fn main() {}
+
+/// ```
+/// let x = 5;
+/// ```
+fn foo() {}
+"#,
+            &[&BIN, &DOCTEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 1..13,
+                            name: "main",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                4..8,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Bin,
+                        cfg_exprs: [],
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 15..57,
+                            name: "foo",
+                            kind: FN_DEF,
+                            focus_range: None,
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "foo",
+                            ),
+                        },
+                        cfg_exprs: [],
+                    },
+                ]
+            "#]],
         );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                range: 1..21,
-                kind: Bin,
-                cfg_exprs: [],
-            },
-            Runnable {
-                range: 22..64,
-                kind: DocTest {
-                    test_id: Path(
-                        "foo",
-                    ),
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
     }
 
     #[test]
     fn test_runnables_doc_test_in_impl() {
-        let (analysis, pos) = analysis_and_position(
+        check(
             r#"
-        //- /lib.rs
-        <|> //empty
-        fn main() {}
-
-        struct Data;
-        impl Data {
-            /// ```
-            /// let x = 5;
-            /// ```
-            fn foo() {}
-        }
-        "#,
+//- /lib.rs
+<|>
+fn main() {}
+
+struct Data;
+impl Data {
+    /// ```
+    /// let x = 5;
+    /// ```
+    fn foo() {}
+}
+"#,
+            &[&BIN, &DOCTEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 1..13,
+                            name: "main",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                4..8,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Bin,
+                        cfg_exprs: [],
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 44..98,
+                            name: "foo",
+                            kind: FN_DEF,
+                            focus_range: None,
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "Data::foo",
+                            ),
+                        },
+                        cfg_exprs: [],
+                    },
+                ]
+            "#]],
         );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                range: 1..21,
-                kind: Bin,
-                cfg_exprs: [],
-            },
-            Runnable {
-                range: 51..105,
-                kind: DocTest {
-                    test_id: Path(
-                        "Data::foo",
-                    ),
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
     }
 
     #[test]
     fn test_runnables_module() {
-        let (analysis, pos) = analysis_and_position(
+        check(
             r#"
-        //- /lib.rs
-        <|> //empty
-        mod test_mod {
-            #[test]
-            fn test_foo1() {}
-        }
-        "#,
-        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                range: 1..59,
-                kind: TestMod {
-                    path: "test_mod",
-                },
-                cfg_exprs: [],
-            },
-            Runnable {
-                range: 28..57,
-                kind: Test {
-                    test_id: Path(
-                        "test_mod::test_foo1",
-                    ),
-                    attr: TestAttr {
-                        ignore: false,
+//- /lib.rs
+<|>
+mod test_mod {
+    #[test]
+    fn test_foo1() {}
+}
+"#,
+            &[&TEST, &TEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 1..51,
+                            name: "test_mod",
+                            kind: MODULE,
+                            focus_range: Some(
+                                5..13,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: TestMod {
+                            path: "test_mod",
+                        },
+                        cfg_exprs: [],
                     },
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 20..49,
+                            name: "test_foo1",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                35..44,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "test_mod::test_foo1",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg_exprs: [],
+                    },
+                ]
+            "#]],
+        );
     }
 
     #[test]
     fn test_runnables_one_depth_layer_module() {
-        let (analysis, pos) = analysis_and_position(
+        check(
             r#"
-        //- /lib.rs
-        <|> //empty
-        mod foo {
-            mod test_mod {
-                #[test]
-                fn test_foo1() {}
-            }
-        }
-        "#,
-        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                range: 23..85,
-                kind: TestMod {
-                    path: "foo::test_mod",
-                },
-                cfg_exprs: [],
-            },
-            Runnable {
-                range: 46..79,
-                kind: Test {
-                    test_id: Path(
-                        "foo::test_mod::test_foo1",
-                    ),
-                    attr: TestAttr {
-                        ignore: false,
+//- /lib.rs
+<|>
+mod foo {
+    mod test_mod {
+        #[test]
+        fn test_foo1() {}
+    }
+}
+"#,
+            &[&TEST, &TEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 15..77,
+                            name: "test_mod",
+                            kind: MODULE,
+                            focus_range: Some(
+                                19..27,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: TestMod {
+                            path: "foo::test_mod",
+                        },
+                        cfg_exprs: [],
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 38..71,
+                            name: "test_foo1",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                57..66,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "foo::test_mod::test_foo1",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg_exprs: [],
                     },
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
+                ]
+            "#]],
+        );
     }
 
     #[test]
     fn test_runnables_multiple_depth_module() {
-        let (analysis, pos) = analysis_and_position(
+        check(
             r#"
-        //- /lib.rs
-        <|> //empty
-        mod foo {
-            mod bar {
-                mod test_mod {
-                    #[test]
-                    fn test_foo1() {}
-                }
-            }
+//- /lib.rs
+<|>
+mod foo {
+    mod bar {
+        mod test_mod {
+            #[test]
+            fn test_foo1() {}
         }
-        "#,
-        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                range: 41..115,
-                kind: TestMod {
-                    path: "foo::bar::test_mod",
-                },
-                cfg_exprs: [],
-            },
-            Runnable {
-                range: 68..105,
-                kind: Test {
-                    test_id: Path(
-                        "foo::bar::test_mod::test_foo1",
-                    ),
-                    attr: TestAttr {
-                        ignore: false,
+    }
+}
+"#,
+            &[&TEST, &TEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 33..107,
+                            name: "test_mod",
+                            kind: MODULE,
+                            focus_range: Some(
+                                37..45,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: TestMod {
+                            path: "foo::bar::test_mod",
+                        },
+                        cfg_exprs: [],
                     },
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 60..97,
+                            name: "test_foo1",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                83..92,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "foo::bar::test_mod::test_foo1",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg_exprs: [],
+                    },
+                ]
+            "#]],
+        );
     }
 
     #[test]
     fn test_runnables_with_feature() {
-        let (analysis, pos) = analysis_and_position(
+        check(
             r#"
-        //- /lib.rs crate:foo cfg:feature=foo
-        <|> //empty
-        #[test]
-        #[cfg(feature = "foo")]
-        fn test_foo1() {}
-        "#,
-        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                range: 1..58,
-                kind: Test {
-                    test_id: Path(
-                        "test_foo1",
-                    ),
-                    attr: TestAttr {
-                        ignore: false,
-                    },
-                },
-                cfg_exprs: [
-                    KeyValue {
-                        key: "feature",
-                        value: "foo",
+//- /lib.rs crate:foo cfg:feature=foo
+<|>
+#[test]
+#[cfg(feature = "foo")]
+fn test_foo1() {}
+"#,
+            &[&TEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 1..50,
+                            name: "test_foo1",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                36..45,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "test_foo1",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg_exprs: [
+                            KeyValue {
+                                key: "feature",
+                                value: "foo",
+                            },
+                        ],
                     },
-                ],
-            },
-        ]
-        "###
-                );
+                ]
+            "#]],
+        );
     }
 
     #[test]
     fn test_runnables_with_features() {
-        let (analysis, pos) = analysis_and_position(
+        check(
             r#"
-        //- /lib.rs crate:foo cfg:feature=foo,feature=bar
-        <|> //empty
-        #[test]
-        #[cfg(all(feature = "foo", feature = "bar"))]
-        fn test_foo1() {}
-        "#,
-        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                range: 1..80,
-                kind: Test {
-                    test_id: Path(
-                        "test_foo1",
-                    ),
-                    attr: TestAttr {
-                        ignore: false,
-                    },
-                },
-                cfg_exprs: [
-                    All(
-                        [
-                            KeyValue {
-                                key: "feature",
-                                value: "foo",
-                            },
-                            KeyValue {
-                                key: "feature",
-                                value: "bar",
+//- /lib.rs crate:foo cfg:feature=foo,feature=bar
+<|>
+#[test]
+#[cfg(all(feature = "foo", feature = "bar"))]
+fn test_foo1() {}
+"#,
+            &[&TEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 1..72,
+                            name: "test_foo1",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                58..67,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "test_foo1",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
                             },
+                        },
+                        cfg_exprs: [
+                            All(
+                                [
+                                    KeyValue {
+                                        key: "feature",
+                                        value: "foo",
+                                    },
+                                    KeyValue {
+                                        key: "feature",
+                                        value: "bar",
+                                    },
+                                ],
+                            ),
                         ],
-                    ),
-                ],
-            },
-        ]
-        "###
-                );
+                    },
+                ]
+            "#]],
+        );
     }
 
     #[test]
     fn test_runnables_no_test_function_in_module() {
-        let (analysis, pos) = analysis_and_position(
+        check(
             r#"
-        //- /lib.rs
-        <|> //empty
-        mod test_mod {
-            fn foo1() {}
-        }
-        "#,
+//- /lib.rs
+<|>
+mod test_mod {
+    fn foo1() {}
+}
+"#,
+            &[],
+            expect![[r#"
+                []
+            "#]],
         );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert!(runnables.is_empty())
     }
 }
diff --git a/crates/ra_ide/src/snapshots/highlight_injection.html b/crates/ra_ide/src/snapshots/highlight_injection.html
deleted file mode 100644
index 68fc589bc..000000000
--- a/crates/ra_ide/src/snapshots/highlight_injection.html
+++ /dev/null
@@ -1,41 +0,0 @@
-
-<style>
-body                { margin: 0; }
-pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
-
-.lifetime           { color: #DFAF8F; font-style: italic; }
-.comment            { color: #7F9F7F; }
-.struct, .enum      { color: #7CB8BB; }
-.enum_variant       { color: #BDE0F3; }
-.string_literal     { color: #CC9393; }
-.field              { color: #94BFF3; }
-.function           { color: #93E0E3; }
-.parameter          { color: #94BFF3; }
-.text               { color: #DCDCCC; }
-.type               { color: #7CB8BB; }
-.builtin_type       { color: #8CD0D3; }
-.type_param         { color: #DFAF8F; }
-.attribute          { color: #94BFF3; }
-.numeric_literal    { color: #BFEBBF; }
-.bool_literal       { color: #BFE6EB; }
-.macro              { color: #94BFF3; }
-.module             { color: #AFD8AF; }
-.variable           { color: #DCDCCC; }
-.format_specifier   { color: #CC696B; }
-.mutable            { text-decoration: underline; }
-
-.keyword            { color: #F0DFAF; font-weight: bold; }
-.keyword.unsafe     { color: #BC8383; font-weight: bold; }
-.control            { font-style: italic; }
-</style>
-<pre><code><span class="keyword">fn</span> <span class="function declaration">fixture</span>(<span class="variable declaration">ra_fixture</span>: &<span class="builtin_type">str</span>) {}
-
-<span class="keyword">fn</span> <span class="function declaration">main</span>() {
-    <span class="function">fixture</span>(<span class="string_literal">r#"</span>
-        <span class="keyword">trait</span> <span class="trait declaration">Foo</span> {
-            <span class="keyword">fn</span> <span class="function declaration">foo</span>() {
-                <span class="macro">println!</span>(<span class="string_literal">"2 + 2 = {}"</span>, <span class="numeric_literal">4</span>);
-            }
-        }<span class="string_literal">"#</span>
-    );
-}</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide/src/snapshots/highlight_strings.html b/crates/ra_ide/src/snapshots/highlight_strings.html
deleted file mode 100644
index 326744361..000000000
--- a/crates/ra_ide/src/snapshots/highlight_strings.html
+++ /dev/null
@@ -1,84 +0,0 @@
-
-<style>
-body                { margin: 0; }
-pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
-
-.lifetime           { color: #DFAF8F; font-style: italic; }
-.comment            { color: #7F9F7F; }
-.struct, .enum      { color: #7CB8BB; }
-.enum_variant       { color: #BDE0F3; }
-.string_literal     { color: #CC9393; }
-.field              { color: #94BFF3; }
-.function           { color: #93E0E3; }
-.parameter          { color: #94BFF3; }
-.text               { color: #DCDCCC; }
-.type               { color: #7CB8BB; }
-.builtin_type       { color: #8CD0D3; }
-.type_param         { color: #DFAF8F; }
-.attribute          { color: #94BFF3; }
-.numeric_literal    { color: #BFEBBF; }
-.bool_literal       { color: #BFE6EB; }
-.macro              { color: #94BFF3; }
-.module             { color: #AFD8AF; }
-.variable           { color: #DCDCCC; }
-.format_specifier   { color: #CC696B; }
-.mutable            { text-decoration: underline; }
-
-.keyword            { color: #F0DFAF; font-weight: bold; }
-.keyword.unsafe     { color: #BC8383; font-weight: bold; }
-.control            { font-style: italic; }
-</style>
-<pre><code><span class="macro">macro_rules!</span> <span class="macro declaration">println</span> {
-    ($($arg:tt)*) =&gt; ({
-        $<span class="keyword">crate</span>::io::_print($<span class="keyword">crate</span>::format_args_nl!($($arg)*));
-    })
-}
-#[rustc_builtin_macro]
-<span class="macro">macro_rules!</span> <span class="macro declaration">format_args_nl</span> {
-    ($fmt:expr) =&gt; {{ <span class="comment">/* compiler built-in */</span> }};
-    ($fmt:expr, $($args:tt)*) =&gt; {{ <span class="comment">/* compiler built-in */</span> }};
-}
-
-<span class="keyword">fn</span> <span class="function declaration">main</span>() {
-    <span class="comment">// from https://doc.rust-lang.org/std/fmt/index.html</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello"</span>);                 <span class="comment">// =&gt; "Hello"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"world"</span>);   <span class="comment">// =&gt; "Hello, world!"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"The number is </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">1</span>);   <span class="comment">// =&gt; "The number is 1"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">?</span><span class="format_specifier">}</span><span class="string_literal">"</span>, (<span class="numeric_literal">3</span>, <span class="numeric_literal">4</span>));          <span class="comment">// =&gt; "(3, 4)"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">value</span><span class="format_specifier">}</span><span class="string_literal">"</span>, value=<span class="numeric_literal">4</span>);      <span class="comment">// =&gt; "4"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">1</span>, <span class="numeric_literal">2</span>);           <span class="comment">// =&gt; "1 2"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">4</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">42</span>);             <span class="comment">// =&gt; "0042" with leading zerosV</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">1</span>, <span class="numeric_literal">2</span>);   <span class="comment">// =&gt; "2 1 1 2"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">argument</span><span class="format_specifier">}</span><span class="string_literal">"</span>, argument = <span class="string_literal">"test"</span>);   <span class="comment">// =&gt; "test"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">1</span>, name = <span class="numeric_literal">2</span>);          <span class="comment">// =&gt; "2 1"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">a</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">c</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">b</span><span class="format_specifier">}</span><span class="string_literal">"</span>, a=<span class="string_literal">"a"</span>, b=<span class="char_literal">'b'</span>, c=<span class="numeric_literal">3</span>);  <span class="comment">// =&gt; "a 3 b"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>, <span class="numeric_literal">5</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">5</span>, <span class="string_literal">"x"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="variable">width</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>, width = <span class="numeric_literal">5</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">-</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">^</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">+</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">5</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="variable">x</span><span class="string_literal">}!"</span>, <span class="numeric_literal">27</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">5</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, -<span class="numeric_literal">5</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="numeric_literal">0</span><span class="numeric_literal">10</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">27</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="string_literal">"x"</span>, <span class="numeric_literal">0.01</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">5</span>, <span class="string_literal">"x"</span>, <span class="numeric_literal">0.01</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="string_literal">"x"</span>, <span class="numeric_literal">5</span>, <span class="numeric_literal">0.01</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span>,    <span class="string_literal">"x"</span>, <span class="numeric_literal">5</span>, <span class="numeric_literal">0.01</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span>,   <span class="string_literal">"x"</span>, <span class="numeric_literal">5</span>, <span class="numeric_literal">0.01</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="variable">number</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="variable">prec</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="string_literal">"x"</span>, prec = <span class="numeric_literal">5</span>, number = <span class="numeric_literal">0.01</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 fractional digits"</span>, <span class="string_literal">"Hello"</span>, <span class="numeric_literal">3</span>, name=<span class="numeric_literal">1234.56</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 characters"</span>, <span class="string_literal">"Hello"</span>, <span class="numeric_literal">3</span>, name=<span class="string_literal">"1234.56"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">8</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 right-aligned characters"</span>, <span class="string_literal">"Hello"</span>, <span class="numeric_literal">3</span>, name=<span class="string_literal">"1234.56"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"Hello {{}}"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"{{ Hello"</span>);
-
-    <span class="macro">println!</span>(<span class="string_literal">r"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"world"</span>);
-
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span>, A = <span class="numeric_literal">92</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">ничоси</span><span class="format_specifier">}</span><span class="string_literal">"</span>, ничоси = <span class="numeric_literal">92</span>);
-}</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
deleted file mode 100644
index 352e35095..000000000
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ /dev/null
@@ -1,101 +0,0 @@
-
-<style>
-body                { margin: 0; }
-pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
-
-.lifetime           { color: #DFAF8F; font-style: italic; }
-.comment            { color: #7F9F7F; }
-.struct, .enum      { color: #7CB8BB; }
-.enum_variant       { color: #BDE0F3; }
-.string_literal     { color: #CC9393; }
-.field              { color: #94BFF3; }
-.function           { color: #93E0E3; }
-.parameter          { color: #94BFF3; }
-.text               { color: #DCDCCC; }
-.type               { color: #7CB8BB; }
-.builtin_type       { color: #8CD0D3; }
-.type_param         { color: #DFAF8F; }
-.attribute          { color: #94BFF3; }
-.numeric_literal    { color: #BFEBBF; }
-.bool_literal       { color: #BFE6EB; }
-.macro              { color: #94BFF3; }
-.module             { color: #AFD8AF; }
-.variable           { color: #DCDCCC; }
-.format_specifier   { color: #CC696B; }
-.mutable            { text-decoration: underline; }
-
-.keyword            { color: #F0DFAF; font-weight: bold; }
-.keyword.unsafe     { color: #BC8383; font-weight: bold; }
-.control            { font-style: italic; }
-</style>
-<pre><code><span class="attribute">#[</span><span class="function attribute">derive</span><span class="attribute">(Clone, Debug)]</span>
-<span class="keyword">struct</span> <span class="struct declaration">Foo</span> {
-    <span class="keyword">pub</span> <span class="field declaration">x</span>: <span class="builtin_type">i32</span>,
-    <span class="keyword">pub</span> <span class="field declaration">y</span>: <span class="builtin_type">i32</span>,
-}
-
-<span class="keyword">trait</span> <span class="trait declaration">Bar</span> {
-    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="self_keyword">self</span>) -&gt; <span class="builtin_type">i32</span>;
-}
-
-<span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> {
-    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="self_keyword">self</span>) -&gt; <span class="builtin_type">i32</span> {
-        <span class="self_keyword">self</span>.<span class="field">x</span>
-    }
-}
-
-<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable">STATIC_MUT</span>: <span class="builtin_type">i32</span> = <span class="numeric_literal">0</span>;
-
-<span class="keyword">fn</span> <span class="function declaration">foo</span>&lt;<span class="lifetime declaration">'a</span>, <span class="type_param declaration">T</span>&gt;() -&gt; <span class="type_param">T</span> {
-    <span class="function">foo</span>::&lt;<span class="lifetime">'a</span>, <span class="builtin_type">i32</span>&gt;()
-}
-
-<span class="macro">macro_rules!</span> <span class="macro declaration">def_fn</span> {
-    ($($tt:tt)*) =&gt; {$($tt)*}
-}
-
-<span class="macro">def_fn!</span> {
-    <span class="keyword">fn</span> <span class="function declaration">bar</span>() -&gt; <span class="builtin_type">u32</span> {
-        <span class="numeric_literal">100</span>
-    }
-}
-
-<span class="comment">// comment</span>
-<span class="keyword">fn</span> <span class="function declaration">main</span>() {
-    <span class="macro">println!</span>(<span class="string_literal">"Hello, {}!"</span>, <span class="numeric_literal">92</span>);
-
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">vec</span> = <span class="unresolved_reference">Vec</span>::<span class="unresolved_reference">new</span>();
-    <span class="keyword control">if</span> <span class="bool_literal">true</span> {
-        <span class="keyword">let</span> <span class="variable declaration">x</span> = <span class="numeric_literal">92</span>;
-        <span class="variable mutable">vec</span>.<span class="unresolved_reference">push</span>(<span class="struct">Foo</span> { <span class="field">x</span>, <span class="field">y</span>: <span class="numeric_literal">1</span> });
-    }
-    <span class="keyword unsafe">unsafe</span> {
-        <span class="variable mutable">vec</span>.<span class="unresolved_reference">set_len</span>(<span class="numeric_literal">0</span>);
-        <span class="static mutable">STATIC_MUT</span> = <span class="numeric_literal">1</span>;
-    }
-
-    <span class="keyword control">for</span> <span class="variable declaration">e</span> <span class="keyword control">in</span> <span class="variable mutable">vec</span> {
-        <span class="comment">// Do nothing</span>
-    }
-
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> = <span class="numeric_literal">42</span>;
-    <span class="keyword">let</span> <span class="variable declaration mutable">y</span> = &<span class="keyword">mut</span> <span class="variable mutable">x</span>;
-    <span class="keyword">let</span> <span class="variable declaration">z</span> = &<span class="variable mutable">y</span>;
-
-    <span class="variable mutable">y</span>;
-}
-
-<span class="keyword">enum</span> <span class="enum declaration">Option</span>&lt;<span class="type_param declaration">T</span>&gt; {
-    <span class="enum_variant declaration">Some</span>(<span class="type_param">T</span>),
-    <span class="enum_variant declaration">None</span>,
-}
-<span class="keyword">use</span> <span class="enum">Option</span>::*;
-
-<span class="keyword">impl</span>&lt;<span class="type_param declaration">T</span>&gt; <span class="enum">Option</span>&lt;<span class="type_param">T</span>&gt; {
-    <span class="keyword">fn</span> <span class="function declaration">and</span>&lt;<span class="type_param declaration">U</span>&gt;(<span class="self_keyword">self</span>, <span class="variable declaration">other</span>: <span class="enum">Option</span>&lt;<span class="type_param">U</span>&gt;) -&gt; <span class="enum">Option</span>&lt;(<span class="type_param">T</span>, <span class="type_param">U</span>)&gt; {
-        <span class="keyword control">match</span> <span class="variable">other</span> {
-            <span class="enum_variant">None</span> =&gt; <span class="macro">unimplemented!</span>(),
-            <span class="variable declaration">Nope</span> =&gt; <span class="variable">Nope</span>,
-        }
-    }
-}</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
deleted file mode 100644
index 2a0294f71..000000000
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ /dev/null
@@ -1,42 +0,0 @@
-
-<style>
-body                { margin: 0; }
-pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
-
-.lifetime           { color: #DFAF8F; font-style: italic; }
-.comment            { color: #7F9F7F; }
-.struct, .enum      { color: #7CB8BB; }
-.enum_variant       { color: #BDE0F3; }
-.string_literal     { color: #CC9393; }
-.field              { color: #94BFF3; }
-.function           { color: #93E0E3; }
-.parameter          { color: #94BFF3; }
-.text               { color: #DCDCCC; }
-.type               { color: #7CB8BB; }
-.builtin_type       { color: #8CD0D3; }
-.type_param         { color: #DFAF8F; }
-.attribute          { color: #94BFF3; }
-.numeric_literal    { color: #BFEBBF; }
-.bool_literal       { color: #BFE6EB; }
-.macro              { color: #94BFF3; }
-.module             { color: #AFD8AF; }
-.variable           { color: #DCDCCC; }
-.format_specifier   { color: #CC696B; }
-.mutable            { text-decoration: underline; }
-
-.keyword            { color: #F0DFAF; font-weight: bold; }
-.keyword.unsafe     { color: #BC8383; font-weight: bold; }
-.control            { font-style: italic; }
-</style>
-<pre><code><span class="keyword">fn</span> <span class="function declaration">main</span>() {
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> = <span class="string_literal">"hello"</span>;
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="2705725358298919760" style="color: hsl(17,51%,74%);">x</span> = <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span>.<span class="unresolved_reference">to_string</span>();
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="3365759661443752373" style="color: hsl(127,76%,66%);">y</span> = <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span>.<span class="unresolved_reference">to_string</span>();
-
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span> = <span class="string_literal">"other color please!"</span>;
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="6717528807933952652" style="color: hsl(85,49%,84%);">y</span> = <span class="variable" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span>.<span class="unresolved_reference">to_string</span>();
-}
-
-<span class="keyword">fn</span> <span class="function declaration">bar</span>() {
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> = <span class="string_literal">"hello"</span>;
-}</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
index 93e9aee1d..b3e9e5dfe 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -1,37 +1,31 @@
-use std::{collections::HashMap, iter::once, str::FromStr};
-
-use ra_db::{SourceDatabase, SourceDatabaseExt};
+use ra_db::SourceDatabaseExt;
 use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
-use ra_syntax::ast::{
-    make::try_expr_from_text, ArgList, AstToken, CallExpr, Comment, Expr, MethodCallExpr,
-    RecordField, RecordLit,
-};
-use ra_syntax::{AstNode, SyntaxElement, SyntaxKind, SyntaxNode};
-use ra_text_edit::{TextEdit, TextEditBuilder};
-use rustc_hash::FxHashMap;
 
 use crate::SourceFileEdit;
+use ra_ssr::{MatchFinder, SsrError, SsrRule};
 
-#[derive(Debug, PartialEq)]
-pub struct SsrError(String);
-
-impl std::fmt::Display for SsrError {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "Parse error: {}", self.0)
-    }
-}
-
-impl std::error::Error for SsrError {}
-
-// Feature: Structural Seach and Replace
+// Feature: Structural Search and Replace
 //
-// Search and replace with named wildcards that will match any expression.
+// Search and replace with named wildcards that will match any expression, type, path, pattern or item.
 // The syntax for a structural search replace command is `<search_pattern> ==>> <replace_pattern>`.
-// A `$<name>:expr` placeholder in the search pattern will match any expression and `$<name>` will reference it in the replacement.
+// A `$<name>` placeholder in the search pattern will match any AST node and `$<name>` will reference it in the replacement.
+// Within a macro call, a placeholder will match up until whatever token follows the placeholder.
+//
+// Placeholders may be given constraints by writing them as `${<name>:<constraint1>:<constraint2>...}`.
+//
+// Supported constraints:
+//
+// |===
+// | Constraint    | Restricts placeholder
+//
+// | kind(literal) | Is a literal (e.g. `42` or `"forty two"`)
+// | not(a)        | Negates the constraint `a`
+// |===
+//
 // Available via the command `rust-analyzer.ssr`.
 //
 // ```rust
-// // Using structural search replace command [foo($a:expr, $b:expr) ==>> ($a).foo($b)]
+// // Using structural search replace command [foo($a, $b) ==>> ($a).foo($b)]
 //
 // // BEFORE
 // String::from(foo(y + 5, z))
@@ -46,584 +40,24 @@ impl std::error::Error for SsrError {}
 // | VS Code | **Rust Analyzer: Structural Search Replace**
 // |===
 pub fn parse_search_replace(
-    query: &str,
+    rule: &str,
     parse_only: bool,
     db: &RootDatabase,
 ) -> Result<Vec<SourceFileEdit>, SsrError> {
     let mut edits = vec![];
-    let query: SsrQuery = query.parse()?;
+    let rule: SsrRule = rule.parse()?;
     if parse_only {
         return Ok(edits);
     }
+    let mut match_finder = MatchFinder::new(db);
+    match_finder.add_rule(rule);
     for &root in db.local_roots().iter() {
         let sr = db.source_root(root);
-        for file_id in sr.walk() {
-            let matches = find(&query.pattern, db.parse(file_id).tree().syntax());
-            if !matches.matches.is_empty() {
-                edits.push(SourceFileEdit { file_id, edit: replace(&matches, &query.template) });
+        for file_id in sr.iter() {
+            if let Some(edit) = match_finder.edits_for_file(file_id) {
+                edits.push(SourceFileEdit { file_id, edit });
             }
         }
     }
     Ok(edits)
 }
-
-#[derive(Debug)]
-struct SsrQuery {
-    pattern: SsrPattern,
-    template: SsrTemplate,
-}
-
-#[derive(Debug)]
-struct SsrPattern {
-    pattern: SyntaxNode,
-    vars: Vec<Var>,
-}
-
-/// represents an `$var` in an SSR query
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-struct Var(String);
-
-#[derive(Debug)]
-struct SsrTemplate {
-    template: SyntaxNode,
-    placeholders: FxHashMap<SyntaxNode, Var>,
-}
-
-type Binding = HashMap<Var, SyntaxNode>;
-
-#[derive(Debug)]
-struct Match {
-    place: SyntaxNode,
-    binding: Binding,
-    ignored_comments: Vec<Comment>,
-}
-
-#[derive(Debug)]
-struct SsrMatches {
-    matches: Vec<Match>,
-}
-
-impl FromStr for SsrQuery {
-    type Err = SsrError;
-
-    fn from_str(query: &str) -> Result<SsrQuery, SsrError> {
-        let mut it = query.split("==>>");
-        let pattern = it.next().expect("at least empty string").trim();
-        let mut template = it
-            .next()
-            .ok_or_else(|| SsrError("Cannot find delemiter `==>>`".into()))?
-            .trim()
-            .to_string();
-        if it.next().is_some() {
-            return Err(SsrError("More than one delimiter found".into()));
-        }
-        let mut vars = vec![];
-        let mut it = pattern.split('$');
-        let mut pattern = it.next().expect("something").to_string();
-
-        for part in it.map(split_by_var) {
-            let (var, var_type, remainder) = part?;
-            is_expr(var_type)?;
-            let new_var = create_name(var, &mut vars)?;
-            pattern.push_str(new_var);
-            pattern.push_str(remainder);
-            template = replace_in_template(template, var, new_var);
-        }
-
-        let template = try_expr_from_text(&template)
-            .ok_or(SsrError("Template is not an expression".into()))?
-            .syntax()
-            .clone();
-        let mut placeholders = FxHashMap::default();
-
-        traverse(&template, &mut |n| {
-            if let Some(v) = vars.iter().find(|v| v.0.as_str() == n.text()) {
-                placeholders.insert(n.clone(), v.clone());
-                false
-            } else {
-                true
-            }
-        });
-
-        let pattern = SsrPattern {
-            pattern: try_expr_from_text(&pattern)
-                .ok_or(SsrError("Pattern is not an expression".into()))?
-                .syntax()
-                .clone(),
-            vars,
-        };
-        let template = SsrTemplate { template, placeholders };
-        Ok(SsrQuery { pattern, template })
-    }
-}
-
-fn traverse(node: &SyntaxNode, go: &mut impl FnMut(&SyntaxNode) -> bool) {
-    if !go(node) {
-        return;
-    }
-    for ref child in node.children() {
-        traverse(child, go);
-    }
-}
-
-fn split_by_var(s: &str) -> Result<(&str, &str, &str), SsrError> {
-    let end_of_name = s.find(':').ok_or_else(|| SsrError("Use $<name>:expr".into()))?;
-    let name = &s[0..end_of_name];
-    is_name(name)?;
-    let type_begin = end_of_name + 1;
-    let type_length =
-        s[type_begin..].find(|c| !char::is_ascii_alphanumeric(&c)).unwrap_or_else(|| s.len());
-    let type_name = &s[type_begin..type_begin + type_length];
-    Ok((name, type_name, &s[type_begin + type_length..]))
-}
-
-fn is_name(s: &str) -> Result<(), SsrError> {
-    if s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
-        Ok(())
-    } else {
-        Err(SsrError("Name can contain only alphanumerics and _".into()))
-    }
-}
-
-fn is_expr(s: &str) -> Result<(), SsrError> {
-    if s == "expr" {
-        Ok(())
-    } else {
-        Err(SsrError("Only $<name>:expr is supported".into()))
-    }
-}
-
-fn replace_in_template(template: String, var: &str, new_var: &str) -> String {
-    let name = format!("${}", var);
-    template.replace(&name, new_var)
-}
-
-fn create_name<'a>(name: &str, vars: &'a mut Vec<Var>) -> Result<&'a str, SsrError> {
-    let sanitized_name = format!("__search_pattern_{}", name);
-    if vars.iter().any(|a| a.0 == sanitized_name) {
-        return Err(SsrError(format!("Name `{}` repeats more than once", name)));
-    }
-    vars.push(Var(sanitized_name));
-    Ok(&vars.last().unwrap().0)
-}
-
-fn find(pattern: &SsrPattern, code: &SyntaxNode) -> SsrMatches {
-    fn check_record_lit(
-        pattern: RecordLit,
-        code: RecordLit,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match> {
-        let match_ = check_opt_nodes(pattern.path(), code.path(), placeholders, match_)?;
-
-        let mut pattern_fields: Vec<RecordField> =
-            pattern.record_field_list().map(|x| x.fields().collect()).unwrap_or_default();
-        let mut code_fields: Vec<RecordField> =
-            code.record_field_list().map(|x| x.fields().collect()).unwrap_or_default();
-
-        if pattern_fields.len() != code_fields.len() {
-            return None;
-        }
-
-        let by_name = |a: &RecordField, b: &RecordField| {
-            a.name_ref()
-                .map(|x| x.syntax().text().to_string())
-                .cmp(&b.name_ref().map(|x| x.syntax().text().to_string()))
-        };
-        pattern_fields.sort_by(by_name);
-        code_fields.sort_by(by_name);
-
-        pattern_fields.into_iter().zip(code_fields.into_iter()).fold(
-            Some(match_),
-            |accum, (a, b)| {
-                accum.and_then(|match_| check_opt_nodes(Some(a), Some(b), placeholders, match_))
-            },
-        )
-    }
-
-    fn check_call_and_method_call(
-        pattern: CallExpr,
-        code: MethodCallExpr,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match> {
-        let (pattern_name, pattern_type_args) = if let Some(Expr::PathExpr(path_exr)) =
-            pattern.expr()
-        {
-            let segment = path_exr.path().and_then(|p| p.segment());
-            (segment.as_ref().and_then(|s| s.name_ref()), segment.and_then(|s| s.type_arg_list()))
-        } else {
-            (None, None)
-        };
-        let match_ = check_opt_nodes(pattern_name, code.name_ref(), placeholders, match_)?;
-        let match_ =
-            check_opt_nodes(pattern_type_args, code.type_arg_list(), placeholders, match_)?;
-        let pattern_args = pattern.syntax().children().find_map(ArgList::cast)?.args();
-        let code_args = code.syntax().children().find_map(ArgList::cast)?.args();
-        let code_args = once(code.expr()?).chain(code_args);
-        check_iter(pattern_args, code_args, placeholders, match_)
-    }
-
-    fn check_method_call_and_call(
-        pattern: MethodCallExpr,
-        code: CallExpr,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match> {
-        let (code_name, code_type_args) = if let Some(Expr::PathExpr(path_exr)) = code.expr() {
-            let segment = path_exr.path().and_then(|p| p.segment());
-            (segment.as_ref().and_then(|s| s.name_ref()), segment.and_then(|s| s.type_arg_list()))
-        } else {
-            (None, None)
-        };
-        let match_ = check_opt_nodes(pattern.name_ref(), code_name, placeholders, match_)?;
-        let match_ =
-            check_opt_nodes(pattern.type_arg_list(), code_type_args, placeholders, match_)?;
-        let code_args = code.syntax().children().find_map(ArgList::cast)?.args();
-        let pattern_args = pattern.syntax().children().find_map(ArgList::cast)?.args();
-        let pattern_args = once(pattern.expr()?).chain(pattern_args);
-        check_iter(pattern_args, code_args, placeholders, match_)
-    }
-
-    fn check_opt_nodes(
-        pattern: Option<impl AstNode>,
-        code: Option<impl AstNode>,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match> {
-        match (pattern, code) {
-            (Some(pattern), Some(code)) => check(
-                &pattern.syntax().clone().into(),
-                &code.syntax().clone().into(),
-                placeholders,
-                match_,
-            ),
-            (None, None) => Some(match_),
-            _ => None,
-        }
-    }
-
-    fn check_iter<T, I1, I2>(
-        mut pattern: I1,
-        mut code: I2,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match>
-    where
-        T: AstNode,
-        I1: Iterator<Item = T>,
-        I2: Iterator<Item = T>,
-    {
-        pattern
-            .by_ref()
-            .zip(code.by_ref())
-            .fold(Some(match_), |accum, (a, b)| {
-                accum.and_then(|match_| {
-                    check(
-                        &a.syntax().clone().into(),
-                        &b.syntax().clone().into(),
-                        placeholders,
-                        match_,
-                    )
-                })
-            })
-            .filter(|_| pattern.next().is_none() && code.next().is_none())
-    }
-
-    fn check(
-        pattern: &SyntaxElement,
-        code: &SyntaxElement,
-        placeholders: &[Var],
-        mut match_: Match,
-    ) -> Option<Match> {
-        match (&pattern, &code) {
-            (SyntaxElement::Token(pattern), SyntaxElement::Token(code)) => {
-                if pattern.text() == code.text() {
-                    Some(match_)
-                } else {
-                    None
-                }
-            }
-            (SyntaxElement::Node(pattern), SyntaxElement::Node(code)) => {
-                if placeholders.iter().any(|n| n.0.as_str() == pattern.text()) {
-                    match_.binding.insert(Var(pattern.text().to_string()), code.clone());
-                    Some(match_)
-                } else {
-                    if let (Some(pattern), Some(code)) =
-                        (RecordLit::cast(pattern.clone()), RecordLit::cast(code.clone()))
-                    {
-                        check_record_lit(pattern, code, placeholders, match_)
-                    } else if let (Some(pattern), Some(code)) =
-                        (CallExpr::cast(pattern.clone()), MethodCallExpr::cast(code.clone()))
-                    {
-                        check_call_and_method_call(pattern, code, placeholders, match_)
-                    } else if let (Some(pattern), Some(code)) =
-                        (MethodCallExpr::cast(pattern.clone()), CallExpr::cast(code.clone()))
-                    {
-                        check_method_call_and_call(pattern, code, placeholders, match_)
-                    } else {
-                        let mut pattern_children = pattern
-                            .children_with_tokens()
-                            .filter(|element| !element.kind().is_trivia());
-                        let mut code_children = code
-                            .children_with_tokens()
-                            .filter(|element| !element.kind().is_trivia());
-                        let new_ignored_comments =
-                            code.children_with_tokens().filter_map(|element| {
-                                element.as_token().and_then(|token| Comment::cast(token.clone()))
-                            });
-                        match_.ignored_comments.extend(new_ignored_comments);
-                        pattern_children
-                            .by_ref()
-                            .zip(code_children.by_ref())
-                            .fold(Some(match_), |accum, (a, b)| {
-                                accum.and_then(|match_| check(&a, &b, placeholders, match_))
-                            })
-                            .filter(|_| {
-                                pattern_children.next().is_none() && code_children.next().is_none()
-                            })
-                    }
-                }
-            }
-            _ => None,
-        }
-    }
-    let kind = pattern.pattern.kind();
-    let matches = code
-        .descendants()
-        .filter(|n| {
-            n.kind() == kind
-                || (kind == SyntaxKind::CALL_EXPR && n.kind() == SyntaxKind::METHOD_CALL_EXPR)
-                || (kind == SyntaxKind::METHOD_CALL_EXPR && n.kind() == SyntaxKind::CALL_EXPR)
-        })
-        .filter_map(|code| {
-            let match_ =
-                Match { place: code.clone(), binding: HashMap::new(), ignored_comments: vec![] };
-            check(&pattern.pattern.clone().into(), &code.into(), &pattern.vars, match_)
-        })
-        .collect();
-    SsrMatches { matches }
-}
-
-fn replace(matches: &SsrMatches, template: &SsrTemplate) -> TextEdit {
-    let mut builder = TextEditBuilder::default();
-    for match_ in &matches.matches {
-        builder.replace(
-            match_.place.text_range(),
-            render_replace(&match_.binding, &match_.ignored_comments, template),
-        );
-    }
-    builder.finish()
-}
-
-fn render_replace(
-    binding: &Binding,
-    ignored_comments: &Vec<Comment>,
-    template: &SsrTemplate,
-) -> String {
-    let edit = {
-        let mut builder = TextEditBuilder::default();
-        for element in template.template.descendants() {
-            if let Some(var) = template.placeholders.get(&element) {
-                builder.replace(element.text_range(), binding[var].to_string())
-            }
-        }
-        for comment in ignored_comments {
-            builder.insert(template.template.text_range().end(), comment.syntax().to_string())
-        }
-        builder.finish()
-    };
-
-    let mut text = template.template.text().to_string();
-    edit.apply(&mut text);
-    text
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ra_syntax::SourceFile;
-
-    fn parse_error_text(query: &str) -> String {
-        format!("{}", query.parse::<SsrQuery>().unwrap_err())
-    }
-
-    #[test]
-    fn parser_happy_case() {
-        let result: SsrQuery = "foo($a:expr, $b:expr) ==>> bar($b, $a)".parse().unwrap();
-        assert_eq!(&result.pattern.pattern.text(), "foo(__search_pattern_a, __search_pattern_b)");
-        assert_eq!(result.pattern.vars.len(), 2);
-        assert_eq!(result.pattern.vars[0].0, "__search_pattern_a");
-        assert_eq!(result.pattern.vars[1].0, "__search_pattern_b");
-        assert_eq!(&result.template.template.text(), "bar(__search_pattern_b, __search_pattern_a)");
-    }
-
-    #[test]
-    fn parser_empty_query() {
-        assert_eq!(parse_error_text(""), "Parse error: Cannot find delemiter `==>>`");
-    }
-
-    #[test]
-    fn parser_no_delimiter() {
-        assert_eq!(parse_error_text("foo()"), "Parse error: Cannot find delemiter `==>>`");
-    }
-
-    #[test]
-    fn parser_two_delimiters() {
-        assert_eq!(
-            parse_error_text("foo() ==>> a ==>> b "),
-            "Parse error: More than one delimiter found"
-        );
-    }
-
-    #[test]
-    fn parser_no_pattern_type() {
-        assert_eq!(parse_error_text("foo($a) ==>>"), "Parse error: Use $<name>:expr");
-    }
-
-    #[test]
-    fn parser_invalid_name() {
-        assert_eq!(
-            parse_error_text("foo($a+:expr) ==>>"),
-            "Parse error: Name can contain only alphanumerics and _"
-        );
-    }
-
-    #[test]
-    fn parser_invalid_type() {
-        assert_eq!(
-            parse_error_text("foo($a:ident) ==>>"),
-            "Parse error: Only $<name>:expr is supported"
-        );
-    }
-
-    #[test]
-    fn parser_repeated_name() {
-        assert_eq!(
-            parse_error_text("foo($a:expr, $a:expr) ==>>"),
-            "Parse error: Name `a` repeats more than once"
-        );
-    }
-
-    #[test]
-    fn parser_invlid_pattern() {
-        assert_eq!(parse_error_text(" ==>> ()"), "Parse error: Pattern is not an expression");
-    }
-
-    #[test]
-    fn parser_invlid_template() {
-        assert_eq!(parse_error_text("() ==>> )"), "Parse error: Template is not an expression");
-    }
-
-    #[test]
-    fn parse_match_replace() {
-        let query: SsrQuery = "foo($x:expr) ==>> bar($x)".parse().unwrap();
-        let input = "fn main() { foo(1+2); }";
-
-        let code = SourceFile::parse(input).tree();
-        let matches = find(&query.pattern, code.syntax());
-        assert_eq!(matches.matches.len(), 1);
-        assert_eq!(matches.matches[0].place.text(), "foo(1+2)");
-        assert_eq!(matches.matches[0].binding.len(), 1);
-        assert_eq!(
-            matches.matches[0].binding[&Var("__search_pattern_x".to_string())].text(),
-            "1+2"
-        );
-
-        let edit = replace(&matches, &query.template);
-        let mut after = input.to_string();
-        edit.apply(&mut after);
-        assert_eq!(after, "fn main() { bar(1+2); }");
-    }
-
-    fn assert_ssr_transform(query: &str, input: &str, result: &str) {
-        let query: SsrQuery = query.parse().unwrap();
-        let code = SourceFile::parse(input).tree();
-        let matches = find(&query.pattern, code.syntax());
-        let edit = replace(&matches, &query.template);
-        let mut after = input.to_string();
-        edit.apply(&mut after);
-        assert_eq!(after, result);
-    }
-
-    #[test]
-    fn ssr_function_to_method() {
-        assert_ssr_transform(
-            "my_function($a:expr, $b:expr) ==>> ($a).my_method($b)",
-            "loop { my_function( other_func(x, y), z + w) }",
-            "loop { (other_func(x, y)).my_method(z + w) }",
-        )
-    }
-
-    #[test]
-    fn ssr_nested_function() {
-        assert_ssr_transform(
-            "foo($a:expr, $b:expr, $c:expr) ==>> bar($c, baz($a, $b))",
-            "fn main { foo  (x + value.method(b), x+y-z, true && false) }",
-            "fn main { bar(true && false, baz(x + value.method(b), x+y-z)) }",
-        )
-    }
-
-    #[test]
-    fn ssr_expected_spacing() {
-        assert_ssr_transform(
-            "foo($x:expr) + bar() ==>> bar($x)",
-            "fn main() { foo(5) + bar() }",
-            "fn main() { bar(5) }",
-        );
-    }
-
-    #[test]
-    fn ssr_with_extra_space() {
-        assert_ssr_transform(
-            "foo($x:expr  ) +    bar() ==>> bar($x)",
-            "fn main() { foo(  5 )  +bar(   ) }",
-            "fn main() { bar(5) }",
-        );
-    }
-
-    #[test]
-    fn ssr_keeps_nested_comment() {
-        assert_ssr_transform(
-            "foo($x:expr) ==>> bar($x)",
-            "fn main() { foo(other(5 /* using 5 */)) }",
-            "fn main() { bar(other(5 /* using 5 */)) }",
-        )
-    }
-
-    #[test]
-    fn ssr_keeps_comment() {
-        assert_ssr_transform(
-            "foo($x:expr) ==>> bar($x)",
-            "fn main() { foo(5 /* using 5 */) }",
-            "fn main() { bar(5)/* using 5 */ }",
-        )
-    }
-
-    #[test]
-    fn ssr_struct_lit() {
-        assert_ssr_transform(
-            "foo{a: $a:expr, b: $b:expr} ==>> foo::new($a, $b)",
-            "fn main() { foo{b:2, a:1} }",
-            "fn main() { foo::new(1, 2) }",
-        )
-    }
-
-    #[test]
-    fn ssr_call_and_method_call() {
-        assert_ssr_transform(
-            "foo::<'a>($a:expr, $b:expr)) ==>> foo2($a, $b)",
-            "fn main() { get().bar.foo::<'a>(1); }",
-            "fn main() { foo2(get().bar, 1); }",
-        )
-    }
-
-    #[test]
-    fn ssr_method_call_and_call() {
-        assert_ssr_transform(
-            "$o:expr.foo::<i32>($a:expr)) ==>> $o.foo2($a)",
-            "fn main() { X::foo::<i32>(x, 1); }",
-            "fn main() { x.foo2(1); }",
-        )
-    }
-}
diff --git a/crates/ra_ide/src/status.rs b/crates/ra_ide/src/status.rs
index 5b7992920..08e6f69cb 100644
--- a/crates/ra_ide/src/status.rs
+++ b/crates/ra_ide/src/status.rs
@@ -2,10 +2,7 @@ use std::{fmt, iter::FromIterator, sync::Arc};
 
 use hir::MacroFile;
 use ra_db::{
-    salsa::{
-        debug::{DebugQueryTable, TableEntry},
-        Database,
-    },
+    salsa::debug::{DebugQueryTable, TableEntry},
     FileTextQuery, SourceRootId,
 };
 use ra_ide_db::{
@@ -14,14 +11,15 @@ use ra_ide_db::{
 };
 use ra_prof::{memory_usage, Bytes};
 use ra_syntax::{ast, Parse, SyntaxNode};
+use rustc_hash::FxHashMap;
 
 use crate::FileId;
 
 fn syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
-    db.query(ra_db::ParseQuery).entries::<SyntaxTreeStats>()
+    ra_db::ParseQuery.in_db(db).entries::<SyntaxTreeStats>()
 }
 fn macro_syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
-    db.query(hir::db::ParseMacroQuery).entries::<SyntaxTreeStats>()
+    hir::db::ParseMacroQuery.in_db(db).entries::<SyntaxTreeStats>()
 }
 
 // Feature: Status
@@ -34,10 +32,10 @@ fn macro_syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
 // | VS Code | **Rust Analyzer: Status**
 // |===
 pub(crate) fn status(db: &RootDatabase) -> String {
-    let files_stats = db.query(FileTextQuery).entries::<FilesStats>();
+    let files_stats = FileTextQuery.in_db(db).entries::<FilesStats>();
     let syntax_tree_stats = syntax_tree_stats(db);
     let macro_syntax_tree_stats = macro_syntax_tree_stats(db);
-    let symbols_stats = db.query(LibrarySymbolsQuery).entries::<LibrarySymbolsStats>();
+    let symbols_stats = LibrarySymbolsQuery.in_db(db).entries::<LibrarySymbolsStats>();
     format!(
         "{}\n{}\n{}\n{} (macros)\n\n\nmemory:\n{}\ngc {:?} seconds ago",
         files_stats,
@@ -123,20 +121,24 @@ struct LibrarySymbolsStats {
 
 impl fmt::Display for LibrarySymbolsStats {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "{} ({}) symbols", self.total, self.size,)
+        write!(fmt, "{} ({}) symbols", self.total, self.size)
     }
 }
 
-impl FromIterator<TableEntry<SourceRootId, Arc<SymbolIndex>>> for LibrarySymbolsStats {
+impl FromIterator<TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>
+    for LibrarySymbolsStats
+{
     fn from_iter<T>(iter: T) -> LibrarySymbolsStats
     where
-        T: IntoIterator<Item = TableEntry<SourceRootId, Arc<SymbolIndex>>>,
+        T: IntoIterator<Item = TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>,
     {
         let mut res = LibrarySymbolsStats::default();
         for entry in iter {
             let value = entry.value.unwrap();
-            res.total += value.len();
-            res.size += value.memory_size();
+            for symbols in value.values() {
+                res.total += symbols.len();
+                res.size += symbols.memory_size();
+            }
         }
         res
     }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 0b53ebe69..6ac44c2c0 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -1,5 +1,6 @@
 mod tags;
 mod html;
+mod injection;
 #[cfg(test)]
 mod tests;
 
@@ -10,14 +11,14 @@ use ra_ide_db::{
 };
 use ra_prof::profile;
 use ra_syntax::{
-    ast::{self, HasFormatSpecifier, HasQuotes, HasStringValue},
+    ast::{self, HasFormatSpecifier},
     AstNode, AstToken, Direction, NodeOrToken, SyntaxElement,
     SyntaxKind::*,
-    SyntaxToken, TextRange, WalkEvent, T,
+    TextRange, WalkEvent, T,
 };
 use rustc_hash::FxHashMap;
 
-use crate::{call_info::ActiveParameter, Analysis, FileId};
+use crate::FileId;
 
 use ast::FormatSpecifier;
 pub(crate) use html::highlight_as_html;
@@ -43,6 +44,7 @@ pub(crate) fn highlight(
     db: &RootDatabase,
     file_id: FileId,
     range_to_highlight: Option<TextRange>,
+    syntactic_name_ref_highlighting: bool,
 ) -> Vec<HighlightedRange> {
     let _p = profile("highlight");
     let sema = Semantics::new(db);
@@ -103,6 +105,7 @@ pub(crate) fn highlight(
                     if let Some((highlight, binding_hash)) = highlight_element(
                         &sema,
                         &mut bindings_shadow_count,
+                        syntactic_name_ref_highlighting,
                         name.syntax().clone().into(),
                     ) {
                         stack.add(HighlightedRange {
@@ -118,7 +121,23 @@ pub(crate) fn highlight(
                 assert!(current_macro_call == Some(mc));
                 current_macro_call = None;
                 format_string = None;
-                continue;
+            }
+            _ => (),
+        }
+
+        // Check for Rust code in documentation
+        match &event {
+            WalkEvent::Leave(NodeOrToken::Node(node)) => {
+                if let Some((doctest, range_mapping, new_comments)) =
+                    injection::extract_doc_comments(node)
+                {
+                    injection::highlight_doc_comment(
+                        doctest,
+                        range_mapping,
+                        new_comments,
+                        &mut stack,
+                    );
+                }
             }
             _ => (),
         }
@@ -130,7 +149,7 @@ pub(crate) fn highlight(
 
         let range = element.text_range();
 
-        let element_to_highlight = if current_macro_call.is_some() {
+        let element_to_highlight = if current_macro_call.is_some() && element.kind() != COMMENT {
             // Inside a macro -- expand it first
             let token = match element.clone().into_token() {
                 Some(it) if it.parent().kind() == TOKEN_TREE => it,
@@ -142,23 +161,25 @@ pub(crate) fn highlight(
             // Check if macro takes a format string and remember it for highlighting later.
             // The macros that accept a format string expand to a compiler builtin macros
             // `format_args` and `format_args_nl`.
-            if let Some(fmt_macro_call) = parent.parent().and_then(ast::MacroCall::cast) {
-                if let Some(name) =
-                    fmt_macro_call.path().and_then(|p| p.segment()).and_then(|s| s.name_ref())
-                {
-                    match name.text().as_str() {
-                        "format_args" | "format_args_nl" => {
-                            format_string = parent
-                                .children_with_tokens()
-                                .filter(|t| t.kind() != WHITESPACE)
-                                .nth(1)
-                                .filter(|e| {
-                                    ast::String::can_cast(e.kind())
-                                        || ast::RawString::can_cast(e.kind())
-                                })
-                        }
-                        _ => {}
+            if let Some(name) = parent
+                .parent()
+                .and_then(ast::MacroCall::cast)
+                .and_then(|mc| mc.path())
+                .and_then(|p| p.segment())
+                .and_then(|s| s.name_ref())
+            {
+                match name.text().as_str() {
+                    "format_args" | "format_args_nl" => {
+                        format_string = parent
+                            .children_with_tokens()
+                            .filter(|t| t.kind() != WHITESPACE)
+                            .nth(1)
+                            .filter(|e| {
+                                ast::String::can_cast(e.kind())
+                                    || ast::RawString::can_cast(e.kind())
+                            })
                     }
+                    _ => {}
                 }
             }
 
@@ -173,22 +194,25 @@ pub(crate) fn highlight(
 
         if let Some(token) = element.as_token().cloned().and_then(ast::RawString::cast) {
             let expanded = element_to_highlight.as_token().unwrap().clone();
-            if highlight_injection(&mut stack, &sema, token, expanded).is_some() {
+            if injection::highlight_injection(&mut stack, &sema, token, expanded).is_some() {
                 continue;
             }
         }
 
         let is_format_string = format_string.as_ref() == Some(&element_to_highlight);
 
-        if let Some((highlight, binding_hash)) =
-            highlight_element(&sema, &mut bindings_shadow_count, element_to_highlight.clone())
-        {
+        if let Some((highlight, binding_hash)) = highlight_element(
+            &sema,
+            &mut bindings_shadow_count,
+            syntactic_name_ref_highlighting,
+            element_to_highlight.clone(),
+        ) {
             stack.add(HighlightedRange { range, highlight, binding_hash });
             if let Some(string) =
                 element_to_highlight.as_token().cloned().and_then(ast::String::cast)
             {
-                stack.push();
                 if is_format_string {
+                    stack.push();
                     string.lex_format_specifier(|piece_range, kind| {
                         if let Some(highlight) = highlight_format_specifier(kind) {
                             stack.add(HighlightedRange {
@@ -198,13 +222,27 @@ pub(crate) fn highlight(
                             });
                         }
                     });
+                    stack.pop();
+                }
+                // Highlight escape sequences
+                if let Some(char_ranges) = string.char_ranges() {
+                    stack.push();
+                    for (piece_range, _) in char_ranges.iter().filter(|(_, char)| char.is_ok()) {
+                        if string.text()[piece_range.start().into()..].starts_with('\\') {
+                            stack.add(HighlightedRange {
+                                range: piece_range + range.start(),
+                                highlight: HighlightTag::EscapeSequence.into(),
+                                binding_hash: None,
+                            });
+                        }
+                    }
+                    stack.pop_and_inject(None);
                 }
-                stack.pop();
             } else if let Some(string) =
                 element_to_highlight.as_token().cloned().and_then(ast::RawString::cast)
             {
-                stack.push();
                 if is_format_string {
+                    stack.push();
                     string.lex_format_specifier(|piece_range, kind| {
                         if let Some(highlight) = highlight_format_specifier(kind) {
                             stack.add(HighlightedRange {
@@ -214,8 +252,8 @@ pub(crate) fn highlight(
                             });
                         }
                     });
+                    stack.pop();
                 }
-                stack.pop();
             }
         }
     }
@@ -259,9 +297,8 @@ impl HighlightedRangeStack {
             let mut parent = prev.pop().unwrap();
             for ele in children {
                 assert!(parent.range.contains_range(ele.range));
-                let mut cloned = parent.clone();
-                parent.range = TextRange::new(parent.range.start(), ele.range.start());
-                cloned.range = TextRange::new(ele.range.end(), cloned.range.end());
+
+                let cloned = Self::intersect(&mut parent, &ele);
                 if !parent.range.is_empty() {
                     prev.push(parent);
                 }
@@ -274,6 +311,92 @@ impl HighlightedRangeStack {
         }
     }
 
+    /// Intersects the `HighlightedRange` `parent` with `child`.
+    /// `parent` is mutated in place, becoming the range before `child`.
+    /// Returns the range (of the same type as `parent`) *after* `child`.
+    fn intersect(parent: &mut HighlightedRange, child: &HighlightedRange) -> HighlightedRange {
+        assert!(parent.range.contains_range(child.range));
+
+        let mut cloned = parent.clone();
+        parent.range = TextRange::new(parent.range.start(), child.range.start());
+        cloned.range = TextRange::new(child.range.end(), cloned.range.end());
+
+        cloned
+    }
+
+    /// Remove the `HighlightRange` of `parent` that's currently covered by `child`.
+    fn intersect_partial(parent: &mut HighlightedRange, child: &HighlightedRange) {
+        assert!(
+            parent.range.start() <= child.range.start()
+                && parent.range.end() >= child.range.start()
+                && child.range.end() > parent.range.end()
+        );
+
+        parent.range = TextRange::new(parent.range.start(), child.range.start());
+    }
+
+    /// Similar to `pop`, but can modify arbitrary prior ranges (where `pop`)
+    /// can only modify the last range currently on the stack.
+    /// Can be used to do injections that span multiple ranges, like the
+    /// doctest injection below.
+    /// If `overwrite_parent` is non-optional, the highlighting of the parent range
+    /// is overwritten with the argument.
+    ///
+    /// Note that `pop` can be simulated by `pop_and_inject(false)` but the
+    /// latter is computationally more expensive.
+    fn pop_and_inject(&mut self, overwrite_parent: Option<Highlight>) {
+        let mut children = self.stack.pop().unwrap();
+        let prev = self.stack.last_mut().unwrap();
+        children.sort_by_key(|range| range.range.start());
+        prev.sort_by_key(|range| range.range.start());
+
+        for child in children {
+            if let Some(idx) =
+                prev.iter().position(|parent| parent.range.contains_range(child.range))
+            {
+                if let Some(tag) = overwrite_parent {
+                    prev[idx].highlight = tag;
+                }
+
+                let cloned = Self::intersect(&mut prev[idx], &child);
+                let insert_idx = if prev[idx].range.is_empty() {
+                    prev.remove(idx);
+                    idx
+                } else {
+                    idx + 1
+                };
+                prev.insert(insert_idx, child);
+                if !cloned.range.is_empty() {
+                    prev.insert(insert_idx + 1, cloned);
+                }
+            } else {
+                let maybe_idx =
+                    prev.iter().position(|parent| parent.range.contains(child.range.start()));
+                match (overwrite_parent, maybe_idx) {
+                    (Some(_), Some(idx)) => {
+                        Self::intersect_partial(&mut prev[idx], &child);
+                        let insert_idx = if prev[idx].range.is_empty() {
+                            prev.remove(idx);
+                            idx
+                        } else {
+                            idx + 1
+                        };
+                        prev.insert(insert_idx, child);
+                    }
+                    (_, None) => {
+                        let idx = prev
+                            .binary_search_by_key(&child.range.start(), |range| range.range.start())
+                            .unwrap_or_else(|x| x);
+                        prev.insert(idx, child);
+                    }
+                    _ => {
+                        unreachable!("child range should be completely contained in parent range");
+                    }
+                }
+            }
+        }
+    }
+
     fn add(&mut self, range: HighlightedRange) {
         self.stack
             .last_mut()
@@ -335,6 +458,7 @@ fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
 fn highlight_element(
     sema: &Semantics<RootDatabase>,
     bindings_shadow_count: &mut FxHashMap<Name, u32>,
+    syntactic_name_ref_highlighting: bool,
     element: SyntaxElement,
 ) -> Option<(Highlight, Option<u64>)> {
     let db = sema.db;
@@ -363,6 +487,7 @@ fn highlight_element(
                     highlight_name(db, def) | HighlightModifier::Definition
                 }
                 Some(NameClass::ConstReference(def)) => highlight_name(db, def),
+                Some(NameClass::FieldShorthand { .. }) => HighlightTag::Field.into(),
                 None => highlight_name_by_syntax(name) | HighlightModifier::Definition,
             }
         }
@@ -387,12 +512,20 @@ fn highlight_element(
                     }
                     NameRefClass::FieldShorthand { .. } => HighlightTag::Field.into(),
                 },
+                None if syntactic_name_ref_highlighting => highlight_name_ref_by_syntax(name_ref),
                 None => HighlightTag::UnresolvedReference.into(),
             }
         }
 
         // Simple token-based highlighting
-        COMMENT => HighlightTag::Comment.into(),
+        COMMENT => {
+            let comment = element.into_token().and_then(ast::Comment::cast)?;
+            let h = HighlightTag::Comment;
+            match comment.kind().doc {
+                Some(_) => h | HighlightModifier::Documentation,
+                None => h.into(),
+            }
+        }
         STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => HighlightTag::StringLiteral.into(),
         ATTR => HighlightTag::Attribute.into(),
         INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(),
@@ -406,6 +539,21 @@ fn highlight_element(
                 _ => h,
             }
         }
+        T![*] => {
+            let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
+
+            let expr = prefix_expr.expr()?;
+            let ty = sema.type_of_expr(&expr)?;
+            if !ty.is_raw_ptr() {
+                return None;
+            } else {
+                HighlightTag::Operator | HighlightModifier::Unsafe
+            }
+        }
+        T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
+            Highlight::new(HighlightTag::Macro)
+        }
+        p if p.is_punct() => HighlightTag::Punctuation.into(),
 
         k if k.is_keyword() => {
             let h = Highlight::new(HighlightTag::Keyword);
@@ -419,10 +567,31 @@ fn highlight_element(
                 | T![return]
                 | T![while]
                 | T![in] => h | HighlightModifier::ControlFlow,
-                T![for] if !is_child_of_impl(element) => h | HighlightModifier::ControlFlow,
+                T![for] if !is_child_of_impl(&element) => h | HighlightModifier::ControlFlow,
                 T![unsafe] => h | HighlightModifier::Unsafe,
                 T![true] | T![false] => HighlightTag::BoolLiteral.into(),
-                T![self] => HighlightTag::SelfKeyword.into(),
+                T![self] => {
+                    let self_param_is_mut = element
+                        .parent()
+                        .and_then(ast::SelfParam::cast)
+                        .and_then(|p| p.mut_token())
+                        .is_some();
+                    // closure to enforce lazyness
+                    let self_path = || {
+                        sema.resolve_path(&element.parent()?.parent().and_then(ast::Path::cast)?)
+                    };
+                    if self_param_is_mut
+                        || matches!(self_path(),
+                            Some(hir::PathResolution::Local(local))
+                                if local.is_self(db)
+                                    && (local.is_mut(db) || local.ty(db).is_mutable_reference())
+                        )
+                    {
+                        HighlightTag::SelfKeyword | HighlightModifier::Mutable
+                    } else {
+                        HighlightTag::SelfKeyword.into()
+                    }
+                }
                 _ => h,
             }
         }
@@ -445,7 +614,7 @@ fn highlight_element(
     }
 }
 
-fn is_child_of_impl(element: SyntaxElement) -> bool {
+fn is_child_of_impl(element: &SyntaxElement) -> bool {
     match element.parent() {
         Some(e) => e.kind() == IMPL_DEF,
         _ => false,
@@ -458,7 +627,13 @@ fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight {
         Definition::Field(_) => HighlightTag::Field,
         Definition::ModuleDef(def) => match def {
             hir::ModuleDef::Module(_) => HighlightTag::Module,
-            hir::ModuleDef::Function(_) => HighlightTag::Function,
+            hir::ModuleDef::Function(func) => {
+                let mut h = HighlightTag::Function.into();
+                if func.is_unsafe(db) {
+                    h |= HighlightModifier::Unsafe;
+                }
+                return h;
+            }
             hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HighlightTag::Struct,
             hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HighlightTag::Enum,
             hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Union,
@@ -477,9 +652,10 @@ fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight {
         },
         Definition::SelfType(_) => HighlightTag::SelfType,
         Definition::TypeParam(_) => HighlightTag::TypeParam,
-        // FIXME: distinguish between locals and parameters
         Definition::Local(local) => {
-            let mut h = Highlight::new(HighlightTag::Local);
+            let tag =
+                if local.is_param(db) { HighlightTag::ValueParam } else { HighlightTag::Local };
+            let mut h = Highlight::new(tag);
             if local.is_mut(db) || local.ty(db).is_mutable_reference() {
                 h |= HighlightModifier::Mutable;
             }
@@ -517,41 +693,52 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
     tag.into()
 }
 
-fn highlight_injection(
-    acc: &mut HighlightedRangeStack,
-    sema: &Semantics<RootDatabase>,
-    literal: ast::RawString,
-    expanded: SyntaxToken,
-) -> Option<()> {
-    let active_parameter = ActiveParameter::at_token(&sema, expanded)?;
-    if !active_parameter.name.starts_with("ra_fixture") {
-        return None;
-    }
-    let value = literal.value()?;
-    let (analysis, tmp_file_id) = Analysis::from_single_file(value);
-
-    if let Some(range) = literal.open_quote_text_range() {
-        acc.add(HighlightedRange {
-            range,
-            highlight: HighlightTag::StringLiteral.into(),
-            binding_hash: None,
-        })
-    }
+fn highlight_name_ref_by_syntax(name: ast::NameRef) -> Highlight {
+    let default = HighlightTag::UnresolvedReference;
 
-    for mut h in analysis.highlight(tmp_file_id).unwrap() {
-        if let Some(r) = literal.map_range_up(h.range) {
-            h.range = r;
-            acc.add(h)
-        }
-    }
+    let parent = match name.syntax().parent() {
+        Some(it) => it,
+        _ => return default.into(),
+    };
 
-    if let Some(range) = literal.close_quote_text_range() {
-        acc.add(HighlightedRange {
-            range,
-            highlight: HighlightTag::StringLiteral.into(),
-            binding_hash: None,
-        })
-    }
+    let tag = match parent.kind() {
+        METHOD_CALL_EXPR => HighlightTag::Function,
+        FIELD_EXPR => HighlightTag::Field,
+        PATH_SEGMENT => {
+            let path = match parent.parent().and_then(ast::Path::cast) {
+                Some(it) => it,
+                _ => return default.into(),
+            };
+            let expr = match path.syntax().parent().and_then(ast::PathExpr::cast) {
+                Some(it) => it,
+                _ => {
+                    // within path, decide whether it is module or adt by checking for uppercase name
+                    return if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                        HighlightTag::Struct
+                    } else {
+                        HighlightTag::Module
+                    }
+                    .into();
+                }
+            };
+            let parent = match expr.syntax().parent() {
+                Some(it) => it,
+                None => return default.into(),
+            };
 
-    Some(())
+            match parent.kind() {
+                CALL_EXPR => HighlightTag::Function,
+                _ => {
+                    if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                        HighlightTag::Struct
+                    } else {
+                        HighlightTag::Constant
+                    }
+                }
+            }
+        }
+        _ => default,
+    };
+
+    tag.into()
 }
diff --git a/crates/ra_ide/src/syntax_highlighting/html.rs b/crates/ra_ide/src/syntax_highlighting/html.rs
index edfe61f39..0be55bca9 100644
--- a/crates/ra_ide/src/syntax_highlighting/html.rs
+++ b/crates/ra_ide/src/syntax_highlighting/html.rs
@@ -19,7 +19,7 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
         )
     }
 
-    let ranges = highlight(db, file_id, None);
+    let ranges = highlight(db, file_id, None, false);
     let text = parse.tree().syntax().to_string();
     let mut prev_pos = TextSize::from(0);
     let mut buf = String::new();
@@ -64,11 +64,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 .lifetime           { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
+.documentation      { color: #629755; }
+.injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
 .string_literal     { color: #CC9393; }
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
+.function.unsafe    { color: #BC8383; }
+.operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
 .type               { color: #7CB8BB; }
@@ -79,12 +83,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .bool_literal       { color: #BFE6EB; }
 .macro              { color: #94BFF3; }
 .module             { color: #AFD8AF; }
+.value_param        { color: #DCDCCC; }
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
-
+.escape_sequence    { color: #94BFF3; }
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
 .control            { font-style: italic; }
+
+.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
 ";
diff --git a/crates/ra_ide/src/syntax_highlighting/injection.rs b/crates/ra_ide/src/syntax_highlighting/injection.rs
new file mode 100644
index 000000000..8665b480f
--- /dev/null
+++ b/crates/ra_ide/src/syntax_highlighting/injection.rs
@@ -0,0 +1,188 @@
+//! Syntax highlighting injections such as highlighting of documentation tests.
+
+use std::{collections::BTreeMap, convert::TryFrom};
+
+use ast::{HasQuotes, HasStringValue};
+use hir::Semantics;
+use ra_syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
+use stdx::SepBy;
+
+use crate::{
+    call_info::ActiveParameter, Analysis, Highlight, HighlightModifier, HighlightTag,
+    HighlightedRange, RootDatabase,
+};
+
+use super::HighlightedRangeStack;
+
+pub(super) fn highlight_injection(
+    acc: &mut HighlightedRangeStack,
+    sema: &Semantics<RootDatabase>,
+    literal: ast::RawString,
+    expanded: SyntaxToken,
+) -> Option<()> {
+    let active_parameter = ActiveParameter::at_token(&sema, expanded)?;
+    if !active_parameter.name.starts_with("ra_fixture") {
+        return None;
+    }
+    let value = literal.value()?;
+    let (analysis, tmp_file_id) = Analysis::from_single_file(value.into_owned());
+
+    if let Some(range) = literal.open_quote_text_range() {
+        acc.add(HighlightedRange {
+            range,
+            highlight: HighlightTag::StringLiteral.into(),
+            binding_hash: None,
+        })
+    }
+
+    for mut h in analysis.highlight(tmp_file_id).unwrap() {
+        if let Some(r) = literal.map_range_up(h.range) {
+            h.range = r;
+            acc.add(h)
+        }
+    }
+
+    if let Some(range) = literal.close_quote_text_range() {
+        acc.add(HighlightedRange {
+            range,
+            highlight: HighlightTag::StringLiteral.into(),
+            binding_hash: None,
+        })
+    }
+
+    Some(())
+}
+
+/// Mapping from extracted documentation code to original code
+type RangesMap = BTreeMap<TextSize, TextSize>;
+
+const RUSTDOC_FENCE: &'static str = "```";
+const RUSTDOC_FENCE_TOKENS: &[&'static str] =
+    &["", "rust", "should_panic", "ignore", "no_run", "compile_fail", "edition2015", "edition2018"];
+
+/// Extracts Rust code from documentation comments as well as a mapping from
+/// the extracted source code back to the original source ranges.
+/// Lastly, a vector of new comment highlight ranges (spanning only the
+/// comment prefix) is returned which is used in the syntax highlighting
+/// injection to replace the previous (line-spanning) comment ranges.
+pub(super) fn extract_doc_comments(
+    node: &SyntaxNode,
+) -> Option<(String, RangesMap, Vec<HighlightedRange>)> {
+    // wrap the doctest into function body to get correct syntax highlighting
+    let prefix = "fn doctest() {\n";
+    let suffix = "}\n";
+    // Mapping from extracted documentation code to original code
+    let mut range_mapping: RangesMap = BTreeMap::new();
+    let mut line_start = TextSize::try_from(prefix.len()).unwrap();
+    let mut is_codeblock = false;
+    let mut is_doctest = false;
+    // Replace the original, line-spanning comment ranges by new, only comment-prefix
+    // spanning comment ranges.
+    let mut new_comments = Vec::new();
+    let doctest = node
+        .children_with_tokens()
+        .filter_map(|el| el.into_token().and_then(ast::Comment::cast))
+        .filter(|comment| comment.kind().doc.is_some())
+        .filter(|comment| {
+            if let Some(idx) = comment.text().find(RUSTDOC_FENCE) {
+                is_codeblock = !is_codeblock;
+                // Check whether code is rust by inspecting fence guards
+                let guards = &comment.text()[idx + RUSTDOC_FENCE.len()..];
+                let is_rust =
+                    guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
+                is_doctest = is_codeblock && is_rust;
+                false
+            } else {
+                is_doctest
+            }
+        })
+        .map(|comment| {
+            let prefix_len = comment.prefix().len();
+            let line: &str = comment.text().as_str();
+            let range = comment.syntax().text_range();
+
+            // whitespace after comment is ignored
+            let pos = if let Some(ws) = line.chars().nth(prefix_len).filter(|c| c.is_whitespace()) {
+                prefix_len + ws.len_utf8()
+            } else {
+                prefix_len
+            };
+
+            // lines marked with `#` should be ignored in output, we skip the `#` char
+            let pos = if let Some(ws) = line.chars().nth(pos).filter(|&c| c == '#') {
+                pos + ws.len_utf8()
+            } else {
+                pos
+            };
+
+            range_mapping.insert(line_start, range.start() + TextSize::try_from(pos).unwrap());
+            new_comments.push(HighlightedRange {
+                range: TextRange::new(
+                    range.start(),
+                    range.start() + TextSize::try_from(pos).unwrap(),
+                ),
+                highlight: HighlightTag::Comment | HighlightModifier::Documentation,
+                binding_hash: None,
+            });
+            line_start += range.len() - TextSize::try_from(pos).unwrap();
+            line_start += TextSize::try_from('\n'.len_utf8()).unwrap();
+
+            line[pos..].to_owned()
+        })
+        .sep_by("\n")
+        .to_string();
+
+    if doctest.is_empty() {
+        return None;
+    }
+
+    let doctest = format!("{}{}{}", prefix, doctest, suffix);
+    Some((doctest, range_mapping, new_comments))
+}
+
+/// Injection of syntax highlighting of doctests.
+pub(super) fn highlight_doc_comment(
+    text: String,
+    range_mapping: RangesMap,
+    new_comments: Vec<HighlightedRange>,
+    stack: &mut HighlightedRangeStack,
+) {
+    let (analysis, tmp_file_id) = Analysis::from_single_file(text);
+
+    stack.push();
+    for mut h in analysis.with_db(|db| super::highlight(db, tmp_file_id, None, true)).unwrap() {
+        // Determine start offset and end offset in case of multi-line ranges
+        let mut start_offset = None;
+        let mut end_offset = None;
+        for (line_start, orig_line_start) in range_mapping.range(..h.range.end()).rev() {
+            // It's possible for orig_line_start - line_start to be negative. Add h.range.start()
+            // here and remove it from the end range after the loop below so that the values are
+            // always non-negative.
+            let offset = h.range.start() + orig_line_start - line_start;
+            if line_start <= &h.range.start() {
+                start_offset.get_or_insert(offset);
+                break;
+            } else {
+                end_offset.get_or_insert(offset);
+            }
+        }
+        if let Some(start_offset) = start_offset {
+            h.range = TextRange::new(
+                start_offset,
+                h.range.end() + end_offset.unwrap_or(start_offset) - h.range.start(),
+            );
+
+            h.highlight |= HighlightModifier::Injected;
+            stack.add(h);
+        }
+    }
+
+    // Inject the comment prefix highlight ranges
+    stack.push();
+    for comment in new_comments {
+        stack.add(comment);
+    }
+    stack.pop_and_inject(None);
+    stack
+        .pop_and_inject(Some(Highlight::from(HighlightTag::Generic) | HighlightModifier::Injected));
+}
diff --git a/crates/ra_ide/src/syntax_highlighting/tags.rs b/crates/ra_ide/src/syntax_highlighting/tags.rs
index 1514531de..49ec94bdc 100644
--- a/crates/ra_ide/src/syntax_highlighting/tags.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tags.rs
@@ -23,13 +23,16 @@ pub enum HighlightTag {
     Constant,
     Enum,
     EnumVariant,
+    EscapeSequence,
     Field,
     Function,
+    Generic,
     Keyword,
     Lifetime,
     Macro,
     Module,
     NumericLiteral,
+    Punctuation,
     SelfKeyword,
     SelfType,
     Static,
@@ -39,6 +42,7 @@ pub enum HighlightTag {
     TypeAlias,
     TypeParam,
     Union,
+    ValueParam,
     Local,
     UnresolvedReference,
     FormatSpecifier,
@@ -55,6 +59,8 @@ pub enum HighlightModifier {
     /// `foo` in `fn foo(x: i32)` is a definition, `foo` in `foo(90 + 2)` is
     /// not.
     Definition,
+    Documentation,
+    Injected,
     Mutable,
     Unsafe,
 }
@@ -71,13 +77,18 @@ impl HighlightTag {
             HighlightTag::Constant => "constant",
             HighlightTag::Enum => "enum",
             HighlightTag::EnumVariant => "enum_variant",
+            HighlightTag::EscapeSequence => "escape_sequence",
             HighlightTag::Field => "field",
+            HighlightTag::FormatSpecifier => "format_specifier",
             HighlightTag::Function => "function",
+            HighlightTag::Generic => "generic",
             HighlightTag::Keyword => "keyword",
             HighlightTag::Lifetime => "lifetime",
+            HighlightTag::Punctuation => "punctuation",
             HighlightTag::Macro => "macro",
             HighlightTag::Module => "module",
             HighlightTag::NumericLiteral => "numeric_literal",
+            HighlightTag::Operator => "operator",
             HighlightTag::SelfKeyword => "self_keyword",
             HighlightTag::SelfType => "self_type",
             HighlightTag::Static => "static",
@@ -87,10 +98,9 @@ impl HighlightTag {
             HighlightTag::TypeAlias => "type_alias",
             HighlightTag::TypeParam => "type_param",
             HighlightTag::Union => "union",
+            HighlightTag::ValueParam => "value_param",
             HighlightTag::Local => "variable",
             HighlightTag::UnresolvedReference => "unresolved_reference",
-            HighlightTag::FormatSpecifier => "format_specifier",
-            HighlightTag::Operator => "operator",
         }
     }
 }
@@ -106,6 +116,8 @@ impl HighlightModifier {
         HighlightModifier::Attribute,
         HighlightModifier::ControlFlow,
         HighlightModifier::Definition,
+        HighlightModifier::Documentation,
+        HighlightModifier::Injected,
         HighlightModifier::Mutable,
         HighlightModifier::Unsafe,
     ];
@@ -115,6 +127,8 @@ impl HighlightModifier {
             HighlightModifier::Attribute => "attribute",
             HighlightModifier::ControlFlow => "control",
             HighlightModifier::Definition => "declaration",
+            HighlightModifier::Documentation => "documentation",
+            HighlightModifier::Injected => "injected",
             HighlightModifier::Mutable => "mutable",
             HighlightModifier::Unsafe => "unsafe",
         }
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index eb43a23da..87a6e2523 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -1,15 +1,13 @@
 use std::fs;
 
-use test_utils::{assert_eq_text, project_dir, read_text};
+use expect::{expect_file, ExpectFile};
+use test_utils::project_dir;
 
-use crate::{
-    mock_analysis::{single_file, MockAnalysis},
-    FileRange, TextRange,
-};
+use crate::{mock_analysis::single_file, FileRange, TextRange};
 
 #[test]
 fn test_highlighting() {
-    let (analysis, file_id) = single_file(
+    check_highlighting(
         r#"
 #[derive(Clone, Debug)]
 struct Foo {
@@ -27,6 +25,16 @@ impl Bar for Foo {
     }
 }
 
+impl Foo {
+    fn baz(mut self) -> i32 {
+        self.x
+    }
+
+    fn qux(&mut self) {
+        self.x = 0;
+    }
+}
+
 static mut STATIC_MUT: i32 = 0;
 
 fn foo<'a, T>() -> T {
@@ -43,6 +51,12 @@ def_fn! {
     }
 }
 
+macro_rules! noop {
+    ($expr:expr) => {
+        $expr
+    }
+}
+
 // comment
 fn main() {
     println!("Hello, {}!", 92);
@@ -61,10 +75,14 @@ fn main() {
         // Do nothing
     }
 
+    noop!(noop!(1));
+
     let mut x = 42;
     let y = &mut x;
     let z = &y;
 
+    let Foo { x: z, y } = Foo { x: z, y };
+
     y;
 }
 
@@ -84,17 +102,14 @@ impl<T> Option<T> {
 }
 "#
         .trim(),
+        expect_file!["crates/ra_ide/test_data/highlighting.html"],
+        false,
     );
-    let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlighting.html");
-    let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
-    let expected_html = &read_text(&dst_file);
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
 }
 
 #[test]
 fn test_rainbow_highlighting() {
-    let (analysis, file_id) = single_file(
+    check_highlighting(
         r#"
 fn main() {
     let hello = "hello";
@@ -110,12 +125,9 @@ fn bar() {
 }
 "#
         .trim(),
+        expect_file!["crates/ra_ide/test_data/rainbow_highlighting.html"],
+        true,
     );
-    let dst_file = project_dir().join("crates/ra_ide/src/snapshots/rainbow_highlighting.html");
-    let actual_html = &analysis.highlight_as_html(file_id, true).unwrap();
-    let expected_html = &read_text(&dst_file);
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
 }
 
 #[test]
@@ -123,12 +135,10 @@ fn accidentally_quadratic() {
     let file = project_dir().join("crates/ra_syntax/test_data/accidentally_quadratic");
     let src = fs::read_to_string(file).unwrap();
 
-    let mut mock = MockAnalysis::new();
-    let file_id = mock.add_file("/main.rs", &src);
-    let host = mock.analysis_host();
+    let (analysis, file_id) = single_file(&src);
 
     // let t = std::time::Instant::now();
-    let _ = host.analysis().highlight(file_id).unwrap();
+    let _ = analysis.highlight(file_id).unwrap();
     // eprintln!("elapsed: {:?}", t.elapsed());
 }
 
@@ -136,16 +146,17 @@ fn accidentally_quadratic() {
 fn test_ranges() {
     let (analysis, file_id) = single_file(
         r#"
-            #[derive(Clone, Debug)]
-            struct Foo {
-                pub x: i32,
-                pub y: i32,
-            }"#,
+#[derive(Clone, Debug)]
+struct Foo {
+    pub x: i32,
+    pub y: i32,
+}
+"#,
     );
 
     // The "x"
     let highlights = &analysis
-        .highlight_range(FileRange { file_id, range: TextRange::at(82.into(), 1.into()) })
+        .highlight_range(FileRange { file_id, range: TextRange::at(45.into(), 1.into()) })
         .unwrap();
 
     assert_eq!(&highlights[0].highlight.to_string(), "field.declaration");
@@ -153,7 +164,7 @@ fn test_ranges() {
 
 #[test]
 fn test_flattening() {
-    let (analysis, file_id) = single_file(
+    check_highlighting(
         r##"
 fn fixture(ra_fixture: &str) {}
 
@@ -167,13 +178,9 @@ fn main() {
     );
 }"##
         .trim(),
+        expect_file!["crates/ra_ide/test_data/highlight_injection.html"],
+        false,
     );
-
-    let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlight_injection.html");
-    let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
-    let expected_html = &read_text(&dst_file);
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
 }
 
 #[test]
@@ -192,7 +199,7 @@ macro_rules! test {}
 fn test_string_highlighting() {
     // The format string detection is based on macro-expansion,
     // thus, we have to copy the macro definition from `std`
-    let (analysis, file_id) = single_file(
+    check_highlighting(
         r#"
 macro_rules! println {
     ($($arg:tt)*) => ({
@@ -218,6 +225,7 @@ fn main() {
     println!("{argument}", argument = "test");   // => "test"
     println!("{name} {}", 1, name = 2);          // => "2 1"
     println!("{a} {c} {b}", a="a", b='b', c=3);  // => "a 3 b"
+    println!("{{{}}}", 2);                       // => "{2}"
     println!("Hello {:5}!", "x");
     println!("Hello {:1$}!", "x", 5);
     println!("Hello {1:0$}!", 5, "x");
@@ -245,15 +253,128 @@ fn main() {
 
     println!(r"Hello, {}!", "world");
 
+    // escape sequences
+    println!("Hello\nWorld");
+    println!("\u{48}\x65\x6C\x6C\x6F World");
+
     println!("{\x41}", A = 92);
     println!("{ничоси}", ничоси = 92);
 }"#
         .trim(),
+        expect_file!["crates/ra_ide/test_data/highlight_strings.html"],
+        false,
+    );
+}
+
+#[test]
+fn test_unsafe_highlighting() {
+    check_highlighting(
+        r#"
+unsafe fn unsafe_fn() {}
+
+struct HasUnsafeFn;
+
+impl HasUnsafeFn {
+    unsafe fn unsafe_method(&self) {}
+}
+
+fn main() {
+    let x = &5 as *const usize;
+    unsafe {
+        unsafe_fn();
+        HasUnsafeFn.unsafe_method();
+        let y = *(x);
+        let z = -x;
+    }
+}
+"#
+        .trim(),
+        expect_file!["crates/ra_ide/test_data/highlight_unsafe.html"],
+        false,
+    );
+}
+
+#[test]
+fn test_highlight_doctest() {
+    check_highlighting(
+        r#"
+/// ```
+/// let _ = "early doctests should not go boom";
+/// ```
+struct Foo {
+    bar: bool,
+}
+
+impl Foo {
+    pub const bar: bool = true;
+
+    /// Constructs a new `Foo`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #![allow(unused_mut)]
+    /// let mut foo: Foo = Foo::new();
+    /// ```
+    pub const fn new() -> Foo {
+        Foo { bar: true }
+    }
+
+    /// `bar` method on `Foo`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use x::y;
+    ///
+    /// let foo = Foo::new();
+    ///
+    /// // calls bar on foo
+    /// assert!(foo.bar());
+    ///
+    /// let bar = foo.bar || Foo::bar;
+    ///
+    /// /* multi-line
+    ///        comment */
+    ///
+    /// let multi_line_string = "Foo
+    ///   bar
+    ///          ";
+    ///
+    /// ```
+    ///
+    /// ```rust,no_run
+    /// let foobar = Foo::new().bar();
+    /// ```
+    ///
+    /// ```sh
+    /// echo 1
+    /// ```
+    pub fn foo(&self) -> bool {
+        true
+    }
+}
+
+/// ```
+/// noop!(1);
+/// ```
+macro_rules! noop {
+    ($expr:expr) => {
+        $expr
+    }
+}
+"#
+        .trim(),
+        expect_file!["crates/ra_ide/test_data/highlight_doctest.html"],
+        false,
     );
+}
 
-    let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlight_strings.html");
-    let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
-    let expected_html = &read_text(&dst_file);
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
+/// Highlights the code given by the `ra_fixture` argument, renders the
+/// result as HTML, and compares it with the HTML file given as `snapshot`.
+/// Note that the `snapshot` file is overwritten by the rendered HTML.
+fn check_highlighting(ra_fixture: &str, expect: ExpectFile, rainbow: bool) {
+    let (analysis, file_id) = single_file(ra_fixture);
+    let actual_html = &analysis.highlight_as_html(file_id, rainbow).unwrap();
+    expect.assert_eq(actual_html)
 }
diff --git a/crates/ra_ide/src/syntax_tree.rs b/crates/ra_ide/src/syntax_tree.rs
index a341684fd..f716a3861 100644
--- a/crates/ra_ide/src/syntax_tree.rs
+++ b/crates/ra_ide/src/syntax_tree.rs
@@ -104,7 +104,7 @@ fn syntax_tree_for_token(node: &SyntaxToken, text_range: TextRange) -> Option<St
 mod tests {
     use test_utils::assert_eq_text;
 
-    use crate::mock_analysis::{single_file, single_file_with_range};
+    use crate::mock_analysis::{analysis_and_range, single_file};
 
     #[test]
     fn test_syntax_tree_without_range() {
@@ -184,7 +184,7 @@ [email protected]
 
     #[test]
     fn test_syntax_tree_with_range() {
-        let (analysis, range) = single_file_with_range(r#"<|>fn foo() {}<|>"#.trim());
+        let (analysis, range) = analysis_and_range(r#"<|>fn foo() {}<|>"#.trim());
         let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
 
         assert_eq_text!(
@@ -206,7 +206,7 @@ [email protected]
             .trim()
         );
 
-        let (analysis, range) = single_file_with_range(
+        let (analysis, range) = analysis_and_range(
             r#"fn test() {
     <|>assert!("
     fn foo() {
@@ -242,7 +242,7 @@ [email protected]
 
     #[test]
     fn test_syntax_tree_inside_string() {
-        let (analysis, range) = single_file_with_range(
+        let (analysis, range) = analysis_and_range(
             r#"fn test() {
     assert!("
 <|>fn foo() {
@@ -276,7 +276,7 @@ [email protected]
         );
 
         // With a raw string
-        let (analysis, range) = single_file_with_range(
+        let (analysis, range) = analysis_and_range(
             r###"fn test() {
     assert!(r#"
 <|>fn foo() {
@@ -310,7 +310,7 @@ [email protected]
         );
 
         // With a raw string
-        let (analysis, range) = single_file_with_range(
+        let (analysis, range) = analysis_and_range(
             r###"fn test() {
     assert!(r<|>#"
 fn foo() {
diff --git a/crates/ra_ide/src/typing.rs b/crates/ra_ide/src/typing.rs
index 67e2c33a0..83776d2b6 100644
--- a/crates/ra_ide/src/typing.rs
+++ b/crates/ra_ide/src/typing.rs
@@ -17,11 +17,13 @@ mod on_enter;
 
 use ra_db::{FilePosition, SourceDatabase};
 use ra_fmt::leading_indent;
-use ra_ide_db::RootDatabase;
+use ra_ide_db::{source_change::SourceFileEdit, RootDatabase};
 use ra_syntax::{
     algo::find_node_at_offset,
     ast::{self, AstToken},
-    AstNode, SourceFile, TextRange, TextSize,
+    AstNode, SourceFile,
+    SyntaxKind::{FIELD_EXPR, METHOD_CALL_EXPR},
+    TextRange, TextSize,
 };
 
 use ra_text_edit::TextEdit;
@@ -47,8 +49,8 @@ pub(crate) fn on_char_typed(
     assert!(TRIGGER_CHARS.contains(char_typed));
     let file = &db.parse(position.file_id).tree();
     assert_eq!(file.syntax().text().char_at(position.offset), Some(char_typed));
-    let text_edit = on_char_typed_inner(file, position.offset, char_typed)?;
-    Some(SourceChange::source_file_edit_from(position.file_id, text_edit))
+    let edit = on_char_typed_inner(file, position.offset, char_typed)?;
+    Some(SourceFileEdit { file_id: position.file_id, edit }.into())
 }
 
 fn on_char_typed_inner(file: &SourceFile, offset: TextSize, char_typed: char) -> Option<TextEdit> {
@@ -98,9 +100,12 @@ fn on_dot_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
     };
     let current_indent_len = TextSize::of(current_indent);
 
+    let parent = whitespace.syntax().parent();
     // Make sure dot is a part of call chain
-    let field_expr = ast::FieldExpr::cast(whitespace.syntax().parent())?;
-    let prev_indent = leading_indent(field_expr.syntax())?;
+    if !matches!(parent.kind(), FIELD_EXPR | METHOD_CALL_EXPR) {
+        return None;
+    }
+    let prev_indent = leading_indent(&parent)?;
     let target_indent = format!("    {}", prev_indent);
     let target_indent_len = TextSize::of(&target_indent);
     if current_indent_len == target_indent_len {
@@ -143,11 +148,11 @@ mod tests {
         })
     }
 
-    fn type_char(char_typed: char, before: &str, after: &str) {
-        let actual = do_type_char(char_typed, before)
+    fn type_char(char_typed: char, ra_fixture_before: &str, ra_fixture_after: &str) {
+        let actual = do_type_char(char_typed, ra_fixture_before)
             .unwrap_or_else(|| panic!("typing `{}` did nothing", char_typed));
 
-        assert_eq_text!(after, &actual);
+        assert_eq_text!(ra_fixture_after, &actual);
     }
 
     fn type_char_noop(char_typed: char, before: &str) {
@@ -249,6 +254,27 @@ fn foo() {
     }
 
     #[test]
+    fn indents_new_chain_call_with_let() {
+        type_char(
+            '.',
+            r#"
+fn main() {
+    let _ = foo
+    <|>
+    bar()
+}
+"#,
+            r#"
+fn main() {
+    let _ = foo
+        .
+    bar()
+}
+"#,
+        );
+    }
+
+    #[test]
     fn indents_continued_chain_call() {
         type_char(
             '.',
diff --git a/crates/ra_ide/src/typing/on_enter.rs b/crates/ra_ide/src/typing/on_enter.rs
index a40d8af9c..2faaa8ff0 100644
--- a/crates/ra_ide/src/typing/on_enter.rs
+++ b/crates/ra_ide/src/typing/on_enter.rs
@@ -75,23 +75,22 @@ fn node_indent(file: &SourceFile, token: &SyntaxToken) -> Option<SmolStr> {
 
 #[cfg(test)]
 mod tests {
-    use test_utils::{assert_eq_text, extract_offset};
+    use test_utils::assert_eq_text;
 
-    use crate::mock_analysis::single_file;
-
-    use super::*;
+    use crate::mock_analysis::analysis_and_position;
+    use stdx::trim_indent;
 
     fn apply_on_enter(before: &str) -> Option<String> {
-        let (offset, before) = extract_offset(before);
-        let (analysis, file_id) = single_file(&before);
-        let result = analysis.on_enter(FilePosition { offset, file_id }).unwrap()?;
+        let (analysis, position) = analysis_and_position(&before);
+        let result = analysis.on_enter(position).unwrap()?;
 
-        let mut actual = before.to_string();
+        let mut actual = analysis.file_text(position.file_id).unwrap().to_string();
         result.apply(&mut actual);
         Some(actual)
     }
 
     fn do_check(ra_fixture_before: &str, ra_fixture_after: &str) {
+        let ra_fixture_after = &trim_indent(ra_fixture_after);
         let actual = apply_on_enter(ra_fixture_before).unwrap();
         assert_eq_text!(ra_fixture_after, &actual);
     }