31 files changed, 2749 insertions, 1208 deletions

diff --git a/crates/ide/src/annotations.rs b/crates/ide/src/annotations.rs
new file mode 100644
index 000000000..2e8e82b70
--- /dev/null
+++ b/crates/ide/src/annotations.rs
@@ -0,0 +1,937 @@
+use hir::Semantics;
+use ide_db::{
+    base_db::{FileId, FilePosition, FileRange, SourceDatabase},
+    RootDatabase, SymbolKind,
+};
+use syntax::TextRange;
+
+use crate::{
+    file_structure::file_structure,
+    fn_references::find_all_methods,
+    goto_implementation::goto_implementation,
+    references::find_all_refs,
+    runnables::{runnables, Runnable},
+    NavigationTarget, RunnableKind,
+};
+
+// Feature: Annotations
+//
+// Provides user with annotations above items for looking up references or impl blocks
+// and running/debugging binaries.
+#[derive(Debug)]
+pub struct Annotation {
+    pub range: TextRange,
+    pub kind: AnnotationKind,
+}
+
+#[derive(Debug)]
+pub enum AnnotationKind {
+    Runnable { debug: bool, runnable: Runnable },
+    HasImpls { position: FilePosition, data: Option<Vec<NavigationTarget>> },
+    HasReferences { position: FilePosition, data: Option<Vec<FileRange>> },
+}
+
+pub struct AnnotationConfig {
+    pub binary_target: bool,
+    pub annotate_runnables: bool,
+    pub annotate_impls: bool,
+    pub annotate_references: bool,
+    pub annotate_method_references: bool,
+    pub run: bool,
+    pub debug: bool,
+}
+
+pub(crate) fn annotations(
+    db: &RootDatabase,
+    file_id: FileId,
+    config: AnnotationConfig,
+) -> Vec<Annotation> {
+    let mut annotations = Vec::default();
+
+    if config.annotate_runnables {
+        for runnable in runnables(db, file_id) {
+            if should_skip_runnable(&runnable.kind, config.binary_target) {
+                continue;
+            }
+
+            let action = runnable.action();
+            let range = runnable.nav.full_range;
+
+            if config.run {
+                annotations.push(Annotation {
+                    range,
+
+                    // FIXME: This one allocates without reason if run is enabled, but debug is disabled
+                    kind: AnnotationKind::Runnable { debug: false, runnable: runnable.clone() },
+                });
+            }
+
+            if action.debugee && config.debug {
+                annotations.push(Annotation {
+                    range,
+                    kind: AnnotationKind::Runnable { debug: true, runnable },
+                });
+            }
+        }
+    }
+
+    file_structure(&db.parse(file_id).tree())
+        .into_iter()
+        .filter(|node| {
+            matches!(
+                node.kind,
+                SymbolKind::Trait
+                    | SymbolKind::Struct
+                    | SymbolKind::Enum
+                    | SymbolKind::Union
+                    | SymbolKind::Const
+            )
+        })
+        .for_each(|node| {
+            if config.annotate_impls && node.kind != SymbolKind::Const {
+                annotations.push(Annotation {
+                    range: node.node_range,
+                    kind: AnnotationKind::HasImpls {
+                        position: FilePosition { file_id, offset: node.navigation_range.start() },
+                        data: None,
+                    },
+                });
+            }
+
+            if config.annotate_references {
+                annotations.push(Annotation {
+                    range: node.node_range,
+                    kind: AnnotationKind::HasReferences {
+                        position: FilePosition { file_id, offset: node.navigation_range.start() },
+                        data: None,
+                    },
+                });
+            }
+        });
+
+    if config.annotate_method_references {
+        annotations.extend(find_all_methods(db, file_id).into_iter().map(|method| Annotation {
+            range: method.range,
+            kind: AnnotationKind::HasReferences {
+                position: FilePosition { file_id, offset: method.range.start() },
+                data: None,
+            },
+        }));
+    }
+
+    annotations
+}
+
+pub(crate) fn resolve_annotation(db: &RootDatabase, mut annotation: Annotation) -> Annotation {
+    match annotation.kind {
+        AnnotationKind::HasImpls { position, ref mut data } => {
+            *data = goto_implementation(db, position).map(|range| range.info);
+        }
+        AnnotationKind::HasReferences { position, ref mut data } => {
+            *data = find_all_refs(&Semantics::new(db), position, None).map(|result| {
+                result
+                    .references
+                    .into_iter()
+                    .map(|(file_id, access)| {
+                        access.into_iter().map(move |(range, _)| FileRange { file_id, range })
+                    })
+                    .flatten()
+                    .collect()
+            });
+        }
+        _ => {}
+    };
+
+    annotation
+}
+
+fn should_skip_runnable(kind: &RunnableKind, binary_target: bool) -> bool {
+    match kind {
+        RunnableKind::Bin => !binary_target,
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use expect_test::{expect, Expect};
+
+    use crate::{fixture, Annotation, AnnotationConfig};
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let (analysis, file_id) = fixture::file(ra_fixture);
+
+        let annotations: Vec<Annotation> = analysis
+            .annotations(
+                file_id,
+                AnnotationConfig {
+                    binary_target: true,
+                    annotate_runnables: true,
+                    annotate_impls: true,
+                    annotate_references: true,
+                    annotate_method_references: true,
+                    run: true,
+                    debug: true,
+                },
+            )
+            .unwrap()
+            .into_iter()
+            .map(|annotation| analysis.resolve_annotation(annotation).unwrap())
+            .collect();
+
+        expect.assert_debug_eq(&annotations);
+    }
+
+    #[test]
+    fn const_annotations() {
+        check(
+            r#"
+const DEMO: i32 = 123;
+
+const UNUSED: i32 = 123;
+
+fn main() {
+    let hello = DEMO;
+}
+            "#,
+            expect![[r#"
+                [
+                    Annotation {
+                        range: 50..85,
+                        kind: Runnable {
+                            debug: false,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 50..85,
+                                    focus_range: 53..57,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 50..85,
+                        kind: Runnable {
+                            debug: true,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 50..85,
+                                    focus_range: 53..57,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 0..22,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 6,
+                            },
+                            data: Some(
+                                [
+                                    FileRange {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        range: 78..82,
+                                    },
+                                ],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 24..48,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 30,
+                            },
+                            data: Some(
+                                [],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 53..57,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 53,
+                            },
+                            data: Some(
+                                [],
+                            ),
+                        },
+                    },
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn struct_references_annotations() {
+        check(
+            r#"
+struct Test;
+
+fn main() {
+    let test = Test;
+}
+            "#,
+            expect![[r#"
+                [
+                    Annotation {
+                        range: 14..48,
+                        kind: Runnable {
+                            debug: false,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 14..48,
+                                    focus_range: 17..21,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 14..48,
+                        kind: Runnable {
+                            debug: true,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 14..48,
+                                    focus_range: 17..21,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 0..12,
+                        kind: HasImpls {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 7,
+                            },
+                            data: Some(
+                                [],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 0..12,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 7,
+                            },
+                            data: Some(
+                                [
+                                    FileRange {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        range: 41..45,
+                                    },
+                                ],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 17..21,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 17,
+                            },
+                            data: Some(
+                                [],
+                            ),
+                        },
+                    },
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn struct_and_trait_impls_annotations() {
+        check(
+            r#"
+struct Test;
+
+trait MyCoolTrait {}
+
+impl MyCoolTrait for Test {}
+
+fn main() {
+    let test = Test;
+}
+            "#,
+            expect![[r#"
+                [
+                    Annotation {
+                        range: 66..100,
+                        kind: Runnable {
+                            debug: false,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 66..100,
+                                    focus_range: 69..73,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 66..100,
+                        kind: Runnable {
+                            debug: true,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 66..100,
+                                    focus_range: 69..73,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 0..12,
+                        kind: HasImpls {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 7,
+                            },
+                            data: Some(
+                                [
+                                    NavigationTarget {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        full_range: 36..64,
+                                        focus_range: 57..61,
+                                        name: "impl",
+                                        kind: Impl,
+                                    },
+                                ],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 0..12,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 7,
+                            },
+                            data: Some(
+                                [
+                                    FileRange {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        range: 57..61,
+                                    },
+                                    FileRange {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        range: 93..97,
+                                    },
+                                ],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 14..34,
+                        kind: HasImpls {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 20,
+                            },
+                            data: Some(
+                                [
+                                    NavigationTarget {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        full_range: 36..64,
+                                        focus_range: 57..61,
+                                        name: "impl",
+                                        kind: Impl,
+                                    },
+                                ],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 14..34,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 20,
+                            },
+                            data: Some(
+                                [
+                                    FileRange {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        range: 41..52,
+                                    },
+                                ],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 69..73,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 69,
+                            },
+                            data: Some(
+                                [],
+                            ),
+                        },
+                    },
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn runnable_annotation() {
+        check(
+            r#"
+fn main() {}
+            "#,
+            expect![[r#"
+                [
+                    Annotation {
+                        range: 0..12,
+                        kind: Runnable {
+                            debug: false,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 0..12,
+                                    focus_range: 3..7,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 0..12,
+                        kind: Runnable {
+                            debug: true,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 0..12,
+                                    focus_range: 3..7,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 3..7,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 3,
+                            },
+                            data: Some(
+                                [],
+                            ),
+                        },
+                    },
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn method_annotations() {
+        check(
+            r#"
+struct Test;
+
+impl Test {
+    fn self_by_ref(&self) {}
+}
+
+fn main() {
+    Test.self_by_ref();
+}
+            "#,
+            expect![[r#"
+                [
+                    Annotation {
+                        range: 58..95,
+                        kind: Runnable {
+                            debug: false,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 58..95,
+                                    focus_range: 61..65,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 58..95,
+                        kind: Runnable {
+                            debug: true,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 58..95,
+                                    focus_range: 61..65,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 0..12,
+                        kind: HasImpls {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 7,
+                            },
+                            data: Some(
+                                [
+                                    NavigationTarget {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        full_range: 14..56,
+                                        focus_range: 19..23,
+                                        name: "impl",
+                                        kind: Impl,
+                                    },
+                                ],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 0..12,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 7,
+                            },
+                            data: Some(
+                                [
+                                    FileRange {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        range: 19..23,
+                                    },
+                                    FileRange {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        range: 74..78,
+                                    },
+                                ],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 33..44,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 33,
+                            },
+                            data: Some(
+                                [
+                                    FileRange {
+                                        file_id: FileId(
+                                            0,
+                                        ),
+                                        range: 79..90,
+                                    },
+                                ],
+                            ),
+                        },
+                    },
+                    Annotation {
+                        range: 61..65,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 61,
+                            },
+                            data: Some(
+                                [],
+                            ),
+                        },
+                    },
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_annotations() {
+        check(
+            r#"
+fn main() {}
+
+mod tests {
+    #[test]
+    fn my_cool_test() {}
+}
+            "#,
+            expect![[r#"
+                [
+                    Annotation {
+                        range: 0..12,
+                        kind: Runnable {
+                            debug: false,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 0..12,
+                                    focus_range: 3..7,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 0..12,
+                        kind: Runnable {
+                            debug: true,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 0..12,
+                                    focus_range: 3..7,
+                                    name: "main",
+                                    kind: Function,
+                                },
+                                kind: Bin,
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 14..64,
+                        kind: Runnable {
+                            debug: false,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 14..64,
+                                    focus_range: 18..23,
+                                    name: "tests",
+                                    kind: Module,
+                                },
+                                kind: TestMod {
+                                    path: "tests",
+                                },
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 14..64,
+                        kind: Runnable {
+                            debug: true,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 14..64,
+                                    focus_range: 18..23,
+                                    name: "tests",
+                                    kind: Module,
+                                },
+                                kind: TestMod {
+                                    path: "tests",
+                                },
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 30..62,
+                        kind: Runnable {
+                            debug: false,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 30..62,
+                                    focus_range: 45..57,
+                                    name: "my_cool_test",
+                                    kind: Function,
+                                },
+                                kind: Test {
+                                    test_id: Path(
+                                        "tests::my_cool_test",
+                                    ),
+                                    attr: TestAttr {
+                                        ignore: false,
+                                    },
+                                },
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 30..62,
+                        kind: Runnable {
+                            debug: true,
+                            runnable: Runnable {
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 30..62,
+                                    focus_range: 45..57,
+                                    name: "my_cool_test",
+                                    kind: Function,
+                                },
+                                kind: Test {
+                                    test_id: Path(
+                                        "tests::my_cool_test",
+                                    ),
+                                    attr: TestAttr {
+                                        ignore: false,
+                                    },
+                                },
+                                cfg: None,
+                            },
+                        },
+                    },
+                    Annotation {
+                        range: 3..7,
+                        kind: HasReferences {
+                            position: FilePosition {
+                                file_id: FileId(
+                                    0,
+                                ),
+                                offset: 3,
+                            },
+                            data: Some(
+                                [],
+                            ),
+                        },
+                    },
+                ]
+            "#]],
+        );
+    }
+}
diff --git a/crates/ide/src/call_hierarchy.rs b/crates/ide/src/call_hierarchy.rs
index e8999a7f3..b848945d7 100644
--- a/crates/ide/src/call_hierarchy.rs
+++ b/crates/ide/src/call_hierarchy.rs
@@ -47,11 +47,11 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
 
     let mut calls = CallLocations::default();
 
-    for (&file_id, references) in refs.info.references().iter() {
+    for (file_id, references) in refs.references {
         let file = sema.parse(file_id);
         let file = file.syntax();
-        for reference in references {
-            let token = file.token_at_offset(reference.range.start()).next()?;
+        for (r_range, _) in references {
+            let token = file.token_at_offset(r_range.start()).next()?;
             let token = sema.descend_into_macros(token);
             let syntax = token.parent();
 
@@ -61,7 +61,7 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
                 let def = sema.to_def(&fn_)?;
                 def.try_to_nav(sema.db)
             }) {
-                let relative_range = reference.range;
+                let relative_range = r_range;
                 calls.add(&nav, relative_range);
             }
         }
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index b35bc2bae..fe32f39b6 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -10,15 +10,16 @@ mod field_shorthand;
 use std::cell::RefCell;
 
 use hir::{
+    db::AstDatabase,
     diagnostics::{Diagnostic as _, DiagnosticCode, DiagnosticSinkBuilder},
-    Semantics,
+    InFile, Semantics,
 };
 use ide_db::{base_db::SourceDatabase, RootDatabase};
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
 use syntax::{
     ast::{self, AstNode},
-    SyntaxNode, TextRange,
+    SyntaxNode, SyntaxNodePtr, TextRange,
 };
 use text_edit::TextEdit;
 
@@ -136,6 +137,9 @@ pub(crate) fn diagnostics(
         .on::<hir::diagnostics::IncorrectCase, _>(|d| {
             res.borrow_mut().push(warning_with_fix(d, &sema));
         })
+        .on::<hir::diagnostics::ReplaceFilterMapNextWithFindMap, _>(|d| {
+            res.borrow_mut().push(warning_with_fix(d, &sema));
+        })
         .on::<hir::diagnostics::InactiveCode, _>(|d| {
             // If there's inactive code somewhere in a macro, don't propagate to the call-site.
             if d.display_source().file_id.expansion_info(db).is_some() {
@@ -144,20 +148,38 @@ pub(crate) fn diagnostics(
 
             // Override severity and mark as unused.
             res.borrow_mut().push(
-                Diagnostic::hint(sema.diagnostics_display_range(d).range, d.message())
-                    .with_unused(true)
-                    .with_code(Some(d.code())),
+                Diagnostic::hint(
+                    sema.diagnostics_display_range(d.display_source()).range,
+                    d.message(),
+                )
+                .with_unused(true)
+                .with_code(Some(d.code())),
             );
         })
         .on::<hir::diagnostics::UnresolvedProcMacro, _>(|d| {
             // Use more accurate position if available.
-            let display_range =
-                d.precise_location.unwrap_or_else(|| sema.diagnostics_display_range(d).range);
+            let display_range = d
+                .precise_location
+                .unwrap_or_else(|| sema.diagnostics_display_range(d.display_source()).range);
 
             // FIXME: it would be nice to tell the user whether proc macros are currently disabled
             res.borrow_mut()
                 .push(Diagnostic::hint(display_range, d.message()).with_code(Some(d.code())));
         })
+        .on::<hir::diagnostics::UnresolvedMacroCall, _>(|d| {
+            let last_path_segment = sema.db.parse_or_expand(d.file).and_then(|root| {
+                d.node
+                    .to_node(&root)
+                    .path()
+                    .and_then(|it| it.segment())
+                    .and_then(|it| it.name_ref())
+                    .map(|it| InFile::new(d.file, SyntaxNodePtr::new(it.syntax())))
+            });
+            let diagnostics = last_path_segment.unwrap_or_else(|| d.display_source());
+            let display_range = sema.diagnostics_display_range(diagnostics).range;
+            res.borrow_mut()
+                .push(Diagnostic::error(display_range, d.message()).with_code(Some(d.code())));
+        })
         // Only collect experimental diagnostics when they're enabled.
         .filter(|diag| !(diag.is_experimental() && config.disable_experimental))
         .filter(|diag| !config.disabled.contains(diag.code().as_str()));
@@ -167,8 +189,11 @@ pub(crate) fn diagnostics(
         // Diagnostics not handled above get no fix and default treatment.
         .build(|d| {
             res.borrow_mut().push(
-                Diagnostic::error(sema.diagnostics_display_range(d).range, d.message())
-                    .with_code(Some(d.code())),
+                Diagnostic::error(
+                    sema.diagnostics_display_range(d.display_source()).range,
+                    d.message(),
+                )
+                .with_code(Some(d.code())),
             );
         });
 
@@ -180,13 +205,13 @@ pub(crate) fn diagnostics(
 }
 
 fn diagnostic_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
-    Diagnostic::error(sema.diagnostics_display_range(d).range, d.message())
+    Diagnostic::error(sema.diagnostics_display_range(d.display_source()).range, d.message())
         .with_fix(d.fix(&sema))
         .with_code(Some(d.code()))
 }
 
 fn warning_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
-    Diagnostic::hint(sema.diagnostics_display_range(d).range, d.message())
+    Diagnostic::hint(sema.diagnostics_display_range(d.display_source()).range, d.message())
         .with_fix(d.fix(&sema))
         .with_code(Some(d.code()))
 }
@@ -643,6 +668,29 @@ fn test_fn() {
     }
 
     #[test]
+    fn test_unresolved_macro_range() {
+        check_expect(
+            r#"foo::bar!(92);"#,
+            expect![[r#"
+                [
+                    Diagnostic {
+                        message: "unresolved macro call",
+                        range: 5..8,
+                        severity: Error,
+                        fix: None,
+                        unused: false,
+                        code: Some(
+                            DiagnosticCode(
+                                "unresolved-macro-call",
+                            ),
+                        ),
+                    },
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
     fn range_mapping_out_of_macros() {
         // FIXME: this is very wrong, but somewhat tricky to fix.
         check_fix(
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index e4335119b..cbfc66ab3 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -4,7 +4,7 @@ use hir::{
     db::AstDatabase,
     diagnostics::{
         Diagnostic, IncorrectCase, MissingFields, MissingOkOrSomeInTailExpr, NoSuchField,
-        RemoveThisSemicolon, UnresolvedModule,
+        RemoveThisSemicolon, ReplaceFilterMapNextWithFindMap, UnresolvedModule,
     },
     HasSource, HirDisplay, InFile, Semantics, VariantDef,
 };
@@ -15,8 +15,8 @@ use ide_db::{
 };
 use syntax::{
     algo,
-    ast::{self, edit::IndentLevel, make},
-    AstNode,
+    ast::{self, edit::IndentLevel, make, ArgListOwner},
+    AstNode, TextRange,
 };
 use text_edit::TextEdit;
 
@@ -140,7 +140,34 @@ impl DiagnosticWithFix for IncorrectCase {
             rename_with_semantics(sema, file_position, &self.suggested_text).ok()?;
 
         let label = format!("Rename to {}", self.suggested_text);
-        Some(Fix::new(&label, rename_changes.info, rename_changes.range))
+        Some(Fix::new(&label, rename_changes, frange.range))
+    }
+}
+
+impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap {
+    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+        let root = sema.db.parse_or_expand(self.file)?;
+        let next_expr = self.next_expr.to_node(&root);
+        let next_call = ast::MethodCallExpr::cast(next_expr.syntax().clone())?;
+
+        let filter_map_call = ast::MethodCallExpr::cast(next_call.receiver()?.syntax().clone())?;
+        let filter_map_name_range = filter_map_call.name_ref()?.ident_token()?.text_range();
+        let filter_map_args = filter_map_call.arg_list()?;
+
+        let range_to_replace =
+            TextRange::new(filter_map_name_range.start(), next_expr.syntax().text_range().end());
+        let replacement = format!("find_map{}", filter_map_args.syntax().text());
+        let trigger_range = next_expr.syntax().text_range();
+
+        let edit = TextEdit::replace(range_to_replace, replacement);
+
+        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
+
+        Some(Fix::new(
+            "Replace filter_map(..).next() with find_map()",
+            source_change,
+            trigger_range,
+        ))
     }
 }
 
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 00e601244..198243466 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -7,6 +7,7 @@ use hir::{AssocItem, Documentation, FieldSource, HasAttrs, HasSource, InFile, Mo
 use ide_db::{
     base_db::{FileId, FileRange, SourceDatabase},
     symbol_index::FileSymbolKind,
+    SymbolKind,
 };
 use ide_db::{defs::Definition, RootDatabase};
 use syntax::{
@@ -18,30 +19,6 @@ use crate::FileSymbol;
 
 use super::short_label::ShortLabel;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum SymbolKind {
-    Module,
-    Impl,
-    Field,
-    TypeParam,
-    ConstParam,
-    LifetimeParam,
-    ValueParam,
-    SelfParam,
-    Local,
-    Label,
-    Function,
-    Const,
-    Static,
-    Struct,
-    Enum,
-    Variant,
-    Union,
-    TypeAlias,
-    Trait,
-    Macro,
-}
-
 /// `NavigationTarget` represents and element in the editor's UI which you can
 /// click on to navigate to a particular piece of code.
 ///
@@ -108,12 +85,16 @@ impl NavigationTarget {
         let name = module.name(db).map(|it| it.to_string().into()).unwrap_or_default();
         if let Some(src) = module.declaration_source(db) {
             let node = src.as_ref().map(|it| it.syntax());
-            let frange = node.original_file_range(db);
+            let full_range = node.original_file_range(db);
+            let focus_range = src
+                .value
+                .name()
+                .map(|name| src.with_value(name.syntax()).original_file_range(db).range);
             let mut res = NavigationTarget::from_syntax(
-                frange.file_id,
+                full_range.file_id,
                 name,
-                None,
-                frange.range,
+                focus_range,
+                full_range.range,
                 SymbolKind::Module,
             );
             res.docs = module.attrs(db).docs();
@@ -153,8 +134,7 @@ impl NavigationTarget {
         node: InFile<&dyn ast::NameOwner>,
         kind: SymbolKind,
     ) -> NavigationTarget {
-        let name =
-            node.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
+        let name = node.value.name().map(|it| it.text().into()).unwrap_or_else(|| "_".into());
         let focus_range =
             node.value.name().map(|it| node.with_value(it.syntax()).original_file_range(db).range);
         let frange = node.map(|it| it.syntax()).original_file_range(db);
@@ -197,6 +177,7 @@ impl ToNav for FileSymbol {
                 FileSymbolKind::Const => SymbolKind::Const,
                 FileSymbolKind::Static => SymbolKind::Static,
                 FileSymbolKind::Macro => SymbolKind::Macro,
+                FileSymbolKind::Union => SymbolKind::Union,
             }),
             full_range: self.range,
             focus_range: self.name_range,
@@ -295,6 +276,7 @@ impl ToNav for hir::Module {
             ModuleSource::Module(node) => {
                 (node.syntax(), node.name().map(|it| it.syntax().text_range()))
             }
+            ModuleSource::BlockExpr(node) => (node.syntax(), None),
         };
         let frange = src.with_value(syntax).original_file_range(db);
         NavigationTarget::from_syntax(frange.file_id, name, focus, frange.range, SymbolKind::Module)
@@ -457,13 +439,16 @@ impl TryToNav for hir::TypeParam {
     fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
         let src = self.source(db)?;
         let full_range = match &src.value {
-            Either::Left(it) => it.syntax().text_range(),
+            Either::Left(it) => it
+                .name()
+                .map_or_else(|| it.syntax().text_range(), |name| name.syntax().text_range()),
             Either::Right(it) => it.syntax().text_range(),
         };
         let focus_range = match &src.value {
-            Either::Left(_) => None,
-            Either::Right(it) => it.name().map(|it| it.syntax().text_range()),
-        };
+            Either::Left(it) => it.name(),
+            Either::Right(it) => it.name(),
+        }
+        .map(|it| it.syntax().text_range());
         Some(NavigationTarget {
             file_id: src.file_id.original_file(db),
             name: self.name(db).to_string().into(),
diff --git a/crates/ide/src/display/short_label.rs b/crates/ide/src/display/short_label.rs
index 990f740b8..84b8883de 100644
--- a/crates/ide/src/display/short_label.rs
+++ b/crates/ide/src/display/short_label.rs
@@ -53,9 +53,19 @@ impl ShortLabel for ast::SourceFile {
     }
 }
 
+impl ShortLabel for ast::BlockExpr {
+    fn short_label(&self) -> Option<String> {
+        None
+    }
+}
+
 impl ShortLabel for ast::TypeAlias {
     fn short_label(&self) -> Option<String> {
-        short_label_from_node(self, "type ")
+        let mut buf = short_label_from_node(self, "type ")?;
+        if let Some(type_ref) = self.ty() {
+            format_to!(buf, " = {}", type_ref.syntax());
+        }
+        Some(buf)
     }
 }
 
@@ -90,7 +100,7 @@ impl ShortLabel for ast::Variant {
 impl ShortLabel for ast::ConstParam {
     fn short_label(&self) -> Option<String> {
         let mut buf = "const ".to_owned();
-        buf.push_str(self.name()?.text().as_str());
+        buf.push_str(self.name()?.text());
         if let Some(type_ref) = self.ty() {
             format_to!(buf, ": {}", type_ref.syntax());
         }
@@ -117,6 +127,6 @@ where
 {
     let mut buf = node.visibility().map(|v| format!("{} ", v.syntax())).unwrap_or_default();
     buf.push_str(label);
-    buf.push_str(node.name()?.text().as_str());
+    buf.push_str(node.name()?.text());
     Some(buf)
 }
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index de10406bc..7bdd3cca3 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -9,8 +9,7 @@ use url::Url;
 
 use hir::{
     db::{DefDatabase, HirDatabase},
-    Adt, AsAssocItem, AsName, AssocItem, AssocItemContainer, Crate, Field, HasAttrs, ItemInNs,
-    ModuleDef,
+    Adt, AsAssocItem, AssocItem, AssocItemContainer, Crate, Field, HasAttrs, ItemInNs, ModuleDef,
 };
 use ide_db::{
     defs::{Definition, NameClass, NameRefClass},
@@ -221,14 +220,31 @@ fn rewrite_intra_doc_link(
     }?;
     let krate = resolved.module(db)?.krate();
     let canonical_path = resolved.canonical_path(db)?;
-    let new_target = get_doc_url(db, &krate)?
+    let mut new_url = get_doc_url(db, &krate)?
         .join(&format!("{}/", krate.display_name(db)?))
         .ok()?
         .join(&canonical_path.replace("::", "/"))
         .ok()?
         .join(&get_symbol_filename(db, &resolved)?)
-        .ok()?
-        .into_string();
+        .ok()?;
+
+    if let ModuleDef::Trait(t) = resolved {
+        let items = t.items(db);
+        if let Some(field_or_assoc_item) = items.iter().find_map(|assoc_item| {
+            if let Some(name) = assoc_item.name(db) {
+                if *link == format!("{}::{}", canonical_path, name) {
+                    return Some(FieldOrAssocItem::AssocItem(*assoc_item));
+                }
+            }
+            None
+        }) {
+            if let Some(fragment) = get_symbol_fragment(db, &field_or_assoc_item) {
+                new_url = new_url.join(&fragment).ok()?;
+            }
+        };
+    }
+
+    let new_target = new_url.into_string();
     let new_title = strip_prefixes_suffixes(title);
     Some((new_target, new_title.to_string()))
 }
@@ -412,7 +428,7 @@ fn get_symbol_filename(db: &dyn HirDatabase, definition: &ModuleDef) -> Option<S
         ModuleDef::Module(_) => "index.html".to_string(),
         ModuleDef::Trait(t) => format!("trait.{}.html", t.name(db)),
         ModuleDef::TypeAlias(t) => format!("type.{}.html", t.name(db)),
-        ModuleDef::BuiltinType(t) => format!("primitive.{}.html", t.as_name()),
+        ModuleDef::BuiltinType(t) => format!("primitive.{}.html", t.name()),
         ModuleDef::Function(f) => format!("fn.{}.html", f.name(db)),
         ModuleDef::Variant(ev) => {
             format!("enum.{}.html#variant.{}", ev.parent_enum(db).name(db), ev.name(db))
@@ -438,10 +454,10 @@ fn get_symbol_fragment(db: &dyn HirDatabase, field_or_assoc: &FieldOrAssocItem)
         FieldOrAssocItem::Field(field) => format!("#structfield.{}", field.name(db)),
         FieldOrAssocItem::AssocItem(assoc) => match assoc {
             AssocItem::Function(function) => {
-                let is_trait_method = matches!(
-                    function.as_assoc_item(db).map(|assoc| assoc.container(db)),
-                    Some(AssocItemContainer::Trait(..))
-                );
+                let is_trait_method = function
+                    .as_assoc_item(db)
+                    .and_then(|assoc| assoc.containing_trait(db))
+                    .is_some();
                 // This distinction may get more complicated when specialization is available.
                 // Rustdoc makes this decision based on whether a method 'has defaultness'.
                 // Currently this is only the case for provided trait methods.
diff --git a/crates/ide/src/extend_selection.rs b/crates/ide/src/extend_selection.rs
index 17a540972..b540d04fe 100644
--- a/crates/ide/src/extend_selection.rs
+++ b/crates/ide/src/extend_selection.rs
@@ -12,15 +12,17 @@ use syntax::{
 
 use crate::FileRange;
 
-// Feature: Extend Selection
+// Feature: Expand and Shrink Selection
 //
-// Extends the current selection to the encompassing syntactic construct
+// Extends or shrinks the current selection to the encompassing syntactic construct
 // (expression, statement, item, module, etc). It works with multiple cursors.
 //
+// This is a standard LSP feature and not a protocol extension.
+//
 // |===
 // | Editor  | Shortcut
 //
-// | VS Code | kbd:[Ctrl+Shift+→]
+// | VS Code | kbd:[Alt+Shift+→], kbd:[Alt+Shift+←]
 // |===
 pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
     let sema = Semantics::new(db);
@@ -213,8 +215,8 @@ fn extend_ws(root: &SyntaxNode, ws: SyntaxToken, offset: TextSize) -> TextRange
     let ws_text = ws.text();
     let suffix = TextRange::new(offset, ws.text_range().end()) - ws.text_range().start();
     let prefix = TextRange::new(ws.text_range().start(), offset) - ws.text_range().start();
-    let ws_suffix = &ws_text.as_str()[suffix];
-    let ws_prefix = &ws_text.as_str()[prefix];
+    let ws_suffix = &ws_text[suffix];
+    let ws_prefix = &ws_text[prefix];
     if ws_text.contains('\n') && !ws_suffix.contains('\n') {
         if let Some(node) = ws.next_sibling_or_token() {
             let start = match ws_prefix.rfind('\n') {
diff --git a/crates/ide/src/file_structure.rs b/crates/ide/src/file_structure.rs
index 32556dad3..26793bdb4 100644
--- a/crates/ide/src/file_structure.rs
+++ b/crates/ide/src/file_structure.rs
@@ -1,10 +1,9 @@
+use ide_db::SymbolKind;
 use syntax::{
     ast::{self, AttrsOwner, GenericParamsOwner, NameOwner},
     match_ast, AstNode, SourceFile, SyntaxNode, TextRange, WalkEvent,
 };
 
-use crate::SymbolKind;
-
 #[derive(Debug, Clone)]
 pub struct StructureNode {
     pub parent: Option<usize>,
diff --git a/crates/ide/src/fixture.rs b/crates/ide/src/fixture.rs
index cc8218885..cc6641ba1 100644
--- a/crates/ide/src/fixture.rs
+++ b/crates/ide/src/fixture.rs
@@ -1,5 +1,6 @@
 //! Utilities for creating `Analysis` instances for tests.
 use ide_db::base_db::fixture::ChangeFixture;
+use syntax::{TextRange, TextSize};
 use test_utils::{extract_annotations, RangeOrOffset};
 
 use crate::{Analysis, AnalysisHost, FileId, FilePosition, FileRange};
@@ -68,3 +69,18 @@ pub(crate) fn annotations(ra_fixture: &str) -> (Analysis, FilePosition, Vec<(Fil
         .collect();
     (host.analysis(), FilePosition { file_id, offset }, annotations)
 }
+
+pub(crate) fn nav_target_annotation(ra_fixture: &str) -> (Analysis, FilePosition, FileRange) {
+    let (analysis, position, mut annotations) = annotations(ra_fixture);
+    let (mut expected, data) = annotations.pop().unwrap();
+    assert!(annotations.is_empty());
+    match data.as_str() {
+        "" => (),
+        "file" => {
+            expected.range =
+                TextRange::up_to(TextSize::of(&*analysis.file_text(expected.file_id).unwrap()))
+        }
+        data => panic!("bad data: {}", data),
+    }
+    (analysis, position, expected)
+}
diff --git a/crates/ide/src/fn_references.rs b/crates/ide/src/fn_references.rs
index f6e5a522b..1a99a1f37 100644
--- a/crates/ide/src/fn_references.rs
+++ b/crates/ide/src/fn_references.rs
@@ -1,8 +1,8 @@
 //! This module implements a methods and free functions search in the specified file.
 //! We have to skip tests, so cannot reuse file_structure module.
 
-use assists::utils::test_related_attribute;
 use hir::Semantics;
+use ide_assists::utils::test_related_attribute;
 use ide_db::RootDatabase;
 use syntax::{ast, ast::NameOwner, AstNode, SyntaxNode};
 
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index a1d2bce1d..abed1969e 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -2,16 +2,14 @@ use either::Either;
 use hir::{HasAttrs, ModuleDef, Semantics};
 use ide_db::{
     defs::{Definition, NameClass, NameRefClass},
-    symbol_index, RootDatabase,
+    RootDatabase,
 };
 use syntax::{
     ast, match_ast, AstNode, AstToken, SyntaxKind::*, SyntaxToken, TextSize, TokenAtOffset, T,
 };
 
 use crate::{
-    display::{ToNav, TryToNav},
-    doc_links::extract_definitions_from_markdown,
-    runnables::doc_owner_to_def,
+    display::TryToNav, doc_links::extract_definitions_from_markdown, runnables::doc_owner_to_def,
     FilePosition, NavigationTarget, RangeInfo,
 };
 
@@ -33,33 +31,31 @@ pub(crate) fn goto_definition(
     let original_token = pick_best(file.token_at_offset(position.offset))?;
     let token = sema.descend_into_macros(original_token.clone());
     let parent = token.parent();
-    if let Some(comment) = ast::Comment::cast(token.clone()) {
+    if let Some(comment) = ast::Comment::cast(token) {
         let nav = def_for_doc_comment(&sema, position, &comment)?.try_to_nav(db)?;
         return Some(RangeInfo::new(original_token.text_range(), vec![nav]));
     }
 
-    let nav_targets = match_ast! {
+    let nav = match_ast! {
         match parent {
             ast::NameRef(name_ref) => {
-                reference_definition(&sema, Either::Right(&name_ref)).to_vec()
+                reference_definition(&sema, Either::Right(&name_ref))
             },
             ast::Name(name) => {
                 let def = NameClass::classify(&sema, &name)?.referenced_or_defined(sema.db);
-                let nav = def.try_to_nav(sema.db)?;
-                vec![nav]
+                def.try_to_nav(sema.db)
             },
             ast::Lifetime(lt) => if let Some(name_class) = NameClass::classify_lifetime(&sema, &lt) {
                 let def = name_class.referenced_or_defined(sema.db);
-                let nav = def.try_to_nav(sema.db)?;
-                vec![nav]
+                def.try_to_nav(sema.db)
             } else {
-                reference_definition(&sema, Either::Left(&lt)).to_vec()
+                reference_definition(&sema, Either::Left(&lt))
             },
             _ => return None,
         }
     };
 
-    Some(RangeInfo::new(original_token.text_range(), nav_targets))
+    Some(RangeInfo::new(original_token.text_range(), nav.into_iter().collect()))
 }
 
 fn def_for_doc_comment(
@@ -120,63 +116,26 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
     }
 }
 
-#[derive(Debug)]
-pub(crate) enum ReferenceResult {
-    Exact(NavigationTarget),
-    Approximate(Vec<NavigationTarget>),
-}
-
-impl ReferenceResult {
-    fn to_vec(self) -> Vec<NavigationTarget> {
-        match self {
-            ReferenceResult::Exact(target) => vec![target],
-            ReferenceResult::Approximate(vec) => vec,
-        }
-    }
-}
-
 pub(crate) fn reference_definition(
     sema: &Semantics<RootDatabase>,
     name_ref: Either<&ast::Lifetime, &ast::NameRef>,
-) -> ReferenceResult {
+) -> Option<NavigationTarget> {
     let name_kind = name_ref.either(
         |lifetime| NameRefClass::classify_lifetime(sema, lifetime),
         |name_ref| NameRefClass::classify(sema, name_ref),
-    );
-    if let Some(def) = name_kind {
-        let def = def.referenced(sema.db);
-        return match def.try_to_nav(sema.db) {
-            Some(nav) => ReferenceResult::Exact(nav),
-            None => ReferenceResult::Approximate(Vec::new()),
-        };
-    }
-
-    // Fallback index based approach:
-    let name = name_ref.either(ast::Lifetime::text, ast::NameRef::text);
-    let navs =
-        symbol_index::index_resolve(sema.db, name).into_iter().map(|s| s.to_nav(sema.db)).collect();
-    ReferenceResult::Approximate(navs)
+    )?;
+    let def = name_kind.referenced(sema.db);
+    def.try_to_nav(sema.db)
 }
 
 #[cfg(test)]
 mod tests {
     use ide_db::base_db::FileRange;
-    use syntax::{TextRange, TextSize};
 
     use crate::fixture;
 
     fn check(ra_fixture: &str) {
-        let (analysis, position, mut annotations) = fixture::annotations(ra_fixture);
-        let (mut expected, data) = annotations.pop().unwrap();
-        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 (analysis, position, expected) = fixture::nav_target_annotation(ra_fixture);
         let mut navs =
             analysis.goto_definition(position).unwrap().expect("no definition found").info;
         if navs.len() == 0 {
@@ -192,12 +151,12 @@ mod tests {
     fn goto_def_for_extern_crate() {
         check(
             r#"
-            //- /main.rs crate:main deps:std
-            extern crate std$0;
-            //- /std/lib.rs crate:std
-            // empty
-            //^ file
-            "#,
+//- /main.rs crate:main deps:std
+extern crate std$0;
+//- /std/lib.rs crate:std
+// empty
+//^ file
+"#,
         )
     }
 
@@ -205,12 +164,12 @@ mod tests {
     fn goto_def_for_renamed_extern_crate() {
         check(
             r#"
-            //- /main.rs crate:main deps:std
-            extern crate std as abc$0;
-            //- /std/lib.rs crate:std
-            // empty
-            //^ file
-            "#,
+//- /main.rs crate:main deps:std
+extern crate std as abc$0;
+//- /std/lib.rs crate:std
+// empty
+//^ file
+"#,
         )
     }
 
@@ -297,13 +256,13 @@ fn bar() {
     fn goto_def_for_macros_from_other_crates() {
         check(
             r#"
-//- /lib.rs
+//- /lib.rs crate:main deps:foo
 use foo::foo;
 fn bar() {
     $0foo!();
 }
 
-//- /foo/lib.rs
+//- /foo/lib.rs crate:foo
 #[macro_export]
 macro_rules! foo { () => { () } }
            //^^^
@@ -315,10 +274,10 @@ macro_rules! foo { () => { () } }
     fn goto_def_for_macros_in_use_tree() {
         check(
             r#"
-//- /lib.rs
+//- /lib.rs crate:main deps:foo
 use foo::foo$0;
 
-//- /foo/lib.rs
+//- /foo/lib.rs crate:foo
 #[macro_export]
 macro_rules! foo { () => { () } }
            //^^^
@@ -976,10 +935,10 @@ type Alias<T> = T$0;
     fn goto_def_for_macro_container() {
         check(
             r#"
-//- /lib.rs
+//- /lib.rs crate:main deps:foo
 foo::module$0::mac!();
 
-//- /foo/lib.rs
+//- /foo/lib.rs crate:foo
 pub mod module {
       //^^^^^^
     #[macro_export]
diff --git a/crates/ide/src/goto_implementation.rs b/crates/ide/src/goto_implementation.rs
index 761a98b2c..3990305fc 100644
--- a/crates/ide/src/goto_implementation.rs
+++ b/crates/ide/src/goto_implementation.rs
@@ -23,7 +23,7 @@ pub(crate) fn goto_implementation(
 
     let krate = sema.to_module_def(position.file_id)?.krate();
 
-    if let Some(nominal_def) = find_node_at_offset::<ast::AdtDef>(&syntax, position.offset) {
+    if let Some(nominal_def) = find_node_at_offset::<ast::Adt>(&syntax, position.offset) {
         return Some(RangeInfo::new(
             nominal_def.syntax().text_range(),
             impls_for_def(&sema, &nominal_def, krate)?,
@@ -40,13 +40,13 @@ pub(crate) fn goto_implementation(
 
 fn impls_for_def(
     sema: &Semantics<RootDatabase>,
-    node: &ast::AdtDef,
+    node: &ast::Adt,
     krate: Crate,
 ) -> Option<Vec<NavigationTarget>> {
     let ty = match node {
-        ast::AdtDef::Struct(def) => sema.to_def(def)?.ty(sema.db),
-        ast::AdtDef::Enum(def) => sema.to_def(def)?.ty(sema.db),
-        ast::AdtDef::Union(def) => sema.to_def(def)?.ty(sema.db),
+        ast::Adt::Struct(def) => sema.to_def(def)?.ty(sema.db),
+        ast::Adt::Enum(def) => sema.to_def(def)?.ty(sema.db),
+        ast::Adt::Union(def) => sema.to_def(def)?.ty(sema.db),
     };
 
     let impls = Impl::all_in_crate(sema.db, krate);
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 2024acd94..20b799490 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -2,8 +2,8 @@ use hir::{
     Adt, AsAssocItem, AssocItemContainer, FieldSource, GenericParam, HasAttrs, HasSource,
     HirDisplay, Module, ModuleDef, ModuleSource, Semantics,
 };
-use ide_db::base_db::SourceDatabase;
 use ide_db::{
+    base_db::SourceDatabase,
     defs::{Definition, NameClass, NameRefClass},
     RootDatabase,
 };
@@ -94,7 +94,12 @@ pub(crate) fn hover(
     let node = token.parent();
     let definition = match_ast! {
         match node {
-            ast::Name(name) => NameClass::classify(&sema, &name).and_then(|d| d.defined(sema.db)),
+            // we don't use NameClass::referenced_or_defined here as we do not want to resolve
+            // field pattern shorthands to their definition
+            ast::Name(name) => NameClass::classify(&sema, &name).and_then(|class| match class {
+                NameClass::ConstReference(def) => Some(def),
+                def => def.defined(sema.db),
+            }),
             ast::NameRef(name_ref) => NameRefClass::classify(&sema, &name_ref).map(|d| d.referenced(sema.db)),
             ast::Lifetime(lifetime) => NameClass::classify_lifetime(&sema, &lifetime)
                 .map_or_else(|| NameRefClass::classify_lifetime(&sema, &lifetime).map(|d| d.referenced(sema.db)), |d| d.defined(sema.db)),
@@ -182,12 +187,7 @@ fn runnable_action(
 ) -> Option<HoverAction> {
     match def {
         Definition::ModuleDef(it) => match it {
-            ModuleDef::Module(it) => match it.definition_source(sema.db).value {
-                ModuleSource::Module(it) => {
-                    runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it))
-                }
-                _ => None,
-            },
+            ModuleDef::Module(it) => runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it)),
             ModuleDef::Function(func) => {
                 let src = func.source(sema.db)?;
                 if src.file_id != file_id.into() {
@@ -326,6 +326,7 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
                 match it.definition_source(db).value {
                     ModuleSource::Module(it) => it.short_label(),
                     ModuleSource::SourceFile(it) => it.short_label(),
+                    ModuleSource::BlockExpr(it) => it.short_label(),
                 },
                 mod_path,
             ),
@@ -338,7 +339,7 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
             ModuleDef::Static(it) => from_def_source(db, it, mod_path),
             ModuleDef::Trait(it) => from_def_source(db, it, mod_path),
             ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path),
-            ModuleDef::BuiltinType(it) => Some(Markup::fenced_block(&it)),
+            ModuleDef::BuiltinType(it) => Some(Markup::fenced_block(&it.name())),
         },
         Definition::Local(it) => Some(Markup::fenced_block(&it.ty(db).display(db))),
         Definition::SelfType(impl_def) => {
@@ -1830,6 +1831,35 @@ pub struct B$0ar
             "#]],
         );
     }
+    #[test]
+    fn test_hover_intra_link_reference_to_trait_method() {
+        check(
+            r#"
+pub trait Foo {
+    fn buzz() -> usize;
+}
+/// [Foo][buzz]
+///
+/// [buzz]: Foo::buzz
+pub struct B$0ar
+"#,
+            expect![[r#"
+                *Bar*
+
+                ```rust
+                test
+                ```
+
+                ```rust
+                pub struct Bar
+                ```
+
+                ---
+
+                [Foo](https://docs.rs/test/*/test/trait.Foo.html#tymethod.buzz)
+            "#]],
+        );
+    }
 
     #[test]
     fn test_hover_external_url() {
@@ -3387,7 +3417,7 @@ impl<T> Foo<T$0> {}
                 ```
                 "#]],
         );
-        // lifetimes aren't being substituted yet
+        // lifetimes bounds arent being tracked yet
         check(
             r#"
 struct Foo<T>(T);
@@ -3397,7 +3427,7 @@ impl<T: 'static> Foo<T$0> {}
                 *T*
 
                 ```rust
-                T: {error}
+                T
                 ```
                 "#]],
         );
@@ -3419,4 +3449,80 @@ impl<const LEN: usize> Foo<LEN$0> {}
             "#]],
         );
     }
+
+    #[test]
+    fn hover_const_pat() {
+        check(
+            r#"
+/// This is a doc
+const FOO: usize = 3;
+fn foo() {
+    match 5 {
+        FOO$0 => (),
+        _ => ()
+    }
+}
+"#,
+            expect![[r#"
+                *FOO*
+
+                ```rust
+                test
+                ```
+
+                ```rust
+                const FOO: usize = 3
+                ```
+
+                ---
+
+                This is a doc
+            "#]],
+        );
+    }
+
+    #[test]
+    fn hover_mod_def() {
+        check(
+            r#"
+//- /main.rs
+mod foo$0;
+//- /foo.rs
+//! For the horde!
+"#,
+            expect![[r#"
+                *foo*
+                For the horde!
+            "#]],
+        );
+    }
+
+    #[test]
+    fn hover_self_in_use() {
+        check(
+            r#"
+//! This should not appear
+mod foo {
+    /// But this should appear
+    pub mod bar {}
+}
+use foo::bar::{self$0};
+"#,
+            expect![[r#"
+                *self*
+
+                ```rust
+                test::foo
+                ```
+
+                ```rust
+                pub mod bar
+                ```
+
+                ---
+
+                But this should appear
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index a2039fcc7..4ceb20742 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -109,26 +109,31 @@ fn get_chaining_hints(
     // Chaining can be defined as an expression whose next sibling tokens are newline and dot
     // Ignoring extra whitespace and comments
     let next = tokens.next()?.kind();
-    let next_next = tokens.next()?.kind();
-    if next == SyntaxKind::WHITESPACE && next_next == T![.] {
-        let ty = sema.type_of_expr(&expr)?;
-        if ty.is_unknown() {
-            return None;
+    if next == SyntaxKind::WHITESPACE {
+        let mut next_next = tokens.next()?.kind();
+        while next_next == SyntaxKind::WHITESPACE {
+            next_next = tokens.next()?.kind();
         }
-        if matches!(expr, ast::Expr::PathExpr(_)) {
-            if let Some(hir::Adt::Struct(st)) = ty.as_adt() {
-                if st.fields(sema.db).is_empty() {
-                    return None;
+        if next_next == T![.] {
+            let ty = sema.type_of_expr(&expr)?;
+            if ty.is_unknown() {
+                return None;
+            }
+            if matches!(expr, ast::Expr::PathExpr(_)) {
+                if let Some(hir::Adt::Struct(st)) = ty.as_adt() {
+                    if st.fields(sema.db).is_empty() {
+                        return None;
+                    }
                 }
             }
+            acc.push(InlayHint {
+                range: expr.syntax().text_range(),
+                kind: InlayKind::ChainingHint,
+                label: hint_iterator(sema, &famous_defs, config, &ty).unwrap_or_else(|| {
+                    ty.display_truncated(sema.db, config.max_length).to_string().into()
+                }),
+            });
         }
-        acc.push(InlayHint {
-            range: expr.syntax().text_range(),
-            kind: InlayKind::ChainingHint,
-            label: hint_iterator(sema, &famous_defs, config, &ty).unwrap_or_else(|| {
-                ty.display_truncated(sema.db, config.max_length).to_string().into()
-            }),
-        });
     }
     Some(())
 }
@@ -411,13 +416,16 @@ fn get_string_representation(expr: &ast::Expr) -> Option<String> {
     match expr {
         ast::Expr::MethodCallExpr(method_call_expr) => {
             let name_ref = method_call_expr.name_ref()?;
-            match name_ref.text().as_str() {
+            match name_ref.text() {
                 "clone" => method_call_expr.receiver().map(|rec| rec.to_string()),
                 name_ref => Some(name_ref.to_owned()),
             }
         }
+        ast::Expr::FieldExpr(field_expr) => Some(field_expr.name_ref()?.to_string()),
+        ast::Expr::PathExpr(path_expr) => Some(path_expr.to_string()),
+        ast::Expr::PrefixExpr(prefix_expr) => get_string_representation(&prefix_expr.expr()?),
         ast::Expr::RefExpr(ref_expr) => get_string_representation(&ref_expr.expr()?),
-        _ => Some(expr.to_string()),
+        _ => None,
     }
 }
 
@@ -651,6 +659,7 @@ fn main() {
     let test = "test";
       //^^^^ &str
     let test = InnerStruct {};
+      //^^^^ InnerStruct
 
     let test = unresolved();
 
@@ -979,6 +988,7 @@ struct C;
 fn main() {
     let c = A(B(C))
         .into_b() // This is a comment
+        // This is another comment
         .into_c();
 }
 "#,
@@ -1438,4 +1448,19 @@ fn main() {
 "#,
         )
     }
+
+    #[test]
+    fn param_name_hints_show_for_literals() {
+        check(
+            r#"pub fn test(a: i32, b: i32) -> [i32; 2] { [a, b] }
+fn main() {
+    test(
+        0x0fab272b,
+      //^^^^^^^^^^ a
+        0x0fab272b
+      //^^^^^^^^^^ b
+    );
+}"#,
+        )
+    }
 }
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index 981467c8d..2c077ed1f 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -1,4 +1,4 @@
-use assists::utils::extract_trivial_expression;
+use ide_assists::utils::extract_trivial_expression;
 use itertools::Itertools;
 use syntax::{
     algo::non_trivia_sibling,
@@ -59,7 +59,7 @@ fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextS
         // The node is either the first or the last in the file
         let suff = &token.text()[TextRange::new(
             offset - token.text_range().start() + TextSize::of('\n'),
-            TextSize::of(token.text().as_str()),
+            TextSize::of(token.text()),
         )];
         let spaces = suff.bytes().take_while(|&b| b == b' ').count();
 
@@ -270,27 +270,28 @@ fn foo() {
 
     #[test]
     fn test_join_lines_diverging_block() {
-        let before = r"
-            fn foo() {
-                loop {
-                    match x {
-                        92 => $0{
-                            continue;
-                        }
-                    }
-                }
-            }
-        ";
-        let after = r"
-            fn foo() {
-                loop {
-                    match x {
-                        92 => $0continue,
-                    }
-                }
+        check_join_lines(
+            r"
+fn foo() {
+    loop {
+        match x {
+            92 => $0{
+                continue;
             }
-        ";
-        check_join_lines(before, after);
+        }
+    }
+}
+        ",
+            r"
+fn foo() {
+    loop {
+        match x {
+            92 => $0continue,
+        }
+    }
+}
+        ",
+        );
     }
 
     #[test]
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 6c94c26b5..b600178ee 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -22,6 +22,7 @@ mod markup;
 mod prime_caches;
 mod display;
 
+mod annotations;
 mod call_hierarchy;
 mod diagnostics;
 mod expand_macro;
@@ -63,9 +64,10 @@ use syntax::SourceFile;
 use crate::display::ToNav;
 
 pub use crate::{
+    annotations::{Annotation, AnnotationConfig, AnnotationKind},
     call_hierarchy::CallItem,
     diagnostics::{Diagnostic, DiagnosticsConfig, Fix, Severity},
-    display::navigation_target::{NavigationTarget, SymbolKind},
+    display::navigation_target::NavigationTarget,
     expand_macro::ExpandedMacro,
     file_structure::StructureNode,
     folding_ranges::{Fold, FoldKind},
@@ -73,19 +75,19 @@ pub use crate::{
     inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
     markup::Markup,
     prime_caches::PrimeCachesProgress,
-    references::{rename::RenameError, Declaration, ReferenceSearchResult},
+    references::{rename::RenameError, ReferenceSearchResult},
     runnables::{Runnable, RunnableKind, TestId},
     syntax_highlighting::{
         tags::{Highlight, HlMod, HlMods, HlPunct, HlTag},
         HlRange,
     },
 };
-pub use assists::{Assist, AssistConfig, AssistId, AssistKind};
-pub use completion::{
+pub use hir::{Documentation, Semantics};
+pub use ide_assists::{Assist, AssistConfig, AssistId, AssistKind};
+pub use ide_completion::{
     CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, ImportEdit,
     InsertTextFormat,
 };
-pub use hir::{Documentation, Semantics};
 pub use ide_db::{
     base_db::{
         Canceled, Change, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange,
@@ -93,13 +95,13 @@ pub use ide_db::{
     },
     call_info::CallInfo,
     label::Label,
-    line_index::{LineCol, LineIndex},
-    search::{FileReference, ReferenceAccess, ReferenceKind, SearchScope},
+    line_index::{LineCol, LineColUtf16, LineIndex},
+    search::{ReferenceAccess, SearchScope},
     source_change::{FileSystemEdit, SourceChange},
     symbol_index::Query,
     RootDatabase,
 };
-pub use ssr::SsrError;
+pub use ide_ssr::SsrError;
 pub use syntax::{TextRange, TextSize};
 pub use text_edit::{Indel, TextEdit};
 
@@ -369,9 +371,7 @@ impl Analysis {
         position: FilePosition,
         search_scope: Option<SearchScope>,
     ) -> Cancelable<Option<ReferenceSearchResult>> {
-        self.with_db(|db| {
-            references::find_all_refs(&Semantics::new(db), position, search_scope).map(|it| it.info)
-        })
+        self.with_db(|db| references::find_all_refs(&Semantics::new(db), position, search_scope))
     }
 
     /// Finds all methods and free functions for the file. Does not return tests!
@@ -468,7 +468,7 @@ impl Analysis {
         config: &CompletionConfig,
         position: FilePosition,
     ) -> Cancelable<Option<Vec<CompletionItem>>> {
-        self.with_db(|db| completion::completions(db, config, position).map(Into::into))
+        self.with_db(|db| ide_completion::completions(db, config, position).map(Into::into))
     }
 
     /// Resolves additional completion data at the position given.
@@ -478,15 +478,17 @@ impl Analysis {
         position: FilePosition,
         full_import_path: &str,
         imported_name: String,
+        import_for_trait_assoc_item: bool,
     ) -> Cancelable<Vec<TextEdit>> {
         Ok(self
             .with_db(|db| {
-                completion::resolve_completion_edits(
+                ide_completion::resolve_completion_edits(
                     db,
                     config,
                     position,
                     full_import_path,
                     imported_name,
+                    import_for_trait_assoc_item,
                 )
             })?
             .unwrap_or_default())
@@ -520,7 +522,7 @@ impl Analysis {
         &self,
         position: FilePosition,
         new_name: &str,
-    ) -> Cancelable<Result<RangeInfo<SourceChange>, RenameError>> {
+    ) -> Cancelable<Result<SourceChange, RenameError>> {
         self.with_db(|db| references::rename::rename(db, position, new_name))
     }
 
@@ -547,14 +549,27 @@ impl Analysis {
         selections: Vec<FileRange>,
     ) -> Cancelable<Result<SourceChange, SsrError>> {
         self.with_db(|db| {
-            let rule: ssr::SsrRule = query.parse()?;
-            let mut match_finder = ssr::MatchFinder::in_context(db, resolve_context, selections);
+            let rule: ide_ssr::SsrRule = query.parse()?;
+            let mut match_finder =
+                ide_ssr::MatchFinder::in_context(db, resolve_context, selections);
             match_finder.add_rule(rule)?;
             let edits = if parse_only { Default::default() } else { match_finder.edits() };
             Ok(SourceChange::from(edits))
         })
     }
 
+    pub fn annotations(
+        &self,
+        file_id: FileId,
+        config: AnnotationConfig,
+    ) -> Cancelable<Vec<Annotation>> {
+        self.with_db(|db| annotations::annotations(db, file_id, config))
+    }
+
+    pub fn resolve_annotation(&self, annotation: Annotation) -> Cancelable<Annotation> {
+        self.with_db(|db| annotations::resolve_annotation(db, annotation))
+    }
+
     /// Performs an operation on that may be Canceled.
     fn with_db<F, T>(&self, f: F) -> Cancelable<T>
     where
diff --git a/crates/ide/src/parent_module.rs b/crates/ide/src/parent_module.rs
index d343638fb..ddbaf22b7 100644
--- a/crates/ide/src/parent_module.rs
+++ b/crates/ide/src/parent_module.rs
@@ -63,57 +63,62 @@ pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
 
 #[cfg(test)]
 mod tests {
+    use ide_db::base_db::FileRange;
     use test_utils::mark;
 
-    use crate::fixture::{self};
+    use crate::fixture;
+
+    fn check(ra_fixture: &str) {
+        let (analysis, position, expected) = fixture::nav_target_annotation(ra_fixture);
+        let mut navs = analysis.parent_module(position).unwrap();
+        assert_eq!(navs.len(), 1);
+        let nav = navs.pop().unwrap();
+        assert_eq!(expected, FileRange { file_id: nav.file_id, range: nav.focus_or_full_range() });
+    }
 
     #[test]
     fn test_resolve_parent_module() {
-        let (analysis, pos) = fixture::position(
-            "
-            //- /lib.rs
-            mod foo;
-            //- /foo.rs
-            $0// empty
-            ",
+        check(
+            r#"
+//- /lib.rs
+mod foo;
+  //^^^
+
+//- /foo.rs
+$0// empty
+"#,
         );
-        let nav = analysis.parent_module(pos).unwrap().pop().unwrap();
-        nav.assert_match("foo Module FileId(0) 0..8");
     }
 
     #[test]
     fn test_resolve_parent_module_on_module_decl() {
         mark::check!(test_resolve_parent_module_on_module_decl);
-        let (analysis, pos) = fixture::position(
-            "
-            //- /lib.rs
-            mod foo;
-
-            //- /foo.rs
-            mod $0bar;
+        check(
+            r#"
+//- /lib.rs
+mod foo;
+  //^^^
+//- /foo.rs
+mod $0bar;
 
-            //- /foo/bar.rs
-            // empty
-            ",
+//- /foo/bar.rs
+// empty
+"#,
         );
-        let nav = analysis.parent_module(pos).unwrap().pop().unwrap();
-        nav.assert_match("foo Module FileId(0) 0..8");
     }
 
     #[test]
     fn test_resolve_parent_module_for_inline() {
-        let (analysis, pos) = fixture::position(
-            "
-            //- /lib.rs
-            mod foo {
-                mod bar {
-                    mod baz { $0 }
-                }
-            }
-            ",
+        check(
+            r#"
+//- /lib.rs
+mod foo {
+    mod bar {
+        mod baz { $0 }
+    }     //^^^
+}
+"#,
         );
-        let nav = analysis.parent_module(pos).unwrap().pop().unwrap();
-        nav.assert_match("baz Module FileId(0) 32..44");
     }
 
     #[test]
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index df9c31aef..fef70533d 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -11,171 +11,120 @@
 
 pub(crate) mod rename;
 
-use either::Either;
-use hir::Semantics;
+use hir::{PathResolution, Semantics};
 use ide_db::{
     base_db::FileId,
     defs::{Definition, NameClass, NameRefClass},
-    search::{FileReference, ReferenceAccess, ReferenceKind, SearchScope, UsageSearchResult},
+    search::{ReferenceAccess, SearchScope},
     RootDatabase,
 };
+use rustc_hash::FxHashMap;
 use syntax::{
     algo::find_node_at_offset,
     ast::{self, NameOwner},
-    AstNode, SyntaxNode, TextRange, TokenAtOffset, T,
+    match_ast, AstNode, SyntaxNode, TextRange, T,
 };
 
-use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
+use crate::{display::TryToNav, FilePosition, NavigationTarget};
 
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
-    declaration: Declaration,
-    references: UsageSearchResult,
+    pub declaration: Declaration,
+    pub references: FxHashMap<FileId, Vec<(TextRange, Option<ReferenceAccess>)>>,
 }
 
 #[derive(Debug, Clone)]
 pub struct Declaration {
     pub nav: NavigationTarget,
-    pub kind: ReferenceKind,
     pub access: Option<ReferenceAccess>,
 }
 
-impl ReferenceSearchResult {
-    pub fn declaration(&self) -> &Declaration {
-        &self.declaration
-    }
-
-    pub fn decl_target(&self) -> &NavigationTarget {
-        &self.declaration.nav
-    }
-
-    pub fn references(&self) -> &UsageSearchResult {
-        &self.references
-    }
-
-    pub fn references_with_declaration(mut self) -> UsageSearchResult {
-        let decl_ref = FileReference {
-            range: self.declaration.nav.focus_or_full_range(),
-            kind: self.declaration.kind,
-            access: self.declaration.access,
-        };
-        let file_id = self.declaration.nav.file_id;
-        self.references.references.entry(file_id).or_default().push(decl_ref);
-        self.references
-    }
-
-    /// Total number of references
-    /// At least 1 since all valid references should
-    /// Have a declaration
-    pub fn len(&self) -> usize {
-        self.references.len() + 1
-    }
-}
-
-// allow turning ReferenceSearchResult into an iterator
-// over References
-impl IntoIterator for ReferenceSearchResult {
-    type Item = (FileId, Vec<FileReference>);
-    type IntoIter = std::collections::hash_map::IntoIter<FileId, Vec<FileReference>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.references_with_declaration().into_iter()
-    }
-}
-
+// Feature: Find All References
+//
+// Shows all references of the item at the cursor location
+//
+// |===
+// | Editor  | Shortcut
+//
+// | VS Code | kbd:[Shift+Alt+F12]
+// |===
 pub(crate) fn find_all_refs(
     sema: &Semantics<RootDatabase>,
     position: FilePosition,
     search_scope: Option<SearchScope>,
-) -> Option<RangeInfo<ReferenceSearchResult>> {
+) -> Option<ReferenceSearchResult> {
     let _p = profile::span("find_all_refs");
     let syntax = sema.parse(position.file_id).syntax().clone();
 
-    let (opt_name, search_kind) = if let Some(name) =
-        get_struct_def_name_for_struct_literal_search(&sema, &syntax, position)
-    {
-        (Some(name), ReferenceKind::StructLiteral)
-    } else if let Some(name) = get_enum_def_name_for_struct_literal_search(&sema, &syntax, position)
-    {
-        (Some(name), ReferenceKind::EnumLiteral)
-    } else {
-        (
-            sema.find_node_at_offset_with_descend::<ast::Name>(&syntax, position.offset),
-            ReferenceKind::Other,
-        )
-    };
-
-    let RangeInfo { range, info: def } = find_name(&sema, &syntax, position, opt_name)?;
+    let (def, is_literal_search) =
+        if let Some(name) = get_name_of_item_declaration(&syntax, position) {
+            (NameClass::classify(sema, &name)?.referenced_or_defined(sema.db), true)
+        } else {
+            (find_def(&sema, &syntax, position)?, false)
+        };
 
     let mut usages = def.usages(sema).set_scope(search_scope).all();
-    usages
-        .references
-        .values_mut()
-        .for_each(|it| it.retain(|r| search_kind == ReferenceKind::Other || search_kind == r.kind));
-    usages.references.retain(|_, it| !it.is_empty());
-
-    let nav = def.try_to_nav(sema.db)?;
-    let decl_range = nav.focus_or_full_range();
-
-    let mut kind = ReferenceKind::Other;
-    if let Definition::Local(local) = def {
-        match local.source(sema.db).value {
-            Either::Left(pat) => {
-                if matches!(
-                    pat.syntax().parent().and_then(ast::RecordPatField::cast),
-                    Some(pat_field) if pat_field.name_ref().is_none()
-                ) {
-                    kind = ReferenceKind::FieldShorthandForLocal;
-                }
+    if is_literal_search {
+        // filter for constructor-literals
+        let refs = usages.references.values_mut();
+        match def {
+            Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(enum_))) => {
+                refs.for_each(|it| {
+                    it.retain(|reference| {
+                        reference
+                            .name
+                            .as_name_ref()
+                            .map_or(false, |name_ref| is_enum_lit_name_ref(sema, enum_, name_ref))
+                    })
+                });
+                usages.references.retain(|_, it| !it.is_empty());
             }
-            Either::Right(_) => kind = ReferenceKind::SelfParam,
+            Definition::ModuleDef(hir::ModuleDef::Adt(_))
+            | Definition::ModuleDef(hir::ModuleDef::Variant(_)) => {
+                refs.for_each(|it| {
+                    it.retain(|reference| {
+                        reference.name.as_name_ref().map_or(false, is_lit_name_ref)
+                    })
+                });
+                usages.references.retain(|_, it| !it.is_empty());
+            }
+            _ => {}
         }
-    } else if matches!(
-        def,
-        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
-    ) {
-        kind = ReferenceKind::Lifetime;
-    };
+    }
+    let nav = def.try_to_nav(sema.db)?;
+    let decl_range = nav.focus_or_full_range();
 
-    let declaration = Declaration { nav, kind, access: decl_access(&def, &syntax, decl_range) };
+    let declaration = Declaration { nav, access: decl_access(&def, &syntax, decl_range) };
+    let references = usages
+        .into_iter()
+        .map(|(file_id, refs)| {
+            (file_id, refs.into_iter().map(|file_ref| (file_ref.range, file_ref.access)).collect())
+        })
+        .collect();
 
-    Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references: usages }))
+    Some(ReferenceSearchResult { declaration, references })
 }
 
-fn find_name(
+fn find_def(
     sema: &Semantics<RootDatabase>,
     syntax: &SyntaxNode,
     position: FilePosition,
-    opt_name: Option<ast::Name>,
-) -> Option<RangeInfo<Definition>> {
-    if let Some(name) = opt_name {
-        let def = NameClass::classify(sema, &name)?.referenced_or_defined(sema.db);
-        let FileRange { range, .. } = sema.original_range(name.syntax());
-        return Some(RangeInfo::new(range, def));
-    }
-
-    let (FileRange { range, .. }, def) = if let Some(lifetime) =
-        sema.find_node_at_offset_with_descend::<ast::Lifetime>(&syntax, position.offset)
-    {
-        if let Some(def) = NameRefClass::classify_lifetime(sema, &lifetime)
-            .map(|class| NameRefClass::referenced(class, sema.db))
-        {
-            (sema.original_range(lifetime.syntax()), def)
-        } else {
-            (
-                sema.original_range(lifetime.syntax()),
-                NameClass::classify_lifetime(sema, &lifetime)?.referenced_or_defined(sema.db),
-            )
+) -> Option<Definition> {
+    let def = match sema.find_node_at_offset_with_descend(syntax, position.offset)? {
+        ast::NameLike::NameRef(name_ref) => {
+            NameRefClass::classify(sema, &name_ref)?.referenced(sema.db)
         }
-    } else {
-        let name_ref =
-            sema.find_node_at_offset_with_descend::<ast::NameRef>(&syntax, position.offset)?;
-        (
-            sema.original_range(name_ref.syntax()),
-            NameRefClass::classify(sema, &name_ref)?.referenced(sema.db),
-        )
+        ast::NameLike::Name(name) => {
+            NameClass::classify(sema, &name)?.referenced_or_defined(sema.db)
+        }
+        ast::NameLike::Lifetime(lifetime) => NameRefClass::classify_lifetime(sema, &lifetime)
+            .map(|class| class.referenced(sema.db))
+            .or_else(|| {
+                NameClass::classify_lifetime(sema, &lifetime)
+                    .map(|class| class.referenced_or_defined(sema.db))
+            })?,
     };
-    Some(RangeInfo::new(range, def))
+    Some(def)
 }
 
 fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Option<ReferenceAccess> {
@@ -197,58 +146,85 @@ fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Optio
     None
 }
 
-fn get_struct_def_name_for_struct_literal_search(
-    sema: &Semantics<RootDatabase>,
-    syntax: &SyntaxNode,
-    position: FilePosition,
-) -> Option<ast::Name> {
-    if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
-        if right.kind() != T!['{'] && right.kind() != T!['('] {
-            return None;
-        }
-        if let Some(name) =
-            sema.find_node_at_offset_with_descend::<ast::Name>(&syntax, left.text_range().start())
-        {
-            return name.syntax().ancestors().find_map(ast::Struct::cast).and_then(|l| l.name());
+fn get_name_of_item_declaration(syntax: &SyntaxNode, position: FilePosition) -> Option<ast::Name> {
+    let token = syntax.token_at_offset(position.offset).right_biased()?;
+    let kind = token.kind();
+    if kind == T![;] {
+        ast::Struct::cast(token.parent())
+            .filter(|struct_| struct_.field_list().is_none())
+            .and_then(|struct_| struct_.name())
+    } else if kind == T!['{'] {
+        match_ast! {
+            match (token.parent()) {
+                ast::RecordFieldList(rfl) => match_ast! {
+                    match (rfl.syntax().parent()?) {
+                        ast::Variant(it) => it.name(),
+                        ast::Struct(it) => it.name(),
+                        ast::Union(it) => it.name(),
+                        _ => None,
+                    }
+                },
+                ast::VariantList(vl) => ast::Enum::cast(vl.syntax().parent()?)?.name(),
+                _ => None,
+            }
         }
-        if sema
-            .find_node_at_offset_with_descend::<ast::GenericParamList>(
-                &syntax,
-                left.text_range().start(),
-            )
-            .is_some()
-        {
-            return left.ancestors().find_map(ast::Struct::cast).and_then(|l| l.name());
+    } else if kind == T!['('] {
+        let tfl = ast::TupleFieldList::cast(token.parent())?;
+        match_ast! {
+            match (tfl.syntax().parent()?) {
+                ast::Variant(it) => it.name(),
+                ast::Struct(it) => it.name(),
+                _ => None,
+            }
         }
+    } else {
+        None
     }
-    None
 }
 
-fn get_enum_def_name_for_struct_literal_search(
+fn is_enum_lit_name_ref(
     sema: &Semantics<RootDatabase>,
-    syntax: &SyntaxNode,
-    position: FilePosition,
-) -> Option<ast::Name> {
-    if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
-        if right.kind() != T!['{'] && right.kind() != T!['('] {
-            return None;
-        }
-        if let Some(name) =
-            sema.find_node_at_offset_with_descend::<ast::Name>(&syntax, left.text_range().start())
-        {
-            return name.syntax().ancestors().find_map(ast::Enum::cast).and_then(|l| l.name());
-        }
-        if sema
-            .find_node_at_offset_with_descend::<ast::GenericParamList>(
-                &syntax,
-                left.text_range().start(),
-            )
-            .is_some()
-        {
-            return left.ancestors().find_map(ast::Enum::cast).and_then(|l| l.name());
+    enum_: hir::Enum,
+    name_ref: &ast::NameRef,
+) -> bool {
+    let path_is_variant_of_enum = |path: ast::Path| {
+        matches!(
+            sema.resolve_path(&path),
+            Some(PathResolution::Def(hir::ModuleDef::Variant(variant)))
+                if variant.parent_enum(sema.db) == enum_
+        )
+    };
+    name_ref
+        .syntax()
+        .ancestors()
+        .find_map(|ancestor| {
+            match_ast! {
+                match ancestor {
+                    ast::PathExpr(path_expr) => path_expr.path().map(path_is_variant_of_enum),
+                    ast::RecordExpr(record_expr) => record_expr.path().map(path_is_variant_of_enum),
+                    _ => None,
+                }
+            }
+        })
+        .unwrap_or(false)
+}
+
+fn path_ends_with(path: Option<ast::Path>, name_ref: &ast::NameRef) -> bool {
+    path.and_then(|path| path.segment())
+        .and_then(|segment| segment.name_ref())
+        .map_or(false, |segment| segment == *name_ref)
+}
+
+fn is_lit_name_ref(name_ref: &ast::NameRef) -> bool {
+    name_ref.syntax().ancestors().find_map(|ancestor| {
+        match_ast! {
+            match ancestor {
+                ast::PathExpr(path_expr) => Some(path_ends_with(path_expr.path(), name_ref)),
+                ast::RecordExpr(record_expr) => Some(path_ends_with(record_expr.path(), name_ref)),
+                _ => None,
+            }
         }
-    }
-    None
+    }).unwrap_or(false)
 }
 
 #[cfg(test)]
@@ -275,9 +251,9 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo Struct FileId(0) 0..26 7..10 Other
+                Foo Struct FileId(0) 0..26 7..10
 
-                FileId(0) 101..104 StructLiteral
+                FileId(0) 101..104
             "#]],
         );
     }
@@ -293,10 +269,10 @@ struct Foo$0 {}
 }
 "#,
             expect![[r#"
-                Foo Struct FileId(0) 0..13 7..10 Other
+                Foo Struct FileId(0) 0..13 7..10
 
-                FileId(0) 41..44 Other
-                FileId(0) 54..57 StructLiteral
+                FileId(0) 41..44
+                FileId(0) 54..57
             "#]],
         );
     }
@@ -312,9 +288,9 @@ struct Foo<T> $0{}
 }
 "#,
             expect![[r#"
-                Foo Struct FileId(0) 0..16 7..10 Other
+                Foo Struct FileId(0) 0..16 7..10
 
-                FileId(0) 64..67 StructLiteral
+                FileId(0) 64..67
             "#]],
         );
     }
@@ -331,9 +307,30 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo Struct FileId(0) 0..16 7..10 Other
+                Foo Struct FileId(0) 0..16 7..10
+
+                FileId(0) 54..57
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_struct_literal_for_union() {
+        check(
+            r#"
+union Foo $0{
+    x: u32
+}
+
+fn main() {
+    let f: Foo;
+    f = Foo { x: 1 };
+}
+"#,
+            expect![[r#"
+                Foo Union FileId(0) 0..24 6..9
 
-                FileId(0) 54..57 StructLiteral
+                FileId(0) 62..65
             "#]],
         );
     }
@@ -344,17 +341,65 @@ fn main() {
             r#"
 enum Foo $0{
     A,
-    B,
+    B(),
+    C{},
 }
 fn main() {
     let f: Foo;
     f = Foo::A;
+    f = Foo::B();
+    f = Foo::C{};
+}
+"#,
+            expect![[r#"
+                Foo Enum FileId(0) 0..37 5..8
+
+                FileId(0) 74..77
+                FileId(0) 90..93
+                FileId(0) 108..111
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_variant_record_after_space() {
+        check(
+            r#"
+enum Foo {
+    A $0{ n: i32 },
+    B,
+}
+fn main() {
+    let f: Foo;
+    f = Foo::B;
+    f = Foo::A { n: 92 };
 }
 "#,
             expect![[r#"
-                Foo Enum FileId(0) 0..26 5..8 Other
+                A Variant FileId(0) 15..27 15..16
 
-                FileId(0) 63..66 EnumLiteral
+                FileId(0) 95..96
+            "#]],
+        );
+    }
+    #[test]
+    fn test_variant_tuple_before_paren() {
+        check(
+            r#"
+enum Foo {
+    A$0(i32),
+    B,
+}
+fn main() {
+    let f: Foo;
+    f = Foo::B;
+    f = Foo::A(92);
+}
+"#,
+            expect![[r#"
+                A Variant FileId(0) 15..21 15..16
+
+                FileId(0) 89..90
             "#]],
         );
     }
@@ -373,10 +418,10 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo Enum FileId(0) 0..26 5..8 Other
+                Foo Enum FileId(0) 0..26 5..8
 
-                FileId(0) 50..53 Other
-                FileId(0) 63..66 EnumLiteral
+                FileId(0) 50..53
+                FileId(0) 63..66
             "#]],
         );
     }
@@ -395,9 +440,9 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo Enum FileId(0) 0..32 5..8 Other
+                Foo Enum FileId(0) 0..32 5..8
 
-                FileId(0) 73..76 EnumLiteral
+                FileId(0) 73..76
             "#]],
         );
     }
@@ -416,9 +461,9 @@ fn main() {
 }
 "#,
             expect![[r#"
-                Foo Enum FileId(0) 0..33 5..8 Other
+                Foo Enum FileId(0) 0..33 5..8
 
-                FileId(0) 70..73 EnumLiteral
+                FileId(0) 70..73
             "#]],
         );
     }
@@ -439,12 +484,12 @@ fn main() {
     i = 5;
 }"#,
             expect![[r#"
-                i Local FileId(0) 20..25 24..25 Other Write
+                i Local FileId(0) 20..25 24..25 Write
 
-                FileId(0) 50..51 Other Write
-                FileId(0) 54..55 Other Read
-                FileId(0) 76..77 Other Write
-                FileId(0) 94..95 Other Write
+                FileId(0) 50..51 Write
+                FileId(0) 54..55 Read
+                FileId(0) 76..77 Write
+                FileId(0) 94..95 Write
             "#]],
         );
     }
@@ -463,10 +508,10 @@ fn bar() {
 }
 "#,
             expect![[r#"
-                spam Local FileId(0) 19..23 19..23 Other
+                spam Local FileId(0) 19..23 19..23
 
-                FileId(0) 34..38 Other Read
-                FileId(0) 41..45 Other Read
+                FileId(0) 34..38 Read
+                FileId(0) 41..45 Read
             "#]],
         );
     }
@@ -478,9 +523,9 @@ fn bar() {
 fn foo(i : u32) -> u32 { i$0 }
 "#,
             expect![[r#"
-                i ValueParam FileId(0) 7..8 7..8 Other
+                i ValueParam FileId(0) 7..8 7..8
 
-                FileId(0) 25..26 Other Read
+                FileId(0) 25..26 Read
             "#]],
         );
     }
@@ -492,9 +537,9 @@ fn foo(i : u32) -> u32 { i$0 }
 fn foo(i$0 : u32) -> u32 { i }
 "#,
             expect![[r#"
-                i ValueParam FileId(0) 7..8 7..8 Other
+                i ValueParam FileId(0) 7..8 7..8
 
-                FileId(0) 25..26 Other Read
+                FileId(0) 25..26 Read
             "#]],
         );
     }
@@ -513,9 +558,9 @@ fn main(s: Foo) {
 }
 "#,
             expect![[r#"
-                spam Field FileId(0) 17..30 21..25 Other
+                spam Field FileId(0) 17..30 21..25
 
-                FileId(0) 67..71 Other Read
+                FileId(0) 67..71 Read
             "#]],
         );
     }
@@ -530,7 +575,7 @@ impl Foo {
 }
 "#,
             expect![[r#"
-                f Function FileId(0) 27..43 30..31 Other
+                f Function FileId(0) 27..43 30..31
 
             "#]],
         );
@@ -547,7 +592,7 @@ enum Foo {
 }
 "#,
             expect![[r#"
-                B Variant FileId(0) 22..23 22..23 Other
+                B Variant FileId(0) 22..23 22..23
 
             "#]],
         );
@@ -564,7 +609,7 @@ enum Foo {
 }
 "#,
             expect![[r#"
-                field Field FileId(0) 26..35 26..31 Other
+                field Field FileId(0) 26..35 26..31
 
             "#]],
         );
@@ -605,10 +650,10 @@ fn f() {
 }
 "#,
             expect![[r#"
-                Foo Struct FileId(1) 17..51 28..31 Other
+                Foo Struct FileId(1) 17..51 28..31
 
-                FileId(0) 53..56 StructLiteral
-                FileId(2) 79..82 StructLiteral
+                FileId(0) 53..56
+                FileId(2) 79..82
             "#]],
         );
     }
@@ -635,9 +680,9 @@ pub struct Foo {
 }
 "#,
             expect![[r#"
-                foo Module FileId(1) 0..35 Other
+                foo Module FileId(1) 0..35
 
-                FileId(0) 14..17 Other
+                FileId(0) 14..17
             "#]],
         );
     }
@@ -663,10 +708,10 @@ pub(super) struct Foo$0 {
 }
 "#,
             expect![[r#"
-                Foo Struct FileId(2) 0..41 18..21 Other
+                Foo Struct FileId(2) 0..41 18..21
 
-                FileId(1) 20..23 Other
-                FileId(1) 47..50 StructLiteral
+                FileId(1) 20..23
+                FileId(1) 47..50
             "#]],
         );
     }
@@ -691,10 +736,10 @@ pub(super) struct Foo$0 {
             code,
             None,
             expect![[r#"
-                quux Function FileId(0) 19..35 26..30 Other
+                quux Function FileId(0) 19..35 26..30
 
-                FileId(1) 16..20 StructLiteral
-                FileId(2) 16..20 StructLiteral
+                FileId(1) 16..20
+                FileId(2) 16..20
             "#]],
         );
 
@@ -702,9 +747,9 @@ pub(super) struct Foo$0 {
             code,
             Some(SearchScope::single_file(FileId(2))),
             expect![[r#"
-                quux Function FileId(0) 19..35 26..30 Other
+                quux Function FileId(0) 19..35 26..30
 
-                FileId(2) 16..20 StructLiteral
+                FileId(2) 16..20
             "#]],
         );
     }
@@ -722,10 +767,10 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                m1 Macro FileId(0) 0..46 29..31 Other
+                m1 Macro FileId(0) 0..46 29..31
 
-                FileId(0) 63..65 StructLiteral
-                FileId(0) 73..75 StructLiteral
+                FileId(0) 63..65
+                FileId(0) 73..75
             "#]],
         );
     }
@@ -740,10 +785,10 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                i Local FileId(0) 19..24 23..24 Other Write
+                i Local FileId(0) 19..24 23..24 Write
 
-                FileId(0) 34..35 Other Write
-                FileId(0) 38..39 Other Read
+                FileId(0) 34..35 Write
+                FileId(0) 38..39 Read
             "#]],
         );
     }
@@ -762,10 +807,10 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                f Field FileId(0) 15..21 15..16 Other
+                f Field FileId(0) 15..21 15..16
 
-                FileId(0) 55..56 RecordFieldExprOrPat Read
-                FileId(0) 68..69 Other Write
+                FileId(0) 55..56 Read
+                FileId(0) 68..69 Write
             "#]],
         );
     }
@@ -780,9 +825,9 @@ fn foo() {
 }
 "#,
             expect![[r#"
-                i Local FileId(0) 19..20 19..20 Other
+                i Local FileId(0) 19..20 19..20
 
-                FileId(0) 26..27 Other Write
+                FileId(0) 26..27 Write
             "#]],
         );
     }
@@ -804,9 +849,9 @@ fn main() {
 }
 "#,
             expect![[r#"
-                new Function FileId(0) 54..81 61..64 Other
+                new Function FileId(0) 54..81 61..64
 
-                FileId(0) 126..129 StructLiteral
+                FileId(0) 126..129
             "#]],
         );
     }
@@ -826,10 +871,10 @@ use crate::f;
 fn g() { f(); }
 "#,
             expect![[r#"
-                f Function FileId(0) 22..31 25..26 Other
+                f Function FileId(0) 22..31 25..26
 
-                FileId(1) 11..12 Other
-                FileId(1) 24..25 StructLiteral
+                FileId(1) 11..12
+                FileId(1) 24..25
             "#]],
         );
     }
@@ -849,9 +894,9 @@ fn f(s: S) {
 }
 "#,
             expect![[r#"
-                field Field FileId(0) 15..24 15..20 Other
+                field Field FileId(0) 15..24 15..20
 
-                FileId(0) 68..73 FieldShorthandForField Read
+                FileId(0) 68..73 Read
             "#]],
         );
     }
@@ -873,9 +918,9 @@ fn f(e: En) {
 }
 "#,
             expect![[r#"
-                field Field FileId(0) 32..41 32..37 Other
+                field Field FileId(0) 32..41 32..37
 
-                FileId(0) 102..107 FieldShorthandForField Read
+                FileId(0) 102..107 Read
             "#]],
         );
     }
@@ -897,9 +942,9 @@ fn f() -> m::En {
 }
 "#,
             expect![[r#"
-                field Field FileId(0) 56..65 56..61 Other
+                field Field FileId(0) 56..65 56..61
 
-                FileId(0) 125..130 RecordFieldExprOrPat Read
+                FileId(0) 125..130 Read
             "#]],
         );
     }
@@ -922,10 +967,10 @@ impl Foo {
 }
 "#,
             expect![[r#"
-                self SelfParam FileId(0) 47..51 47..51 SelfParam
+                self SelfParam FileId(0) 47..51 47..51
 
-                FileId(0) 71..75 Other Read
-                FileId(0) 152..156 Other Read
+                FileId(0) 71..75 Read
+                FileId(0) 152..156 Read
             "#]],
         );
     }
@@ -943,9 +988,9 @@ impl Foo {
 }
 "#,
             expect![[r#"
-                self SelfParam FileId(0) 47..51 47..51 SelfParam
+                self SelfParam FileId(0) 47..51 47..51
 
-                FileId(0) 63..67 Other Read
+                FileId(0) 63..67 Read
             "#]],
         );
     }
@@ -961,7 +1006,7 @@ impl Foo {
         let mut actual = String::new();
         {
             let decl = refs.declaration;
-            format_to!(actual, "{} {:?}", decl.nav.debug_render(), decl.kind);
+            format_to!(actual, "{}", decl.nav.debug_render());
             if let Some(access) = decl.access {
                 format_to!(actual, " {:?}", access)
             }
@@ -969,9 +1014,9 @@ impl Foo {
         }
 
         for (file_id, references) in refs.references {
-            for r in references {
-                format_to!(actual, "{:?} {:?} {:?}", file_id, r.range, r.kind);
-                if let Some(access) = r.access {
+            for (range, access) in references {
+                format_to!(actual, "{:?} {:?}", file_id, range);
+                if let Some(access) = access {
                     format_to!(actual, " {:?}", access);
                 }
                 actual += "\n";
@@ -992,13 +1037,13 @@ fn foo<'a, 'b: 'a>(x: &'a$0 ()) -> &'a () where &'a (): Foo<'a> {
 }
 "#,
             expect![[r#"
-                'a LifetimeParam FileId(0) 55..57 55..57 Lifetime
+                'a LifetimeParam FileId(0) 55..57 55..57
 
-                FileId(0) 63..65 Lifetime
-                FileId(0) 71..73 Lifetime
-                FileId(0) 82..84 Lifetime
-                FileId(0) 95..97 Lifetime
-                FileId(0) 106..108 Lifetime
+                FileId(0) 63..65
+                FileId(0) 71..73
+                FileId(0) 82..84
+                FileId(0) 95..97
+                FileId(0) 106..108
             "#]],
         );
     }
@@ -1010,10 +1055,10 @@ fn foo<'a, 'b: 'a>(x: &'a$0 ()) -> &'a () where &'a (): Foo<'a> {
 type Foo<'a, T> where T: 'a$0 = &'a T;
 "#,
             expect![[r#"
-                'a LifetimeParam FileId(0) 9..11 9..11 Lifetime
+                'a LifetimeParam FileId(0) 9..11 9..11
 
-                FileId(0) 25..27 Lifetime
-                FileId(0) 31..33 Lifetime
+                FileId(0) 25..27
+                FileId(0) 31..33
             "#]],
         );
     }
@@ -1032,11 +1077,11 @@ impl<'a> Foo<'a> for &'a () {
 }
 "#,
             expect![[r#"
-                'a LifetimeParam FileId(0) 47..49 47..49 Lifetime
+                'a LifetimeParam FileId(0) 47..49 47..49
 
-                FileId(0) 55..57 Lifetime
-                FileId(0) 64..66 Lifetime
-                FileId(0) 89..91 Lifetime
+                FileId(0) 55..57
+                FileId(0) 64..66
+                FileId(0) 89..91
             "#]],
         );
     }
@@ -1052,9 +1097,9 @@ fn main() {
 }
 "#,
             expect![[r#"
-                a Local FileId(0) 59..60 59..60 Other
+                a Local FileId(0) 59..60 59..60
 
-                FileId(0) 80..81 Other Read
+                FileId(0) 80..81 Read
             "#]],
         );
     }
@@ -1070,9 +1115,9 @@ fn main() {
 }
 "#,
             expect![[r#"
-                a Local FileId(0) 59..60 59..60 Other
+                a Local FileId(0) 59..60 59..60
 
-                FileId(0) 80..81 Other Read
+                FileId(0) 80..81 Read
             "#]],
         );
     }
@@ -1091,10 +1136,10 @@ fn foo<'a>() -> &'a () {
 }
 "#,
             expect![[r#"
-                'a Label FileId(0) 29..32 29..31 Lifetime
+                'a Label FileId(0) 29..32 29..31
 
-                FileId(0) 80..82 Lifetime
-                FileId(0) 108..110 Lifetime
+                FileId(0) 80..82
+                FileId(0) 108..110
             "#]],
         );
     }
@@ -1108,9 +1153,108 @@ fn foo<const FOO$0: usize>() -> usize {
 }
 "#,
             expect![[r#"
-                FOO ConstParam FileId(0) 7..23 13..16 Other
+                FOO ConstParam FileId(0) 7..23 13..16
+
+                FileId(0) 42..45
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_find_self_ty_in_trait_def() {
+        check(
+            r#"
+trait Foo {
+    fn f() -> Self$0;
+}
+"#,
+            expect![[r#"
+                Self TypeParam FileId(0) 6..9 6..9
+
+                FileId(0) 26..30
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_self_variant_with_payload() {
+        check(
+            r#"
+enum Foo { Bar() }
+
+impl Foo {
+    fn foo(self) {
+        match self {
+            Self::Bar$0() => (),
+        }
+    }
+}
+
+"#,
+            expect![[r#"
+                Bar Variant FileId(0) 11..16 11..14
+
+                FileId(0) 89..92
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_attr_differs_from_fn_with_same_name() {
+        check(
+            r#"
+#[test]
+fn test$0() {
+    test();
+}
+"#,
+            expect![[r#"
+                test Function FileId(0) 0..33 11..15
+
+                FileId(0) 24..28
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_attr_matches_proc_macro_fn() {
+        check(
+            r#"
+#[proc_macro_attribute]
+fn my_proc_macro() {}
+
+#[my_proc_macro$0]
+fn test() {}
+"#,
+            expect![[r#"
+                my_proc_macro Function FileId(0) 0..45 27..40
+
+                FileId(0) 49..62
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_const_in_pattern() {
+        check(
+            r#"
+const A$0: i32 = 42;
+
+fn main() {
+    match A {
+        A => (),
+        _ => (),
+    }
+    if let A = A {}
+}
+"#,
+            expect![[r#"
+                A Const FileId(0) 0..18 6..7
 
-                FileId(0) 42..45 Other
+                FileId(0) 42..43
+                FileId(0) 54..55
+                FileId(0) 97..98
+                FileId(0) 101..102
             "#]],
         );
     }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 4df189c98..22ddeeae3 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -1,25 +1,23 @@
 //! FIXME: write short doc here
 use std::fmt::{self, Display};
 
-use hir::{Module, ModuleDef, ModuleSource, Semantics};
+use either::Either;
+use hir::{HasSource, InFile, Module, ModuleDef, ModuleSource, Semantics};
 use ide_db::{
-    base_db::{AnchoredPathBuf, FileId, FileRange},
+    base_db::{AnchoredPathBuf, FileId},
     defs::{Definition, NameClass, NameRefClass},
     search::FileReference,
     RootDatabase,
 };
+use stdx::never;
 use syntax::{
-    algo::find_node_at_offset,
     ast::{self, NameOwner},
-    lex_single_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, T,
+    lex_single_syntax_kind, AstNode, SyntaxKind, SyntaxNode, T,
 };
 use test_utils::mark;
 use text_edit::TextEdit;
 
-use crate::{
-    FilePosition, FileSystemEdit, RangeInfo, ReferenceKind, ReferenceSearchResult, SourceChange,
-    TextRange,
-};
+use crate::{display::TryToNav, FilePosition, FileSystemEdit, RangeInfo, SourceChange, TextRange};
 
 type RenameResult<T> = Result<T, RenameError>;
 #[derive(Debug)]
@@ -40,6 +38,8 @@ macro_rules! bail {
     ($($tokens:tt)*) => {return Err(format_err!($($tokens)*))}
 }
 
+/// Prepares a rename. The sole job of this function is to return the TextRange of the thing that is
+/// being targeted for a rename.
 pub(crate) fn prepare_rename(
     db: &RootDatabase,
     position: FilePosition,
@@ -47,20 +47,32 @@ pub(crate) fn prepare_rename(
     let sema = Semantics::new(db);
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
-    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
-        rename_mod(&sema, position, module, "dummy")
-    } else {
-        let RangeInfo { range, .. } = find_all_refs(&sema, position)?;
-        Ok(RangeInfo::new(range, SourceChange::default()))
-    }
-    .map(|info| RangeInfo::new(info.range, ()))
-}
-
+    let range = match &sema
+        .find_node_at_offset_with_descend(&syntax, position.offset)
+        .ok_or_else(|| format_err!("No references found at position"))?
+    {
+        ast::NameLike::Name(it) => it.syntax(),
+        ast::NameLike::NameRef(it) => it.syntax(),
+        ast::NameLike::Lifetime(it) => it.syntax(),
+    }
+    .text_range();
+    Ok(RangeInfo::new(range, ()))
+}
+
+// Feature: Rename
+//
+// Renames the item below the cursor and all of its references
+//
+// |===
+// | Editor  | Shortcut
+//
+// | VS Code | kbd:[F2]
+// |===
 pub(crate) fn rename(
     db: &RootDatabase,
     position: FilePosition,
     new_name: &str,
-) -> RenameResult<RangeInfo<SourceChange>> {
+) -> RenameResult<SourceChange> {
     let sema = Semantics::new(db);
     rename_with_semantics(&sema, position, new_name)
 }
@@ -69,14 +81,14 @@ pub(crate) fn rename_with_semantics(
     sema: &Semantics<RootDatabase>,
     position: FilePosition,
     new_name: &str,
-) -> RenameResult<RangeInfo<SourceChange>> {
+) -> RenameResult<SourceChange> {
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
 
-    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
-        rename_mod(&sema, position, module, new_name)
-    } else {
-        rename_reference(&sema, position, new_name)
+    let def = find_definition(sema, syntax, position)?;
+    match def {
+        Definition::ModuleDef(ModuleDef::Module(module)) => rename_mod(&sema, module, new_name),
+        def => rename_reference(sema, def, new_name),
     }
 }
 
@@ -87,12 +99,7 @@ pub(crate) fn will_rename_file(
 ) -> Option<SourceChange> {
     let sema = Semantics::new(db);
     let module = sema.to_module_def(file_id)?;
-
-    let decl = module.declaration_source(db)?;
-    let range = decl.value.name()?.syntax().text_range();
-
-    let position = FilePosition { file_id: decl.file_id.original_file(db), offset: range.start() };
-    let mut change = rename_mod(&sema, position, module, new_name_stem).ok()?.info;
+    let mut change = rename_mod(&sema, module, new_name_stem).ok()?;
     change.file_system_edits.clear();
     Some(change)
 }
@@ -124,179 +131,232 @@ fn check_identifier(new_name: &str) -> RenameResult<IdentifierKind> {
     }
 }
 
-fn find_module_at_offset(
+fn find_definition(
     sema: &Semantics<RootDatabase>,
-    position: FilePosition,
     syntax: &SyntaxNode,
-) -> Option<Module> {
-    let ident = syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::IDENT)?;
-
-    let module = match_ast! {
-        match (ident.parent()) {
-            ast::NameRef(name_ref) => {
-                match NameRefClass::classify(sema, &name_ref)? {
-                    NameRefClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
-                    _ => return None,
-                }
-            },
-            ast::Name(name) => {
-                match NameClass::classify(&sema, &name)? {
-                    NameClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
-                    _ => return None,
-                }
-            },
-            _ => return None,
-        }
-    };
-
-    Some(module)
-}
-
-fn find_all_refs(
-    sema: &Semantics<RootDatabase>,
     position: FilePosition,
-) -> RenameResult<RangeInfo<ReferenceSearchResult>> {
-    crate::references::find_all_refs(sema, position, None)
-        .ok_or_else(|| format_err!("No references found at position"))
+) -> RenameResult<Definition> {
+    match sema
+        .find_node_at_offset_with_descend(syntax, position.offset)
+        .ok_or_else(|| format_err!("No references found at position"))?
+    {
+        // renaming aliases would rename the item being aliased as the HIR doesn't track aliases yet
+        ast::NameLike::Name(name)
+            if name.syntax().parent().map_or(false, |it| ast::Rename::can_cast(it.kind())) =>
+        {
+            bail!("Renaming aliases is currently unsupported")
+        }
+        ast::NameLike::Name(name) => {
+            NameClass::classify(sema, &name).map(|class| class.referenced_or_defined(sema.db))
+        }
+        ast::NameLike::NameRef(name_ref) => {
+            NameRefClass::classify(sema, &name_ref).map(|class| class.referenced(sema.db))
+        }
+        ast::NameLike::Lifetime(lifetime) => NameRefClass::classify_lifetime(sema, &lifetime)
+            .map(|class| NameRefClass::referenced(class, sema.db))
+            .or_else(|| {
+                NameClass::classify_lifetime(sema, &lifetime)
+                    .map(|it| it.referenced_or_defined(sema.db))
+            }),
+    }
+    .ok_or_else(|| format_err!("No references found at position"))
 }
 
 fn source_edit_from_references(
-    sema: &Semantics<RootDatabase>,
+    _sema: &Semantics<RootDatabase>,
     file_id: FileId,
     references: &[FileReference],
+    def: Definition,
     new_name: &str,
 ) -> (FileId, TextEdit) {
     let mut edit = TextEdit::builder();
     for reference in references {
-        let mut replacement_text = String::new();
-        let range = match reference.kind {
-            ReferenceKind::FieldShorthandForField => {
-                mark::hit!(test_rename_struct_field_for_shorthand);
-                replacement_text.push_str(new_name);
-                replacement_text.push_str(": ");
-                TextRange::new(reference.range.start(), reference.range.start())
-            }
-            ReferenceKind::FieldShorthandForLocal => {
-                mark::hit!(test_rename_local_for_field_shorthand);
-                replacement_text.push_str(": ");
-                replacement_text.push_str(new_name);
-                TextRange::new(reference.range.end(), reference.range.end())
+        let (range, replacement) = match &reference.name {
+            // if the ranges differ then the node is inside a macro call, we can't really attempt
+            // to make special rewrites like shorthand syntax and such, so just rename the node in
+            // the macro input
+            ast::NameLike::NameRef(name_ref)
+                if name_ref.syntax().text_range() == reference.range =>
+            {
+                source_edit_from_name_ref(name_ref, new_name, def)
             }
-            ReferenceKind::RecordFieldExprOrPat => {
-                mark::hit!(test_rename_field_expr_pat);
-                replacement_text.push_str(new_name);
-                edit_text_range_for_record_field_expr_or_pat(
-                    sema,
-                    FileRange { file_id, range: reference.range },
-                    new_name,
-                )
+            ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => {
+                source_edit_from_name(name, new_name)
             }
-            _ => {
-                replacement_text.push_str(new_name);
-                reference.range
-            }
-        };
-        edit.replace(range, replacement_text);
+            _ => None,
+        }
+        .unwrap_or_else(|| (reference.range, new_name.to_string()));
+        edit.replace(range, replacement);
     }
     (file_id, edit.finish())
 }
 
-fn edit_text_range_for_record_field_expr_or_pat(
-    sema: &Semantics<RootDatabase>,
-    file_range: FileRange,
+fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> {
+    if let Some(_) = ast::RecordPatField::for_field_name(name) {
+        if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
+            return Some((
+                TextRange::empty(ident_pat.syntax().text_range().start()),
+                format!("{}: ", new_name),
+            ));
+        }
+    }
+    None
+}
+
+fn source_edit_from_name_ref(
+    name_ref: &ast::NameRef,
     new_name: &str,
-) -> TextRange {
-    let source_file = sema.parse(file_range.file_id);
-    let file_syntax = source_file.syntax();
-    let original_range = file_range.range;
-
-    syntax::algo::find_node_at_range::<ast::RecordExprField>(file_syntax, original_range)
-        .and_then(|field_expr| match field_expr.expr().and_then(|e| e.name_ref()) {
-            Some(name) if &name.to_string() == new_name => Some(field_expr.syntax().text_range()),
-            _ => None,
-        })
-        .or_else(|| {
-            syntax::algo::find_node_at_range::<ast::RecordPatField>(file_syntax, original_range)
-                .and_then(|field_pat| match field_pat.pat() {
-                    Some(ast::Pat::IdentPat(pat))
-                        if pat.name().map(|n| n.to_string()).as_deref() == Some(new_name) =>
-                    {
-                        Some(field_pat.syntax().text_range())
+    def: Definition,
+) -> Option<(TextRange, String)> {
+    if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
+        let rcf_name_ref = record_field.name_ref();
+        let rcf_expr = record_field.expr();
+        match (rcf_name_ref, rcf_expr.and_then(|it| it.name_ref())) {
+            // field: init-expr, check if we can use a field init shorthand
+            (Some(field_name), Some(init)) => {
+                if field_name == *name_ref {
+                    if init.text() == new_name {
+                        mark::hit!(test_rename_field_put_init_shorthand);
+                        // same names, we can use a shorthand here instead.
+                        // we do not want to erase attributes hence this range start
+                        let s = field_name.syntax().text_range().start();
+                        let e = record_field.syntax().text_range().end();
+                        return Some((TextRange::new(s, e), new_name.to_owned()));
                     }
-                    _ => None,
-                })
-        })
-        .unwrap_or(original_range)
+                } else if init == *name_ref {
+                    if field_name.text() == new_name {
+                        mark::hit!(test_rename_local_put_init_shorthand);
+                        // same names, we can use a shorthand here instead.
+                        // we do not want to erase attributes hence this range start
+                        let s = field_name.syntax().text_range().start();
+                        let e = record_field.syntax().text_range().end();
+                        return Some((TextRange::new(s, e), new_name.to_owned()));
+                    }
+                }
+                None
+            }
+            // init shorthand
+            // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
+            // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
+            (None, Some(_)) if matches!(def, Definition::Field(_)) => {
+                mark::hit!(test_rename_field_in_field_shorthand);
+                let s = name_ref.syntax().text_range().start();
+                Some((TextRange::empty(s), format!("{}: ", new_name)))
+            }
+            (None, Some(_)) if matches!(def, Definition::Local(_)) => {
+                mark::hit!(test_rename_local_in_field_shorthand);
+                let s = name_ref.syntax().text_range().end();
+                Some((TextRange::empty(s), format!(": {}", new_name)))
+            }
+            _ => None,
+        }
+    } else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
+        let rcf_name_ref = record_field.name_ref();
+        let rcf_pat = record_field.pat();
+        match (rcf_name_ref, rcf_pat) {
+            // field: rename
+            (Some(field_name), Some(ast::Pat::IdentPat(pat))) if field_name == *name_ref => {
+                // field name is being renamed
+                if pat.name().map_or(false, |it| it.text() == new_name) {
+                    mark::hit!(test_rename_field_put_init_shorthand_pat);
+                    // same names, we can use a shorthand here instead/
+                    // we do not want to erase attributes hence this range start
+                    let s = field_name.syntax().text_range().start();
+                    let e = record_field.syntax().text_range().end();
+                    Some((TextRange::new(s, e), pat.to_string()))
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    } else {
+        None
+    }
 }
 
 fn rename_mod(
     sema: &Semantics<RootDatabase>,
-    position: FilePosition,
     module: Module,
     new_name: &str,
-) -> RenameResult<RangeInfo<SourceChange>> {
+) -> RenameResult<SourceChange> {
     if IdentifierKind::Ident != check_identifier(new_name)? {
         bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
     }
 
     let mut source_change = SourceChange::default();
 
-    let src = module.definition_source(sema.db);
-    let file_id = src.file_id.original_file(sema.db);
-    match src.value {
-        ModuleSource::SourceFile(..) => {
-            // mod is defined in path/to/dir/mod.rs
-            let path = if module.is_mod_rs(sema.db) {
-                format!("../{}/mod.rs", new_name)
-            } else {
-                format!("{}.rs", new_name)
-            };
-            let dst = AnchoredPathBuf { anchor: file_id, path };
-            let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
-            source_change.push_file_system_edit(move_file);
-        }
-        ModuleSource::Module(..) => {}
-    }
-
-    if let Some(src) = module.declaration_source(sema.db) {
-        let file_id = src.file_id.original_file(sema.db);
-        let name = src.value.name().unwrap();
-        source_change.insert_source_edit(
-            file_id,
-            TextEdit::replace(name.syntax().text_range(), new_name.into()),
-        );
+    let InFile { file_id, value: def_source } = module.definition_source(sema.db);
+    let file_id = file_id.original_file(sema.db);
+    if let ModuleSource::SourceFile(..) = def_source {
+        // mod is defined in path/to/dir/mod.rs
+        let path = if module.is_mod_rs(sema.db) {
+            format!("../{}/mod.rs", new_name)
+        } else {
+            format!("{}.rs", new_name)
+        };
+        let dst = AnchoredPathBuf { anchor: file_id, path };
+        let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
+        source_change.push_file_system_edit(move_file);
+    }
+
+    if let Some(InFile { file_id, value: decl_source }) = module.declaration_source(sema.db) {
+        let file_id = file_id.original_file(sema.db);
+        match decl_source.name() {
+            Some(name) => source_change.insert_source_edit(
+                file_id,
+                TextEdit::replace(name.syntax().text_range(), new_name.to_string()),
+            ),
+            _ => unreachable!(),
+        };
     }
-
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
-    let ref_edits = refs.references().iter().map(|(&file_id, references)| {
-        source_edit_from_references(sema, file_id, references, new_name)
+    let def = Definition::ModuleDef(ModuleDef::Module(module));
+    let usages = def.usages(sema).all();
+    let ref_edits = usages.iter().map(|(&file_id, references)| {
+        source_edit_from_references(sema, file_id, references, def, new_name)
     });
     source_change.extend(ref_edits);
 
-    Ok(RangeInfo::new(range, source_change))
+    Ok(source_change)
 }
 
-fn rename_to_self(
-    sema: &Semantics<RootDatabase>,
-    position: FilePosition,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
-    let source_file = sema.parse(position.file_id);
-    let syn = source_file.syntax();
+fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameResult<SourceChange> {
+    if never!(local.is_self(sema.db)) {
+        bail!("rename_to_self invoked on self");
+    }
+
+    let fn_def = match local.parent(sema.db) {
+        hir::DefWithBody::Function(func) => func,
+        _ => bail!("Cannot rename non-param local to self"),
+    };
 
-    let (fn_def, fn_ast) = find_node_at_offset::<ast::Fn>(syn, position.offset)
-        .and_then(|fn_ast| sema.to_def(&fn_ast).zip(Some(fn_ast)))
-        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
-    let param_range = fn_ast
+    // FIXME: reimplement this on the hir instead
+    // as of the time of this writing params in hir don't keep their names
+    let fn_ast = fn_def
+        .source(sema.db)
+        .ok_or_else(|| format_err!("Cannot rename non-param local to self"))?
+        .value;
+
+    let first_param_range = fn_ast
         .param_list()
         .and_then(|p| p.params().next())
         .ok_or_else(|| format_err!("Method has no parameters"))?
         .syntax()
         .text_range();
-    if !param_range.contains(position.offset) {
-        bail!("Only the first parameter can be self");
+    let InFile { file_id, value: local_source } = local.source(sema.db);
+    match local_source {
+        either::Either::Left(pat)
+            if !first_param_range.contains_range(pat.syntax().text_range()) =>
+        {
+            bail!("Only the first parameter can be self");
+        }
+        _ => (),
     }
 
-    let impl_block = find_node_at_offset::<ast::Impl>(syn, position.offset)
+    let impl_block = fn_ast
+        .syntax()
+        .ancestors()
+        .find_map(|node| ast::Impl::cast(node))
         .and_then(|def| sema.to_def(&def))
         .ok_or_else(|| format_err!("No impl block found for function"))?;
     if fn_def.self_param(sema.db).is_some() {
@@ -320,25 +380,21 @@ fn rename_to_self(
         bail!("Parameter type differs from impl block type");
     }
 
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
-
+    let def = Definition::Local(local);
+    let usages = def.usages(sema).all();
     let mut source_change = SourceChange::default();
-    source_change.extend(refs.references().iter().map(|(&file_id, references)| {
-        source_edit_from_references(sema, file_id, references, "self")
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
+        source_edit_from_references(sema, file_id, references, def, "self")
     }));
     source_change.insert_source_edit(
-        position.file_id,
-        TextEdit::replace(param_range, String::from(self_param)),
+        file_id.original_file(sema.db),
+        TextEdit::replace(first_param_range, String::from(self_param)),
     );
 
-    Ok(RangeInfo::new(range, source_change))
+    Ok(source_change)
 }
 
-fn text_edit_from_self_param(
-    syn: &SyntaxNode,
-    self_param: &ast::SelfParam,
-    new_name: &str,
-) -> Option<TextEdit> {
+fn text_edit_from_self_param(self_param: &ast::SelfParam, new_name: &str) -> Option<TextEdit> {
     fn target_type_name(impl_def: &ast::Impl) -> Option<String> {
         if let Some(ast::Type::PathType(p)) = impl_def.self_ty() {
             return Some(p.path()?.segment()?.name_ref()?.text().to_string());
@@ -346,7 +402,7 @@ fn text_edit_from_self_param(
         None
     }
 
-    let impl_def = find_node_at_offset::<ast::Impl>(syn, self_param.syntax().text_range().start())?;
+    let impl_def = self_param.syntax().ancestors().find_map(|it| ast::Impl::cast(it))?;
     let type_name = target_type_name(&impl_def)?;
 
     let mut replacement_text = String::from(new_name);
@@ -363,94 +419,119 @@ fn text_edit_from_self_param(
 
 fn rename_self_to_param(
     sema: &Semantics<RootDatabase>,
-    position: FilePosition,
+    local: hir::Local,
     new_name: &str,
-    ident_kind: IdentifierKind,
-    range: TextRange,
-    refs: ReferenceSearchResult,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
-    match ident_kind {
-        IdentifierKind::Lifetime => bail!("Invalid name `{}`: not an identifier", new_name),
-        IdentifierKind::ToSelf => {
-            // no-op
-            mark::hit!(rename_self_to_self);
-            return Ok(RangeInfo::new(range, SourceChange::default()));
+    identifier_kind: IdentifierKind,
+) -> RenameResult<SourceChange> {
+    let (file_id, self_param) = match local.source(sema.db) {
+        InFile { file_id, value: Either::Right(self_param) } => (file_id, self_param),
+        _ => {
+            never!(true, "rename_self_to_param invoked on a non-self local");
+            bail!("rename_self_to_param invoked on a non-self local");
         }
-        _ => (),
-    }
-    let source_file = sema.parse(position.file_id);
-    let syn = source_file.syntax();
-
-    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)
-        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
-
-    let mut source_change = SourceChange::default();
-    if let Some(self_param) = fn_def.param_list().and_then(|it| it.self_param()) {
-        if self_param
-            .syntax()
-            .text_range()
-            .contains_range(refs.declaration().nav.focus_or_full_range())
-        {
-            let edit = text_edit_from_self_param(syn, &self_param, new_name)
-                .ok_or_else(|| format_err!("No target type found"))?;
-            source_change.insert_source_edit(position.file_id, edit);
-
-            source_change.extend(refs.references().iter().map(|(&file_id, references)| {
-                source_edit_from_references(sema, file_id, &references, new_name)
-            }));
-
-            if source_change.source_file_edits.len() > 1 && ident_kind == IdentifierKind::Underscore
-            {
-                bail!("Cannot rename reference to `_` as it is being referenced multiple times");
-            }
+    };
 
-            return Ok(RangeInfo::new(range, source_change));
-        }
+    let def = Definition::Local(local);
+    let usages = def.usages(sema).all();
+    let edit = text_edit_from_self_param(&self_param, new_name)
+        .ok_or_else(|| format_err!("No target type found"))?;
+    if usages.len() > 1 && identifier_kind == IdentifierKind::Underscore {
+        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
     }
-    Err(format_err!("Method has no self param"))
+    let mut source_change = SourceChange::default();
+    source_change.insert_source_edit(file_id.original_file(sema.db), edit);
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
+        source_edit_from_references(sema, file_id, &references, def, new_name)
+    }));
+    Ok(source_change)
 }
 
 fn rename_reference(
     sema: &Semantics<RootDatabase>,
-    position: FilePosition,
+    def: Definition,
     new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+) -> RenameResult<SourceChange> {
     let ident_kind = check_identifier(new_name)?;
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
 
-    match (ident_kind, &refs.declaration.kind) {
-        (IdentifierKind::ToSelf, ReferenceKind::Lifetime)
-        | (IdentifierKind::Underscore, ReferenceKind::Lifetime)
-        | (IdentifierKind::Ident, ReferenceKind::Lifetime) => {
+    let def_is_lbl_or_lt = matches!(
+        def,
+        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
+    );
+    match (ident_kind, def) {
+        (IdentifierKind::ToSelf, _)
+        | (IdentifierKind::Underscore, _)
+        | (IdentifierKind::Ident, _)
+            if def_is_lbl_or_lt =>
+        {
             mark::hit!(rename_not_a_lifetime_ident_ref);
             bail!("Invalid name `{}`: not a lifetime identifier", new_name)
         }
-        (IdentifierKind::Lifetime, ReferenceKind::Lifetime) => mark::hit!(rename_lifetime),
+        (IdentifierKind::Lifetime, _) if def_is_lbl_or_lt => mark::hit!(rename_lifetime),
         (IdentifierKind::Lifetime, _) => {
             mark::hit!(rename_not_an_ident_ref);
             bail!("Invalid name `{}`: not an identifier", new_name)
         }
-        (_, ReferenceKind::SelfParam) => {
+        (IdentifierKind::ToSelf, Definition::Local(local)) if local.is_self(sema.db) => {
+            // no-op
+            mark::hit!(rename_self_to_self);
+            return Ok(SourceChange::default());
+        }
+        (ident_kind, Definition::Local(local)) if local.is_self(sema.db) => {
             mark::hit!(rename_self_to_param);
-            return rename_self_to_param(sema, position, new_name, ident_kind, range, refs);
+            return rename_self_to_param(sema, local, new_name, ident_kind);
         }
-        (IdentifierKind::ToSelf, _) => {
+        (IdentifierKind::ToSelf, Definition::Local(local)) => {
             mark::hit!(rename_to_self);
-            return rename_to_self(sema, position);
-        }
-        (IdentifierKind::Underscore, _) if !refs.references.is_empty() => {
-            mark::hit!(rename_underscore_multiple);
-            bail!("Cannot rename reference to `_` as it is being referenced multiple times")
+            return rename_to_self(sema, local);
         }
+        (IdentifierKind::ToSelf, _) => bail!("Invalid name `{}`: not an identifier", new_name),
         (IdentifierKind::Ident, _) | (IdentifierKind::Underscore, _) => mark::hit!(rename_ident),
     }
 
+    let usages = def.usages(sema).all();
+    if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
+        mark::hit!(rename_underscore_multiple);
+        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
+    }
     let mut source_change = SourceChange::default();
-    source_change.extend(refs.into_iter().map(|(file_id, references)| {
-        source_edit_from_references(sema, file_id, &references, new_name)
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
+        source_edit_from_references(sema, file_id, &references, def, new_name)
     }));
 
-    Ok(RangeInfo::new(range, source_change))
+    let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
+    source_change.insert_source_edit(file_id, edit);
+    Ok(source_change)
+}
+
+fn source_edit_from_def(
+    sema: &Semantics<RootDatabase>,
+    def: Definition,
+    new_name: &str,
+) -> RenameResult<(FileId, TextEdit)> {
+    let nav = def.try_to_nav(sema.db).unwrap();
+
+    let mut replacement_text = String::new();
+    let mut repl_range = nav.focus_or_full_range();
+    if let Definition::Local(local) = def {
+        if let Either::Left(pat) = local.source(sema.db).value {
+            if matches!(
+                pat.syntax().parent().and_then(ast::RecordPatField::cast),
+                Some(pat_field) if pat_field.name_ref().is_none()
+            ) {
+                replacement_text.push_str(": ");
+                replacement_text.push_str(new_name);
+                repl_range = TextRange::new(
+                    pat.syntax().text_range().end(),
+                    pat.syntax().text_range().end(),
+                );
+            }
+        }
+    }
+    if replacement_text.is_empty() {
+        replacement_text.push_str(new_name);
+    }
+    let edit = TextEdit::replace(repl_range, replacement_text);
+    Ok((nav.file_id, edit))
 }
 
 #[cfg(test)]
@@ -472,7 +553,7 @@ mod tests {
             Ok(source_change) => {
                 let mut text_edit_builder = TextEdit::builder();
                 let mut file_id: Option<FileId> = None;
-                for edit in source_change.info.source_file_edits {
+                for edit in source_change.source_file_edits {
                     file_id = Some(edit.0);
                     for indel in edit.1.into_iter() {
                         text_edit_builder.replace(indel.delete, indel.insert);
@@ -502,10 +583,8 @@ mod tests {
 
     fn check_expect(new_name: &str, ra_fixture: &str, expect: Expect) {
         let (analysis, position) = fixture::position(ra_fixture);
-        let source_change = analysis
-            .rename(position, new_name)
-            .unwrap()
-            .expect("Expect returned RangeInfo to be Some, but was None");
+        let source_change =
+            analysis.rename(position, new_name).unwrap().expect("Expect returned a RenameError");
         expect.assert_debug_eq(&source_change)
     }
 
@@ -749,8 +828,8 @@ impl Foo {
     }
 
     #[test]
-    fn test_rename_struct_field_for_shorthand() {
-        mark::check!(test_rename_struct_field_for_shorthand);
+    fn test_rename_field_in_field_shorthand() {
+        mark::check!(test_rename_field_in_field_shorthand);
         check(
             "j",
             r#"
@@ -775,8 +854,8 @@ impl Foo {
     }
 
     #[test]
-    fn test_rename_local_for_field_shorthand() {
-        mark::check!(test_rename_local_for_field_shorthand);
+    fn test_rename_local_in_field_shorthand() {
+        mark::check!(test_rename_local_in_field_shorthand);
         check(
             "j",
             r#"
@@ -871,36 +950,33 @@ mod foo$0;
 // empty
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 4..7,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                1,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 4..7,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            1,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "foo2",
+                                    delete: 4..7,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                2,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     2,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        2,
-                                    ),
-                                    path: "foo2.rs",
-                                },
+                                path: "foo2.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -923,46 +999,43 @@ pub struct FooContent;
 use crate::foo$0::FooContent;
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 11..14,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                0,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "quux",
-                                        delete: 8..11,
-                                    },
-                                ],
-                            },
-                            FileId(
-                                2,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "quux",
-                                        delete: 11..14,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            0,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "quux",
+                                    delete: 8..11,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                        FileId(
+                            2,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "quux",
+                                    delete: 11..14,
+                                },
+                            ],
+                        },
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                1,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     1,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        1,
-                                    ),
-                                    path: "quux.rs",
-                                },
+                                path: "quux.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -979,36 +1052,33 @@ mod fo$0o;
 // empty
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 4..7,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                0,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 4..7,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            0,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "foo2",
+                                    delete: 4..7,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                1,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     1,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        1,
-                                    ),
-                                    path: "../foo2/mod.rs",
-                                },
+                                path: "../foo2/mod.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -1026,36 +1096,33 @@ mod outer { mod fo$0o; }
 // empty
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 16..19,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                0,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "bar",
-                                        delete: 16..19,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            0,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "bar",
+                                    delete: 16..19,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                1,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     1,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        1,
-                                    ),
-                                    path: "bar.rs",
-                                },
+                                path: "bar.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -1096,46 +1163,43 @@ pub mod foo$0;
 // pub fn fun() {}
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 8..11,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                0,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 27..30,
-                                    },
-                                ],
-                            },
-                            FileId(
-                                1,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 8..11,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            0,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "foo2",
+                                    delete: 27..30,
+                                },
+                            ],
+                        },
+                        FileId(
+                            1,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "foo2",
+                                    delete: 8..11,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                2,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     2,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        2,
-                                    ),
-                                    path: "foo2.rs",
-                                },
+                                path: "foo2.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -1389,8 +1453,8 @@ impl Foo {
     }
 
     #[test]
-    fn test_initializer_use_field_init_shorthand() {
-        mark::check!(test_rename_field_expr_pat);
+    fn test_rename_field_put_init_shorthand() {
+        mark::check!(test_rename_field_put_init_shorthand);
         check(
             "bar",
             r#"
@@ -1411,23 +1475,46 @@ fn foo(bar: i32) -> Foo {
     }
 
     #[test]
-    fn test_struct_field_destructure_into_shorthand() {
+    fn test_rename_local_put_init_shorthand() {
+        mark::check!(test_rename_local_put_init_shorthand);
+        check(
+            "i",
+            r#"
+struct Foo { i: i32 }
+
+fn foo(bar$0: i32) -> Foo {
+    Foo { i: bar }
+}
+"#,
+            r#"
+struct Foo { i: i32 }
+
+fn foo(i: i32) -> Foo {
+    Foo { i }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn test_struct_field_pat_into_shorthand() {
+        mark::check!(test_rename_field_put_init_shorthand_pat);
         check(
             "baz",
             r#"
 struct Foo { i$0: i32 }
 
 fn foo(foo: Foo) {
-    let Foo { i: baz } = foo;
-    let _ = baz;
+    let Foo { i: ref baz @ qux } = foo;
+    let _ = qux;
 }
 "#,
             r#"
 struct Foo { baz: i32 }
 
 fn foo(foo: Foo) {
-    let Foo { baz } = foo;
-    let _ = baz;
+    let Foo { ref baz @ qux } = foo;
+    let _ = qux;
 }
 "#,
         );
@@ -1501,6 +1588,27 @@ fn foo(Foo { i: bar }: foo) -> i32 {
     }
 
     #[test]
+    fn test_struct_field_complex_ident_pat() {
+        check(
+            "baz",
+            r#"
+struct Foo { i$0: i32 }
+
+fn foo(foo: Foo) {
+    let Foo { ref i } = foo;
+}
+"#,
+            r#"
+struct Foo { baz: i32 }
+
+fn foo(foo: Foo) {
+    let Foo { baz: ref i } = foo;
+}
+"#,
+        );
+    }
+
+    #[test]
     fn test_rename_lifetimes() {
         mark::check!(rename_lifetime);
         check(
@@ -1607,4 +1715,38 @@ impl Foo {
 "#,
         )
     }
+
+    #[test]
+    fn test_rename_field_in_pat_in_macro_doesnt_shorthand() {
+        // ideally we would be able to make this emit a short hand, but I doubt this is easily possible
+        check(
+            "baz",
+            r#"
+macro_rules! foo {
+    ($pattern:pat) => {
+        let $pattern = loop {};
+    };
+}
+struct Foo {
+    bar$0: u32,
+}
+fn foo() {
+    foo!(Foo { bar: baz });
+}
+"#,
+            r#"
+macro_rules! foo {
+    ($pattern:pat) => {
+        let $pattern = loop {};
+    };
+}
+struct Foo {
+    baz: u32,
+}
+fn foo() {
+    foo!(Foo { baz: baz });
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index f5ee7de86..1e7baed20 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -1,18 +1,19 @@
 use std::fmt;
 
-use assists::utils::test_related_attribute;
 use cfg::CfgExpr;
 use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
-use ide_db::{defs::Definition, RootDatabase};
+use ide_assists::utils::test_related_attribute;
+use ide_db::{defs::Definition, RootDatabase, SymbolKind};
 use itertools::Itertools;
 use syntax::{
-    ast::{self, AstNode, AttrsOwner, ModuleItemOwner},
+    ast::{self, AstNode, AttrsOwner},
     match_ast, SyntaxNode,
 };
+use test_utils::mark;
 
 use crate::{
     display::{ToNav, TryToNav},
-    FileId, NavigationTarget, SymbolKind,
+    FileId, NavigationTarget,
 };
 
 #[derive(Debug, Clone)]
@@ -95,27 +96,45 @@ impl Runnable {
 // |===
 pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
     let sema = Semantics::new(db);
-    let source_file = sema.parse(file_id);
-    source_file
-        .syntax()
-        .descendants()
-        .filter_map(|item| {
-            let runnable = match_ast! {
-                match item {
-                    ast::Fn(func) => {
-                        let def = sema.to_def(&func)?;
-                        runnable_fn(&sema, def)
-                    },
-                    ast::Module(it) => runnable_mod(&sema, it),
-                    _ => None,
-                }
-            };
-            runnable.or_else(|| match doc_owner_to_def(&sema, item)? {
-                Definition::ModuleDef(def) => module_def_doctest(&sema, def),
-                _ => None,
-            })
-        })
-        .collect()
+    let module = match sema.to_module_def(file_id) {
+        None => return Vec::new(),
+        Some(it) => it,
+    };
+
+    let mut res = Vec::new();
+    runnables_mod(&sema, &mut res, module);
+    res
+}
+
+fn runnables_mod(sema: &Semantics<RootDatabase>, acc: &mut Vec<Runnable>, module: hir::Module) {
+    acc.extend(module.declarations(sema.db).into_iter().filter_map(|def| {
+        let runnable = match def {
+            hir::ModuleDef::Module(it) => runnable_mod(&sema, it),
+            hir::ModuleDef::Function(it) => runnable_fn(&sema, it),
+            _ => None,
+        };
+        runnable.or_else(|| module_def_doctest(&sema, def))
+    }));
+
+    acc.extend(module.impl_defs(sema.db).into_iter().flat_map(|it| it.items(sema.db)).filter_map(
+        |def| match def {
+            hir::AssocItem::Function(it) => {
+                runnable_fn(&sema, it).or_else(|| module_def_doctest(&sema, it.into()))
+            }
+            hir::AssocItem::Const(it) => module_def_doctest(&sema, it.into()),
+            hir::AssocItem::TypeAlias(it) => module_def_doctest(&sema, it.into()),
+        },
+    ));
+
+    for def in module.declarations(sema.db) {
+        if let hir::ModuleDef::Module(submodule) = def {
+            match submodule.definition_source(sema.db).value {
+                hir::ModuleSource::Module(_) => runnables_mod(sema, acc, submodule),
+                hir::ModuleSource::SourceFile(_) => mark::hit!(dont_recurse_in_outline_submodules),
+                hir::ModuleSource::BlockExpr(_) => {} // inner items aren't runnable
+            }
+        }
+    }
 }
 
 pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) -> Option<Runnable> {
@@ -150,26 +169,16 @@ pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) ->
     Some(Runnable { nav, kind, cfg })
 }
 
-pub(crate) fn runnable_mod(
-    sema: &Semantics<RootDatabase>,
-    module: ast::Module,
-) -> Option<Runnable> {
-    if !has_test_function_or_multiple_test_submodules(&module) {
+pub(crate) fn runnable_mod(sema: &Semantics<RootDatabase>, def: hir::Module) -> Option<Runnable> {
+    if !has_test_function_or_multiple_test_submodules(sema, &def) {
         return None;
     }
-    let module_def = sema.to_def(&module)?;
+    let path =
+        def.path_to_root(sema.db).into_iter().rev().filter_map(|it| it.name(sema.db)).join("::");
 
-    let path = module_def
-        .path_to_root(sema.db)
-        .into_iter()
-        .rev()
-        .filter_map(|it| it.name(sema.db))
-        .join("::");
-
-    let def = sema.to_def(&module)?;
     let attrs = def.attrs(sema.db);
     let cfg = attrs.cfg();
-    let nav = module_def.to_nav(sema.db);
+    let nav = def.to_nav(sema.db);
     Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
 }
 
@@ -289,35 +298,37 @@ fn has_runnable_doc_test(attrs: &hir::Attrs) -> bool {
 
 // We could create runnables for modules with number_of_test_submodules > 0,
 // but that bloats the runnables for no real benefit, since all tests can be run by the submodule already
-fn has_test_function_or_multiple_test_submodules(module: &ast::Module) -> bool {
-    if let Some(item_list) = module.item_list() {
-        let mut number_of_test_submodules = 0;
-
-        for item in item_list.items() {
-            match item {
-                ast::Item::Fn(f) => {
-                    if test_related_attribute(&f).is_some() {
+fn has_test_function_or_multiple_test_submodules(
+    sema: &Semantics<RootDatabase>,
+    module: &hir::Module,
+) -> bool {
+    let mut number_of_test_submodules = 0;
+
+    for item in module.declarations(sema.db) {
+        match item {
+            hir::ModuleDef::Function(f) => {
+                if let Some(it) = f.source(sema.db) {
+                    if test_related_attribute(&it.value).is_some() {
                         return true;
                     }
                 }
-                ast::Item::Module(submodule) => {
-                    if has_test_function_or_multiple_test_submodules(&submodule) {
-                        number_of_test_submodules += 1;
-                    }
+            }
+            hir::ModuleDef::Module(submodule) => {
+                if has_test_function_or_multiple_test_submodules(sema, &submodule) {
+                    number_of_test_submodules += 1;
                 }
-                _ => (),
             }
+            _ => (),
         }
-
-        number_of_test_submodules > 1
-    } else {
-        false
     }
+
+    number_of_test_submodules > 1
 }
 
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
+    use test_utils::mark;
 
     use crate::fixture;
 
@@ -753,6 +764,21 @@ mod root_tests {
                             file_id: FileId(
                                 0,
                             ),
+                            full_range: 202..286,
+                            focus_range: 206..220,
+                            name: "nested_tests_2",
+                            kind: Module,
+                        },
+                        kind: TestMod {
+                            path: "root_tests::nested_tests_0::nested_tests_2",
+                        },
+                        cfg: None,
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
                             full_range: 84..126,
                             focus_range: 107..121,
                             name: "nested_test_11",
@@ -793,21 +819,6 @@ mod root_tests {
                             file_id: FileId(
                                 0,
                             ),
-                            full_range: 202..286,
-                            focus_range: 206..220,
-                            name: "nested_tests_2",
-                            kind: Module,
-                        },
-                        kind: TestMod {
-                            path: "root_tests::nested_tests_0::nested_tests_2",
-                        },
-                        cfg: None,
-                    },
-                    Runnable {
-                        nav: NavigationTarget {
-                            file_id: FileId(
-                                0,
-                            ),
                             full_range: 235..276,
                             focus_range: 258..271,
                             name: "nested_test_2",
@@ -982,4 +993,85 @@ impl Foo {
             "#]],
         );
     }
+
+    #[test]
+    fn test_runnables_in_macro() {
+        check(
+            r#"
+//- /lib.rs
+$0
+macro_rules! gen {
+    () => {
+        #[test]
+        fn foo_test() {
+        }
+    }
+}
+mod tests {
+    gen!();
+}
+"#,
+            &[&TEST, &TEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 90..115,
+                            focus_range: 94..99,
+                            name: "tests",
+                            kind: Module,
+                        },
+                        kind: TestMod {
+                            path: "tests",
+                        },
+                        cfg: None,
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 106..113,
+                            focus_range: 106..113,
+                            name: "foo_test",
+                            kind: Function,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "tests::foo_test",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg: None,
+                    },
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn dont_recurse_in_outline_submodules() {
+        mark::check!(dont_recurse_in_outline_submodules);
+        check(
+            r#"
+//- /lib.rs
+$0
+mod m;
+//- /m.rs
+mod tests {
+    #[test]
+    fn t() {}
+}
+"#,
+            &[],
+            expect![[r#"
+                []
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/status.rs b/crates/ide/src/status.rs
index e10d7c3a4..137c38c0d 100644
--- a/crates/ide/src/status.rs
+++ b/crates/ide/src/status.rs
@@ -38,6 +38,7 @@ pub(crate) fn status(db: &RootDatabase, file_id: Option<FileId>) -> String {
     format_to!(buf, "{}\n", syntax_tree_stats(db));
     format_to!(buf, "{} (macros)\n", macro_syntax_tree_stats(db));
     format_to!(buf, "{} total\n", memory_usage());
+    format_to!(buf, "\ncounts:\n{}", profile::countme::get_all());
 
     if let Some(file_id) = file_id {
         format_to!(buf, "\nfile info:\n");
@@ -60,6 +61,7 @@ pub(crate) fn status(db: &RootDatabase, file_id: Option<FileId>) -> String {
             None => format_to!(buf, "does not belong to any crate"),
         }
     }
+
     buf
 }
 
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index f2d4da78d..9bed329d8 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -13,7 +13,7 @@ mod html;
 mod tests;
 
 use hir::{Name, Semantics};
-use ide_db::RootDatabase;
+use ide_db::{RootDatabase, SymbolKind};
 use rustc_hash::FxHashMap;
 use syntax::{
     ast::{self, HasFormatSpecifier},
@@ -27,7 +27,7 @@ use crate::{
         format::highlight_format_string, highlights::Highlights,
         macro_rules::MacroRulesHighlighter, tags::Highlight,
     },
-    FileId, HlMod, HlTag, SymbolKind,
+    FileId, HlMod, HlTag,
 };
 
 pub(crate) use html::highlight_as_html;
@@ -72,7 +72,7 @@ pub(crate) fn highlight(
         }
     };
 
-    let mut hl = highlights::Highlights::new(range_to_highlight);
+    let mut hl = highlights::Highlights::new(root.text_range());
     traverse(&mut hl, &sema, &root, range_to_highlight, syntactic_name_ref_highlighting);
     hl.to_vec()
 }
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index a74ca844b..8c67a0863 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -1,10 +1,11 @@
 //! Syntax highlighting for format macro strings.
+use ide_db::SymbolKind;
 use syntax::{
     ast::{self, FormatSpecifier, HasFormatSpecifier},
     AstNode, AstToken, TextRange,
 };
 
-use crate::{syntax_highlighting::highlights::Highlights, HlRange, HlTag, SymbolKind};
+use crate::{syntax_highlighting::highlights::Highlights, HlRange, HlTag};
 
 pub(super) fn highlight_format_string(
     stack: &mut Highlights,
@@ -30,7 +31,7 @@ fn is_format_string(string: &ast::String) -> Option<()> {
     let parent = string.syntax().parent();
 
     let name = parent.parent().and_then(ast::MacroCall::cast)?.path()?.segment()?.name_ref()?;
-    if !matches!(name.text().as_str(), "format_args" | "format_args_nl") {
+    if !matches!(name.text(), "format_args" | "format_args_nl") {
         return None;
     }
 
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 8625ef5df..24fcbb584 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -3,7 +3,7 @@
 use hir::{AsAssocItem, Semantics, VariantDef};
 use ide_db::{
     defs::{Definition, NameClass, NameRefClass},
-    RootDatabase,
+    RootDatabase, SymbolKind,
 };
 use rustc_hash::FxHashMap;
 use syntax::{
@@ -12,7 +12,7 @@ use syntax::{
     SyntaxNode, SyntaxToken, T,
 };
 
-use crate::{syntax_highlighting::tags::HlPunct, Highlight, HlMod, HlTag, SymbolKind};
+use crate::{syntax_highlighting::tags::HlPunct, Highlight, HlMod, HlTag};
 
 pub(super) fn element(
     sema: &Semantics<RootDatabase>,
diff --git a/crates/ide/src/syntax_highlighting/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
index 281461493..8cdc3688f 100644
--- a/crates/ide/src/syntax_highlighting/inject.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -116,7 +116,7 @@ pub(super) fn doc_comment(hl: &mut Highlights, node: &SyntaxNode) {
             None => (),
         }
 
-        let line: &str = comment.text().as_str();
+        let line: &str = comment.text();
         let range = comment.syntax().text_range();
 
         let mut pos = TextSize::of(comment.prefix());
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index 8dd05ac52..3c02fdb11 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -3,7 +3,7 @@
 
 use std::{fmt, ops};
 
-use crate::SymbolKind;
+use ide_db::SymbolKind;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Highlight {
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 237149566..2f983c0b8 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -108,6 +108,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="brace">}</span>
 <span class="brace">}</span>
 
+<span class="keyword">fn</span> <span class="function declaration">str</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="function">str</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="brace">}</span>
+
 <span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable unsafe">STATIC_MUT</span><span class="colon">:</span> <span class="builtin_type">i32</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>
 
 <span class="keyword">fn</span> <span class="function declaration">foo</span><span class="angle">&lt;</span><span class="lifetime declaration">'a</span><span class="comma">,</span> <span class="type_param declaration">T</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="type_param">T</span> <span class="brace">{</span>
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index a62704c39..9d0cd1af5 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -1,9 +1,8 @@
-use std::fs;
-
 use expect_test::{expect_file, ExpectFile};
-use test_utils::project_dir;
+use ide_db::SymbolKind;
+use test_utils::{bench, bench_fixture, skip_slow_tests};
 
-use crate::{fixture, FileRange, TextRange};
+use crate::{fixture, FileRange, HlTag, TextRange};
 
 #[test]
 fn test_highlighting() {
@@ -81,6 +80,10 @@ impl FooCopy {
     }
 }
 
+fn str() {
+    str();
+}
+
 static mut STATIC_MUT: i32 = 0;
 
 fn foo<'a, T>() -> T {
@@ -224,15 +227,45 @@ fn bar() {
 }
 
 #[test]
-fn accidentally_quadratic() {
-    let file = project_dir().join("crates/syntax/test_data/accidentally_quadratic");
-    let src = fs::read_to_string(file).unwrap();
+fn benchmark_syntax_highlighting_long_struct() {
+    if skip_slow_tests() {
+        return;
+    }
 
-    let (analysis, file_id) = fixture::file(&src);
+    let fixture = bench_fixture::big_struct();
+    let (analysis, file_id) = fixture::file(&fixture);
 
-    // let t = std::time::Instant::now();
-    let _ = analysis.highlight(file_id).unwrap();
-    // eprintln!("elapsed: {:?}", t.elapsed());
+    let hash = {
+        let _pt = bench("syntax highlighting long struct");
+        analysis
+            .highlight(file_id)
+            .unwrap()
+            .iter()
+            .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
+            .count()
+    };
+    assert_eq!(hash, 2001);
+}
+
+#[test]
+fn benchmark_syntax_highlighting_parser() {
+    if skip_slow_tests() {
+        return;
+    }
+
+    let fixture = bench_fixture::glorious_old_parser();
+    let (analysis, file_id) = fixture::file(&fixture);
+
+    let hash = {
+        let _pt = bench("syntax highlighting parser");
+        analysis
+            .highlight(file_id)
+            .unwrap()
+            .iter()
+            .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Function))
+            .count()
+    };
+    assert_eq!(hash, 1629);
 }
 
 #[test]
diff --git a/crates/ide/src/syntax_tree.rs b/crates/ide/src/syntax_tree.rs
index 4c63d3023..f979ba434 100644
--- a/crates/ide/src/syntax_tree.rs
+++ b/crates/ide/src/syntax_tree.rs
@@ -100,147 +100,137 @@ fn syntax_tree_for_token(node: &SyntaxToken, text_range: TextRange) -> Option<St
 
 #[cfg(test)]
 mod tests {
-    use test_utils::assert_eq_text;
+    use expect_test::expect;
 
     use crate::fixture;
 
+    fn check(ra_fixture: &str, expect: expect_test::Expect) {
+        let (analysis, file_id) = fixture::file(ra_fixture);
+        let syn = analysis.syntax_tree(file_id, None).unwrap();
+        expect.assert_eq(&syn)
+    }
+    fn check_range(ra_fixture: &str, expect: expect_test::Expect) {
+        let (analysis, frange) = fixture::range(ra_fixture);
+        let syn = analysis.syntax_tree(frange.file_id, Some(frange.range)).unwrap();
+        expect.assert_eq(&syn)
+    }
+
     #[test]
     fn test_syntax_tree_without_range() {
         // Basic syntax
-        let (analysis, file_id) = fixture::file(r#"fn foo() {}"#);
-        let syn = analysis.syntax_tree(file_id, None).unwrap();
-
-        assert_eq_text!(
-            r#"
-[email protected]
-  [email protected]
-    [email protected] "fn"
-    [email protected] " "
-    [email protected]
-      [email protected] "foo"
-    [email protected]
-      [email protected] "("
-      [email protected] ")"
-    [email protected] " "
-    [email protected]
-      [email protected] "{"
-      [email protected] "}"
-"#
-            .trim(),
-            syn.trim()
+        check(
+            r#"fn foo() {}"#,
+            expect![[r#"
+                [email protected]
+                  [email protected]
+                    [email protected] "fn"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "foo"
+                    [email protected]
+                      [email protected] "("
+                      [email protected] ")"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "{"
+                      [email protected] "}"
+            "#]],
         );
 
-        let (analysis, file_id) = fixture::file(
+        check(
             r#"
 fn test() {
     assert!("
     fn foo() {
     }
     ", "");
-}"#
-            .trim(),
-        );
-        let syn = analysis.syntax_tree(file_id, None).unwrap();
-
-        assert_eq_text!(
-            r#"
-[email protected]
-  [email protected]
-    [email protected] "fn"
-    [email protected] " "
-    [email protected]
-      [email protected] "test"
-    [email protected]
-      [email protected] "("
-      [email protected] ")"
-    [email protected] " "
-    [email protected]
-      [email protected] "{"
-      [email protected] "\n    "
-      [email protected]
-        [email protected]
-          [email protected]
-            [email protected]
-              [email protected]
-                [email protected] "assert"
-          [email protected] "!"
-          [email protected]
-            [email protected] "("
-            [email protected] "\"\n    fn foo() {\n     ..."
-            [email protected] ","
-            [email protected] " "
-            [email protected] "\"\""
-            [email protected] ")"
-        [email protected] ";"
-      [email protected] "\n"
-      [email protected] "}"
-"#
-            .trim(),
-            syn.trim()
-        );
+}"#,
+            expect![[r#"
+                [email protected]
+                  [email protected]
+                    [email protected] "fn"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "test"
+                    [email protected]
+                      [email protected] "("
+                      [email protected] ")"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "{"
+                      [email protected] "\n    "
+                      [email protected]
+                        [email protected]
+                          [email protected]
+                            [email protected]
+                              [email protected]
+                                [email protected] "assert"
+                          [email protected] "!"
+                          [email protected]
+                            [email protected] "("
+                            [email protected] "\"\n    fn foo() {\n     ..."
+                            [email protected] ","
+                            [email protected] " "
+                            [email protected] "\"\""
+                            [email protected] ")"
+                        [email protected] ";"
+                      [email protected] "\n"
+                      [email protected] "}"
+            "#]],
+        )
     }
 
     #[test]
     fn test_syntax_tree_with_range() {
-        let (analysis, range) = fixture::range(r#"$0fn foo() {}$0"#.trim());
-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
-
-        assert_eq_text!(
-            r#"
-[email protected]
-  [email protected] "fn"
-  [email protected] " "
-  [email protected]
-    [email protected] "foo"
-  [email protected]
-    [email protected] "("
-    [email protected] ")"
-  [email protected] " "
-  [email protected]
-    [email protected] "{"
-    [email protected] "}"
-"#
-            .trim(),
-            syn.trim()
+        check_range(
+            r#"$0fn foo() {}$0"#,
+            expect![[r#"
+                [email protected]
+                  [email protected] "fn"
+                  [email protected] " "
+                  [email protected]
+                    [email protected] "foo"
+                  [email protected]
+                    [email protected] "("
+                    [email protected] ")"
+                  [email protected] " "
+                  [email protected]
+                    [email protected] "{"
+                    [email protected] "}"
+            "#]],
         );
 
-        let (analysis, range) = fixture::range(
-            r#"fn test() {
+        check_range(
+            r#"
+fn test() {
     $0assert!("
     fn foo() {
     }
     ", "");$0
-}"#
-            .trim(),
-        );
-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
-
-        assert_eq_text!(
-            r#"
-[email protected]
-  [email protected]
-    [email protected]
-      [email protected]
-        [email protected]
-          [email protected] "assert"
-    [email protected] "!"
-    [email protected]
-      [email protected] "("
-      [email protected] "\"\n    fn foo() {\n     ..."
-      [email protected] ","
-      [email protected] " "
-      [email protected] "\"\""
-      [email protected] ")"
-  [email protected] ";"
-"#
-            .trim(),
-            syn.trim()
+}"#,
+            expect![[r#"
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected]
+                        [email protected]
+                          [email protected] "assert"
+                    [email protected] "!"
+                    [email protected]
+                      [email protected] "("
+                      [email protected] "\"\n    fn foo() {\n     ..."
+                      [email protected] ","
+                      [email protected] " "
+                      [email protected] "\"\""
+                      [email protected] ")"
+                  [email protected] ";"
+            "#]],
         );
     }
 
     #[test]
     fn test_syntax_tree_inside_string() {
-        let (analysis, range) = fixture::range(
+        check_range(
             r#"fn test() {
     assert!("
 $0fn foo() {
@@ -248,33 +238,27 @@ $0fn foo() {
 fn bar() {
 }
     ", "");
-}"#
-            .trim(),
-        );
-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
-        assert_eq_text!(
-            r#"
-[email protected]
-  [email protected]
-    [email protected] "fn"
-    [email protected] " "
-    [email protected]
-      [email protected] "foo"
-    [email protected]
-      [email protected] "("
-      [email protected] ")"
-    [email protected] " "
-    [email protected]
-      [email protected] "{"
-      [email protected] "\n"
-      [email protected] "}"
-"#
-            .trim(),
-            syn.trim()
+}"#,
+            expect![[r#"
+                [email protected]
+                  [email protected]
+                    [email protected] "fn"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "foo"
+                    [email protected]
+                      [email protected] "("
+                      [email protected] ")"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "{"
+                      [email protected] "\n"
+                      [email protected] "}"
+            "#]],
         );
 
         // With a raw string
-        let (analysis, range) = fixture::range(
+        check_range(
             r###"fn test() {
     assert!(r#"
 $0fn foo() {
@@ -282,76 +266,64 @@ $0fn foo() {
 fn bar() {
 }
     "#, "");
-}"###
-                .trim(),
-        );
-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
-        assert_eq_text!(
-            r#"
-[email protected]
-  [email protected]
-    [email protected] "fn"
-    [email protected] " "
-    [email protected]
-      [email protected] "foo"
-    [email protected]
-      [email protected] "("
-      [email protected] ")"
-    [email protected] " "
-    [email protected]
-      [email protected] "{"
-      [email protected] "\n"
-      [email protected] "}"
-"#
-            .trim(),
-            syn.trim()
+}"###,
+            expect![[r#"
+                [email protected]
+                  [email protected]
+                    [email protected] "fn"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "foo"
+                    [email protected]
+                      [email protected] "("
+                      [email protected] ")"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "{"
+                      [email protected] "\n"
+                      [email protected] "}"
+            "#]],
         );
 
         // With a raw string
-        let (analysis, range) = fixture::range(
+        check_range(
             r###"fn test() {
     assert!(r$0#"
 fn foo() {
 }
 fn bar() {
 }"$0#, "");
-}"###
-                .trim(),
-        );
-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
-        assert_eq_text!(
-            r#"
-[email protected]
-  [email protected]
-    [email protected] "fn"
-    [email protected] " "
-    [email protected]
-      [email protected] "foo"
-    [email protected]
-      [email protected] "("
-      [email protected] ")"
-    [email protected] " "
-    [email protected]
-      [email protected] "{"
-      [email protected] "\n"
-      [email protected] "}"
-  [email protected] "\n"
-  [email protected]
-    [email protected] "fn"
-    [email protected] " "
-    [email protected]
-      [email protected] "bar"
-    [email protected]
-      [email protected] "("
-      [email protected] ")"
-    [email protected] " "
-    [email protected]
-      [email protected] "{"
-      [email protected] "\n"
-      [email protected] "}"
-"#
-            .trim(),
-            syn.trim()
+}"###,
+            expect![[r#"
+                [email protected]
+                  [email protected]
+                    [email protected] "fn"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "foo"
+                    [email protected]
+                      [email protected] "("
+                      [email protected] ")"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "{"
+                      [email protected] "\n"
+                      [email protected] "}"
+                  [email protected] "\n"
+                  [email protected]
+                    [email protected] "fn"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "bar"
+                    [email protected]
+                      [email protected] "("
+                      [email protected] ")"
+                    [email protected] " "
+                    [email protected]
+                      [email protected] "{"
+                      [email protected] "\n"
+                      [email protected] "}"
+            "#]],
         );
     }
 }
diff --git a/crates/ide/src/view_hir.rs b/crates/ide/src/view_hir.rs
index cfcfb7cfb..f8f3fae3d 100644
--- a/crates/ide/src/view_hir.rs
+++ b/crates/ide/src/view_hir.rs
@@ -11,7 +11,7 @@ use syntax::{algo::find_node_at_offset, ast, AstNode};
 // | VS Code | **Rust Analyzer: View Hir**
 // |===
 pub(crate) fn view_hir(db: &RootDatabase, position: FilePosition) -> String {
-    body_hir(db, position).unwrap_or("Not inside a function body".to_string())
+    body_hir(db, position).unwrap_or_else(|| "Not inside a function body".to_string())
 }
 
 fn body_hir(db: &RootDatabase, position: FilePosition) -> Option<String> {