9 files changed, 1404 insertions, 1940 deletions

diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 560fb19e6..ef22ea54d 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -213,7 +213,7 @@ impl<'a> CompletionContext<'a> {
         }
     }
 
-    pub(crate) fn scope(&self) -> SemanticsScope<'_, RootDatabase> {
+    pub(crate) fn scope(&self) -> SemanticsScope<'_> {
         self.sema.scope_at_offset(&self.token.parent(), self.offset)
     }
 
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 0b52b01ab..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,14 +81,6 @@ 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) {
@@ -278,16 +271,22 @@ impl ToNav for hir::Module {
 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(),
         )
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index bea7fbfa7..4c78fa214 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -103,205 +103,149 @@ 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().unwrap().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;
-
-            //- /b.rs
-            struct Foo;
-            ",
-            "Foo STRUCT_DEF FileId(2) 0..11 7..10",
-            "struct Foo;|Foo",
+        check(
+            r#"
+//- /lib.rs
+use a::Foo;
+mod a;
+mod b;
+enum E { X(Foo<|>) }
+
+//- /a.rs
+struct Foo;
+     //^^^
+//- /b.rs
+struct Foo;
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_module_declaration() {
-        check_goto(
+        check(
             r#"
 //- /lib.rs
 mod <|>foo;
 
 //- /foo.rs
 // empty
+//^ file
 "#,
-            "foo SOURCE_FILE FileId(2) 0..9",
-            "// empty\n",
         );
 
-        check_goto(
+        check(
             r#"
 //- /lib.rs
 mod <|>foo;
 
 //- /foo/mod.rs
 // empty
+//^ file
 "#,
-            "foo SOURCE_FILE FileId(2) 0..9",
-            "// empty\n",
         );
     }
 
     #[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!();
-            }
-
-            //- /foo/lib.rs
-            #[macro_export]
-            macro_rules! foo { () => { () } }
-            ",
-            "foo MACRO_CALL FileId(2) 0..49 29..32",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
-        );
-    }
-
-    #[test]
-    fn goto_def_for_use_alias() {
-        check_goto(
+        check(
             r#"
 //- /lib.rs
-use foo as bar<|>;
+use foo::foo;
+fn bar() {
+    <|>foo!();
+}
 
 //- /foo/lib.rs
 #[macro_export]
 macro_rules! foo { () => { () } }
+           //^^^
 "#,
-            "SOURCE_FILE FileId(2) 0..50",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }\n",
-        );
-    }
-
-    #[test]
-    fn goto_def_for_use_alias_foo_macro() {
-        check_goto(
-            "
-            //- /lib.rs
-            use foo::foo as bar<|>;
-
-            //- /foo/lib.rs
-            #[macro_export]
-            macro_rules! foo { () => { () } }
-            ",
-            "foo MACRO_CALL FileId(2) 0..49 29..32",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
         );
     }
 
     #[test]
     fn goto_def_for_macros_in_use_tree() {
-        check_goto(
-            "
-            //- /lib.rs
-            use foo::foo<|>;
+        check(
+            r#"
+//- /lib.rs
+use foo::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_macro_defined_fn_with_arg() {
-        check_goto(
+        check(
             r#"
 //- /lib.rs
 macro_rules! define_fn {
@@ -309,522 +253,478 @@ macro_rules! define_fn {
 }
 
 define_fn!(foo);
+         //^^^
 
 fn bar() {
    <|>foo();
 }
 "#,
-            "foo FN_DEF FileId(1) 65..81 76..79",
-            "define_fn!(foo);|foo",
         );
     }
 
     #[test]
     fn goto_def_for_macro_defined_fn_no_arg() {
-        check_goto(
+        check(
             r#"
 //- /lib.rs
 macro_rules! define_fn {
     () => (fn foo() {})
 }
 
-define_fn!();
+  define_fn!();
+//^^^^^^^^^^^^^
 
 fn bar() {
    <|>foo();
 }
 "#,
-            "foo FN_DEF FileId(1) 52..65 52..65",
-            "define_fn!();|define_fn!();",
         );
     }
 
     #[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",
+        check(
+            r#"
+//- /lib.rs
+macro_rules! foo {() => {0}}
+           //^^^
+
+fn bar() {
+    match (0,1) {
+        (<|>foo!(), _) => {}
+    }
+}
+"#,
         );
     }
 
     #[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",
+        check(
+            r#"
+//- /lib.rs
+macro_rules! foo {() => {0}}
+           //^^^
+fn bar() {
+    match 0 {
+        <|>foo!() => {}
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn goto_def_for_use_alias() {
+        check(
+            r#"
+//- /lib.rs
+use foo as bar<|>;
+
+//- /foo/lib.rs
+// empty
+//^ file
+"#,
+        );
+    }
+
+    #[test]
+    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 {}
+        check(
+            r#"
+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",
+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(
+        check(
             r#"
-//- /lib.rs
 macro_rules! id {
     ($($tt:tt)*) => ($($tt)*)
 }
 
 fn foo() {
     let x = 1;
+      //^
     id!({
         let y = <|>x;
         let z = y;
     });
 }
 "#,
-            "x BIND_PAT FileId(1) 70..71",
-            "x",
         );
 
-        check_goto(
+        check(
             r#"
-//- /lib.rs
 macro_rules! id {
     ($($tt:tt)*) => ($($tt)*)
 }
@@ -833,159 +733,125 @@ fn foo() {
     let x = 1;
     id!({
         let y = x;
+          //^
         let z = <|>y;
     });
 }
 "#,
-            "y BIND_PAT FileId(1) 99..100",
-            "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_goto(
-            "
-            //- /lib.rs
-            enum Foo {
-                Bar { x: i32 }
-            }
-            fn baz(foo: Foo) {
-                match foo {
-                    Foo::Bar { x<|> } => x
-                };
-            }
-            ",
-            "x RECORD_FIELD_DEF FileId(1) 21..27 21..22",
-            "x: i32|x",
+        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_goto(
-            "
-            //- /lib.rs
-            enum Foo {
-                Bar,
-            }
-            impl Foo {
-                fn baz(self) {
-                    match self {
-                        Self::Bar<|> => {}
-                    }
-                }
-            }
-            ",
-            "Bar ENUM_VARIANT FileId(1) 15..18 15..18",
-            "Bar|Bar",
+        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_goto(
-            "
-            //- /lib.rs
-            enum Foo {
-                Bar { val: i32 },
-            }
-            impl Foo {
-                fn baz(self) -> i32 {
-                    match self {
-                        Self::Bar<|> { val } => {}
-                    }
-                }
-            }
-            ",
-            "Bar ENUM_VARIANT FileId(1) 15..31 15..18",
-            "Bar { val: i32 }|Bar",
+        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_goto(
-            "
-            //- /lib.rs
-            enum Foo {
-                Bar,
-            }
-            impl Foo {
-                fn baz(self) {
-                    Self::Bar<|>;
-                }
-            }
-            ",
-            "Bar ENUM_VARIANT FileId(1) 15..18 15..18",
-            "Bar|Bar",
+        check(
+            r#"
+enum Foo { Bar }
+         //^^^
+impl Foo {
+    fn baz(self) { Self::Bar<|>; }
+}
+"#,
         );
     }
 
     #[test]
     fn goto_def_for_enum_variant_self_expr_record() {
-        check_goto(
-            "
-            //- /lib.rs
-            enum Foo {
-                Bar { val: i32 },
-            }
-            impl Foo {
-                fn baz(self) {
-                    Self::Bar<|> {val: 4};
-                }
-            }
-            ",
-            "Bar ENUM_VARIANT FileId(1) 15..31 15..18",
-            "Bar { val: i32 }|Bar",
+        check(
+            r#"
+enum Foo { Bar { val: i32 } }
+         //^^^
+impl Foo {
+    fn baz(self) { Self::Bar<|> {val: 4}; }
+}
+"#,
         );
     }
 }
diff --git a/crates/ra_ide/src/goto_implementation.rs b/crates/ra_ide/src/goto_implementation.rs
index 0cec0657e..99a7022a4 100644
--- a/crates/ra_ide/src/goto_implementation.rs
+++ b/crates/ra_ide/src/goto_implementation.rs
@@ -74,135 +74,152 @@ 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<|>;
+"#,
         );
     }
 }
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 3fd08b1e8..62d364bfa 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;
@@ -258,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;
     }
@@ -270,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(
@@ -312,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
 }
 
@@ -346,583 +345,251 @@ 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(ra_fixture, InlayHintsConfig::default());
+    }
+
+    fn check_with_config(ra_fixture: &str, config: InlayHintsConfig) {
+        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(ra_fixture: &str, config: InlayHintsConfig, 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(
             r#"
-            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{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 69..70,
-                kind: ParameterHint,
-                label: "a",
-            },
-            InlayHint {
-                range: 72..73,
-                kind: ParameterHint,
-                label: "b",
+fn foo(a: i32, b: i32) -> i32 { a + b }
+fn main() {
+    let _x = foo(
+        4,
+      //^ a
+        4,
+      //^ b
+    );
+}"#,
+            InlayHintsConfig {
+                parameter_hints: true,
+                type_hints: false,
+                chaining_hints: false,
+                max_length: None,
             },
-        ]
-        "###);
+        );
     }
 
     #[test]
     fn hints_disabled() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
             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);
+}"#,
+            InlayHintsConfig {
+                type_hints: false,
+                parameter_hints: false,
+                chaining_hints: false,
+                max_length: None,
+            },
         );
-        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(
             r#"
-            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: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 60..62,
-                kind: TypeHint,
-                label: "i32",
+fn foo(a: i32, b: i32) -> i32 { a + b }
+fn main() {
+    let _x = foo(4, 4);
+      //^^ i32
+}"#,
+            InlayHintsConfig {
+                type_hints: true,
+                parameter_hints: false,
+                chaining_hints: false,
+                max_length: None,
             },
-        ]
-        "###);
+        );
     }
+
     #[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: 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: 68..70,
-                kind: TypeHint,
-                label: "Test<i32>",
-            },
-            InlayHint {
-                range: 106..112,
-                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: 192..196,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 235..243,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 274..278,
-                kind: TypeHint,
-                label: "&str",
-            },
-            InlayHint {
-                range: 538..542,
-                kind: TypeHint,
-                label: "(i32, char)",
-            },
-            InlayHint {
-                range: 565..566,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 569..570,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 572..573,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 576..577,
-                kind: TypeHint,
-                label: "f64",
-            },
-            InlayHint {
-                range: 579..580,
-                kind: TypeHint,
-                label: "f64",
-            },
-            InlayHint {
-                range: 583..584,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 626..627,
-                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 =
+      //^^^^^^^^ |…| -> i32
+      | a,     b| a * b
+      //^ i32  ^ i32
+    ;
 
-    let multiply = |a, b, c, d| a * b * c * d;
-    let _: i32 = multiply(1, 2, 3, 4);
+    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: 20..29,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 56..65,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 114..122,
-                kind: TypeHint,
-                label: "|…| -> i32",
-            },
-            InlayHint {
-                range: 126..127,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 129..130,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 132..133,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 135..136,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 200..212,
-                kind: TypeHint,
-                label: "&|…| -> i32",
-            },
-            InlayHint {
-                range: 235..244,
-                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: 20..29,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 43..52,
-                kind: TypeHint,
-                label: "i32",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn if_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 });
+      //^^^^ 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: 187..191,
-                kind: TypeHint,
-                label: "CustomOption<Test>",
-            },
-            InlayHint {
-                range: 266..270,
-                kind: TypeHint,
-                label: "&CustomOption<Test>",
-            },
-            InlayHint {
-                range: 299..303,
-                kind: TypeHint,
-                label: "&Test",
-            },
-            InlayHint {
-                range: 340..341,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 343..344,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 386..387,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 392..393,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 440..441,
-                kind: TypeHint,
-                label: "&u32",
-            },
-            InlayHint {
-                range: 447..448,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 499..500,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 542..543,
-                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: 187..191,
-                kind: TypeHint,
-                label: "CustomOption<Test>",
-            },
-            InlayHint {
-                range: 272..276,
-                kind: TypeHint,
-                label: "&CustomOption<Test>",
-            },
-            InlayHint {
-                range: 308..312,
-                kind: TypeHint,
-                label: "&Test",
-            },
-            InlayHint {
-                range: 352..353,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 355..356,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 401..402,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 407..408,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 458..459,
-                kind: TypeHint,
-                label: "&u32",
-            },
-            InlayHint {
-                range: 465..466,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 520..521,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 566..567,
-                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: 251..255,
-                kind: TypeHint,
-                label: "CustomOption<Test>",
-            },
-            InlayHint {
-                range: 276..280,
-                kind: TypeHint,
-                label: "Test",
-            },
-            InlayHint {
-                range: 309..310,
-                kind: TypeHint,
-                label: "CustomOption<u32>",
-            },
-            InlayHint {
-                range: 312..313,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 347..348,
-                kind: TypeHint,
-                label: "CustomOption<u32>",
-            },
-            InlayHint {
-                range: 353..354,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 393..394,
-                kind: TypeHint,
-                label: "u32",
-            },
-            InlayHint {
-                range: 400..401,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 444..445,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 479..480,
-                kind: TypeHint,
-                label: "u8",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn hint_truncation() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
             r#"
 struct Smol<T>(T);
 
@@ -930,52 +597,26 @@ 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: 73..74,
-                kind: TypeHint,
-                label: "Smol<u32>",
-            },
-            InlayHint {
-                range: 97..98,
-                kind: TypeHint,
-                label: "VeryLongOuterName<…>",
-            },
-            InlayHint {
-                range: 136..137,
-                kind: TypeHint,
-                label: "Smol<Smol<…>>",
-            },
-        ]
-        "###
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
         );
     }
 
     #[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 {}
@@ -983,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 {}
     }
@@ -1006,108 +644,35 @@ 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: 797..808,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 841..842,
-                kind: ParameterHint,
-                label: "foo",
-            },
-            InlayHint {
-                range: 844..845,
-                kind: ParameterHint,
-                label: "bar",
-            },
-            InlayHint {
-                range: 847..854,
-                kind: ParameterHint,
-                label: "msg",
-            },
-            InlayHint {
-                range: 859..870,
-                kind: ParameterHint,
-                label: "last",
-            },
-            InlayHint {
-                range: 913..916,
-                kind: ParameterHint,
-                label: "param",
-            },
-            InlayHint {
-                range: 936..938,
-                kind: ParameterHint,
-                label: "&self",
-            },
-            InlayHint {
-                range: 940..944,
-                kind: ParameterHint,
-                label: "param",
-            },
-            InlayHint {
-                range: 979..988,
-                kind: ParameterHint,
-                label: "file_id",
-            },
-            InlayHint {
-                range: 998..1011,
-                kind: ParameterHint,
-                label: "name",
-            },
-            InlayHint {
-                range: 1021..1025,
-                kind: ParameterHint,
-                label: "focus_range",
-            },
-            InlayHint {
-                range: 1035..1047,
-                kind: ParameterHint,
-                label: "full_range",
-            },
-            InlayHint {
-                range: 1057..1070,
-                kind: ParameterHint,
-                label: "kind",
-            },
-            InlayHint {
-                range: 1080..1084,
-                kind: ParameterHint,
-                label: "docs",
-            },
-            InlayHint {
-                range: 1094..1098,
-                kind: ParameterHint,
-                label: "description",
-            },
-        ]
-        "###
-        );
     }
 
     #[test]
     fn omitted_parameters_hints_heuristics() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
             r#"
 fn map(f: i32) {}
 fn filter(predicate: i32) {}
@@ -1188,23 +753,16 @@ fn main() {
     let _: f64 = a.div_euclid(b);
     let _: f64 = a.abs_sub(b);
 }"#,
-        );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
-        []
-        "###
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
         );
     }
 
     #[test]
     fn unit_structs_have_no_type_hints() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
             r#"
-enum CustomResult<T, E> {
-    Ok(T),
-    Err(E),
-}
-use CustomResult::*;
+enum Result<T, E> { Ok(T), Err(E) }
+use Result::*;
 
 struct SyntheticSyntax;
 
@@ -1214,136 +772,157 @@ fn main() {
         Err(SyntheticSyntax) => (),
     }
 }"#,
-        );
-
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
-        []
-        "###
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
         );
     }
 
     #[test]
     fn chaining_hints_ignore_comments() {
-        let (analysis, file_id) = single_file(
+        check_expect(
             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();
+}
+"#,
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
+            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: 147..172,
-                kind: ChainingHint,
-                label: "B",
-            },
-            InlayHint {
-                range: 147..154,
-                kind: ChainingHint,
-                label: "A",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn chaining_hints_without_newlines() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
             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();
+}"#,
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
         );
-        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(
             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();
+}"#,
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
+            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: 143..190,
-                kind: ChainingHint,
-                label: "C",
-            },
-            InlayHint {
-                range: 143..179,
-                kind: ChainingHint,
-                label: "B",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn generic_chaining_hints() {
-        let (analysis, file_id) = single_file(
+        check_expect(
             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();
+}
+"#,
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
+            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: 246..283,
-                kind: ChainingHint,
-                label: "B<X<i32, bool>>",
-            },
-            InlayHint {
-                range: 246..265,
-                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/mock_analysis.rs b/crates/ra_ide/src/mock_analysis.rs
index 889b84c59..a393d3dba 100644
--- a/crates/ra_ide/src/mock_analysis.rs
+++ b/crates/ra_ide/src/mock_analysis.rs
@@ -3,7 +3,9 @@ use std::sync::Arc;
 
 use ra_cfg::CfgOptions;
 use ra_db::{CrateName, Env, FileSet, SourceRoot, VfsPath};
-use test_utils::{extract_range_or_offset, Fixture, RangeOrOffset, CURSOR_MARKER};
+use test_utils::{
+    extract_annotations, extract_range_or_offset, Fixture, RangeOrOffset, CURSOR_MARKER,
+};
 
 use crate::{
     Analysis, AnalysisChange, AnalysisHost, CrateGraph, Edition, FileId, FilePosition, FileRange,
@@ -77,6 +79,24 @@ impl MockAnalysis {
             .expect("no file in this mock");
         FileId(idx as u32 + 1)
     }
+    pub fn annotations(&self) -> Vec<(FileRange, String)> {
+        self.files
+            .iter()
+            .enumerate()
+            .flat_map(|(idx, fixture)| {
+                let file_id = FileId(idx as u32 + 1);
+                let annotations = extract_annotations(&fixture.text);
+                annotations
+                    .into_iter()
+                    .map(move |(range, data)| (FileRange { file_id, range }, data))
+            })
+            .collect()
+    }
+    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 mut change = AnalysisChange::new();
@@ -110,7 +130,7 @@ impl MockAnalysis {
                 let other_crate = crate_graph.add_crate_root(
                     file_id,
                     edition,
-                    Some(CrateName::new(crate_name).unwrap()),
+                    Some(crate_name.to_string()),
                     cfg,
                     env,
                     Default::default(),
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index f569a3f17..ed15d6494 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -251,13 +251,21 @@ fn runnable_mod(
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
     use crate::mock_analysis::analysis_and_position;
 
-    use super::{Runnable, RunnableAction, BENCH, BIN, DOCTEST, TEST};
-
-    fn assert_actions(runnables: &[Runnable], actions: &[&RunnableAction]) {
+    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()
@@ -266,579 +274,557 @@ mod tests {
 
     #[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() {}
-
-        #[bench]
-        fn bench() {}
-        "#,
-        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 1..21,
-                    name: "main",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        12..16,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: Bin,
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 23..47,
-                    name: "test_foo",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        34..42,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                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: [],
                     },
-                },
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 49..83,
-                    name: "test_foo",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        70..78,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: Test {
-                    test_id: Path(
-                        "test_foo",
-                    ),
-                    attr: TestAttr {
-                        ignore: true,
+                    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 {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 85..107,
-                    name: "bench",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        97..102,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: Bench {
-                    test_id: Path(
-                        "bench",
-                    ),
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&BIN, &TEST, &TEST, &BENCH]);
+                    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: [],
+                    },
+                ]
+            "#]],
+        );
     }
 
     #[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 {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 1..21,
-                    name: "main",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        12..16,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: Bin,
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 23..65,
-                    name: "foo",
-                    kind: FN_DEF,
-                    focus_range: None,
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: DocTest {
-                    test_id: Path(
-                        "foo",
-                    ),
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&BIN, &DOCTEST]);
     }
 
     #[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 {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 1..21,
-                    name: "main",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        12..16,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: Bin,
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 52..106,
-                    name: "foo",
-                    kind: FN_DEF,
-                    focus_range: None,
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: DocTest {
-                    test_id: Path(
-                        "Data::foo",
-                    ),
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&BIN, &DOCTEST]);
     }
 
     #[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 {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 1..59,
-                    name: "test_mod",
-                    kind: MODULE,
-                    focus_range: Some(
-                        13..21,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: TestMod {
-                    path: "test_mod",
-                },
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 28..57,
-                    name: "test_foo1",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        43..52,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                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: [],
+                    },
+                    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: [],
                     },
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&TEST, &TEST]);
+                ]
+            "#]],
+        );
     }
 
     #[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 {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 23..85,
-                    name: "test_mod",
-                    kind: MODULE,
-                    focus_range: Some(
-                        27..35,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: TestMod {
-                    path: "foo::test_mod",
-                },
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 46..79,
-                    name: "test_foo1",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        65..74,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                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: [],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&TEST, &TEST]);
+                ]
+            "#]],
+        );
     }
 
     #[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 {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 41..115,
-                    name: "test_mod",
-                    kind: MODULE,
-                    focus_range: Some(
-                        45..53,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: TestMod {
-                    path: "foo::bar::test_mod",
-                },
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 68..105,
-                    name: "test_foo1",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        91..100,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                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: [],
+                    },
+                    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: [],
                     },
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&TEST, &TEST]);
+                ]
+            "#]],
+        );
     }
 
     #[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 {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 1..58,
-                    name: "test_foo1",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        44..53,
-                    ),
-                    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",
+//- /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",
+                            },
+                        ],
                     },
-                ],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&TEST]);
+                ]
+            "#]],
+        );
     }
 
     #[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 {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 1..80,
-                    name: "test_foo1",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        66..75,
-                    ),
-                    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",
+//- /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",
+                                    },
+                                ],
+                            ),
                         ],
-                    ),
-                ],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&TEST]);
+                    },
+                ]
+            "#]],
+        );
     }
 
     #[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/ssr.rs b/crates/ra_ide/src/ssr.rs
index 6cb96608b..9f8e540c0 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -4,7 +4,7 @@ use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
 use crate::SourceFileEdit;
 use ra_ssr::{MatchFinder, SsrError, SsrRule};
 
-// Feature: Structural Seach and Replace
+// Feature: Structural Search and Replace
 //
 // 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>`.