41 files changed, 279 insertions, 2605 deletions
diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index 88f3d09d3..0e8447394 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 [dependencies]
-cov-mark = { version = "1.1", features = ["thread-local"] }
+cov-mark = "2.0.0-pre.1"
 either = "1.5.3"
 indexmap = "1.4.0"
 itertools = "0.10.0"
@@ -29,6 +29,7 @@ ide_db = { path = "../ide_db", version = "0.0.0" }
 cfg = { path = "../cfg", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
 ide_assists = { path = "../ide_assists", version = "0.0.0" }
+ide_diagnostics = { path = "../ide_diagnostics", version = "0.0.0" }
 ide_ssr = { path = "../ide_ssr", version = "0.0.0" }
 ide_completion = { path = "../ide_completion", version = "0.0.0" }
@@ -39,4 +40,3 @@ hir = { path = "../hir", version = "0.0.0" }
 [dev-dependencies]
 test_utils = { path = "../test_utils" }
 expect-test = "1.1"
-cov-mark = "1.1.0"
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
deleted file mode 100644
index d5c954b8b..000000000
--- a/crates/ide/src/diagnostics.rs
+++ /dev/null
@@ -1,722 +0,0 @@
-//! Collects diagnostics & fixits  for a single file.
-//!
-//! The tricky bit here is that diagnostics are produced by hir in terms of
-//! macro-expanded files, but we need to present them to the users in terms of
-//! original files. So we need to map the ranges.
-mod fixes;
-mod field_shorthand;
-mod unlinked_file;
-use std::cell::RefCell;
-use hir::{
-    db::AstDatabase,
-    diagnostics::{Diagnostic as _, DiagnosticCode, DiagnosticSinkBuilder},
-    InFile, Semantics,
-};
-use ide_assists::AssistResolveStrategy;
-use ide_db::{base_db::SourceDatabase, RootDatabase};
-use itertools::Itertools;
-use rustc_hash::FxHashSet;
-use syntax::{
-    ast::{self, AstNode},
-    SyntaxNode, SyntaxNodePtr, TextRange, TextSize,
-};
-use text_edit::TextEdit;
-use unlinked_file::UnlinkedFile;
-use crate::{Assist, AssistId, AssistKind, FileId, Label, SourceChange};
-use self::fixes::DiagnosticWithFixes;
-#[derive(Debug)]
-pub struct Diagnostic {
-    // pub name: Option<String>,
-    pub message: String,
-    pub range: TextRange,
-    pub severity: Severity,
-    pub fixes: Option<Vec<Assist>>,
-    pub unused: bool,
-    pub code: Option<DiagnosticCode>,
-}
-impl Diagnostic {
-    fn error(range: TextRange, message: String) -> Self {
-        Self { message, range, severity: Severity::Error, fixes: None, unused: false, code: None }
-    }
-    fn hint(range: TextRange, message: String) -> Self {
-        Self {
-            message,
-            range,
-            severity: Severity::WeakWarning,
-            fixes: None,
-            unused: false,
-            code: None,
-        }
-    }
-    fn with_fixes(self, fixes: Option<Vec<Assist>>) -> Self {
-        Self { fixes, ..self }
-    }
-    fn with_unused(self, unused: bool) -> Self {
-        Self { unused, ..self }
-    }
-    fn with_code(self, code: Option<DiagnosticCode>) -> Self {
-        Self { code, ..self }
-    }
-}
-#[derive(Debug, Copy, Clone)]
-pub enum Severity {
-    Error,
-    WeakWarning,
-}
-#[derive(Default, Debug, Clone)]
-pub struct DiagnosticsConfig {
-    pub disable_experimental: bool,
-    pub disabled: FxHashSet<String>,
-}
-pub(crate) fn diagnostics(
-    db: &RootDatabase,
-    config: &DiagnosticsConfig,
-    resolve: &AssistResolveStrategy,
-    file_id: FileId,
-) -> Vec<Diagnostic> {
-    let _p = profile::span("diagnostics");
-    let sema = Semantics::new(db);
-    let parse = db.parse(file_id);
-    let mut res = Vec::new();
-    // [#34344] Only take first 128 errors to prevent slowing down editor/ide, the number 128 is chosen arbitrarily.
-    res.extend(
-        parse
-            .errors()
-            .iter()
-            .take(128)
-            .map(|err| Diagnostic::error(err.range(), format!("Syntax Error: {}", err))),
-    );
-    for node in parse.tree().syntax().descendants() {
-        check_unnecessary_braces_in_use_statement(&mut res, file_id, &node);
-        field_shorthand::check(&mut res, file_id, &node);
-    }
-    let res = RefCell::new(res);
-    let sink_builder = DiagnosticSinkBuilder::new()
-        .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
-        })
-        .on::<hir::diagnostics::MissingFields, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
-        })
-        .on::<hir::diagnostics::MissingOkOrSomeInTailExpr, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
-        })
-        .on::<hir::diagnostics::NoSuchField, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
-        })
-        .on::<hir::diagnostics::RemoveThisSemicolon, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
-        })
-        .on::<hir::diagnostics::IncorrectCase, _>(|d| {
-            res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
-        })
-        .on::<hir::diagnostics::ReplaceFilterMapNextWithFindMap, _>(|d| {
-            res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
-        })
-        .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() {
-                return;
-            }
-            // Override severity and mark as unused.
-            res.borrow_mut().push(
-                Diagnostic::hint(
-                    sema.diagnostics_display_range(d.display_source()).range,
-                    d.message(),
-                )
-                .with_unused(true)
-                .with_code(Some(d.code())),
-            );
-        })
-        .on::<UnlinkedFile, _>(|d| {
-            // Limit diagnostic to the first few characters in the file. This matches how VS Code
-            // renders it with the full span, but on other editors, and is less invasive.
-            let range = sema.diagnostics_display_range(d.display_source()).range;
-            let range = range.intersect(TextRange::up_to(TextSize::of("..."))).unwrap_or(range);
-            // Override severity and mark as unused.
-            res.borrow_mut().push(
-                Diagnostic::hint(range, d.message())
-                    .with_fixes(d.fixes(&sema, resolve))
-                    .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.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())));
-        })
-        .on::<hir::diagnostics::UnimplementedBuiltinMacro, _>(|d| {
-            let display_range = sema.diagnostics_display_range(d.display_source()).range;
-            res.borrow_mut()
-                .push(Diagnostic::hint(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()));
-    // Finalize the `DiagnosticSink` building process.
-    let mut sink = sink_builder
-        // Diagnostics not handled above get no fix and default treatment.
-        .build(|d| {
-            res.borrow_mut().push(
-                Diagnostic::error(
-                    sema.diagnostics_display_range(d.display_source()).range,
-                    d.message(),
-                )
-                .with_code(Some(d.code())),
-            );
-        });
-    match sema.to_module_def(file_id) {
-        Some(m) => m.diagnostics(db, &mut sink),
-        None => {
-            sink.push(UnlinkedFile { file_id, node: SyntaxNodePtr::new(&parse.tree().syntax()) });
-        }
-    }
-    drop(sink);
-    res.into_inner()
-}
-fn diagnostic_with_fix<D: DiagnosticWithFixes>(
-    d: &D,
-    sema: &Semantics<RootDatabase>,
-    resolve: &AssistResolveStrategy,
-) -> Diagnostic {
-    Diagnostic::error(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fixes(d.fixes(&sema, resolve))
-        .with_code(Some(d.code()))
-}
-fn warning_with_fix<D: DiagnosticWithFixes>(
-    d: &D,
-    sema: &Semantics<RootDatabase>,
-    resolve: &AssistResolveStrategy,
-) -> Diagnostic {
-    Diagnostic::hint(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fixes(d.fixes(&sema, resolve))
-        .with_code(Some(d.code()))
-}
-fn check_unnecessary_braces_in_use_statement(
-    acc: &mut Vec<Diagnostic>,
-    file_id: FileId,
-    node: &SyntaxNode,
-) -> Option<()> {
-    let use_tree_list = ast::UseTreeList::cast(node.clone())?;
-    if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() {
-        // If there is a comment inside the bracketed `use`,
-        // assume it is a commented out module path and don't show diagnostic.
-        if use_tree_list.has_inner_comment() {
-            return Some(());
-        }
-        let use_range = use_tree_list.syntax().text_range();
-        let edit =
-            text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(&single_use_tree)
-                .unwrap_or_else(|| {
-                    let to_replace = single_use_tree.syntax().text().to_string();
-                    let mut edit_builder = TextEdit::builder();
-                    edit_builder.delete(use_range);
-                    edit_builder.insert(use_range.start(), to_replace);
-                    edit_builder.finish()
-                });
-        acc.push(
-            Diagnostic::hint(use_range, "Unnecessary braces in use statement".to_string())
-                .with_fixes(Some(vec![fix(
-                    "remove_braces",
-                    "Remove unnecessary braces",
-                    SourceChange::from_text_edit(file_id, edit),
-                    use_range,
-                )])),
-        );
-    }
-    Some(())
-}
-fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
-    single_use_tree: &ast::UseTree,
-) -> Option<TextEdit> {
-    let use_tree_list_node = single_use_tree.syntax().parent()?;
-    if single_use_tree.path()?.segment()?.self_token().is_some() {
-        let start = use_tree_list_node.prev_sibling_or_token()?.text_range().start();
-        let end = use_tree_list_node.text_range().end();
-        return Some(TextEdit::delete(TextRange::new(start, end)));
-    }
-    None
-}
-fn fix(id: &'static str, label: &str, source_change: SourceChange, target: TextRange) -> Assist {
-    let mut res = unresolved_fix(id, label, target);
-    res.source_change = Some(source_change);
-    res
-}
-fn unresolved_fix(id: &'static str, label: &str, target: TextRange) -> Assist {
-    assert!(!id.contains(' '));
-    Assist {
-        id: AssistId(id, AssistKind::QuickFix),
-        label: Label::new(label),
-        group: None,
-        target,
-        source_change: None,
-    }
-}
-#[cfg(test)]
-mod tests {
-    use expect_test::Expect;
-    use ide_assists::AssistResolveStrategy;
-    use stdx::trim_indent;
-    use test_utils::{assert_eq_text, extract_annotations};
-    use crate::{fixture, DiagnosticsConfig};
-    /// Takes a multi-file input fixture with annotated cursor positions,
-    /// and checks that:
-    ///  * a diagnostic is produced
-    ///  * the first diagnostic fix trigger range touches the input cursor position
-    ///  * that the contents of the file containing the cursor match `after` after the diagnostic fix is applied
-    #[track_caller]
-    pub(crate) fn check_fix(ra_fixture_before: &str, ra_fixture_after: &str) {
-        check_nth_fix(0, ra_fixture_before, ra_fixture_after);
-    }
-    /// Takes a multi-file input fixture with annotated cursor positions,
-    /// and checks that:
-    ///  * a diagnostic is produced
-    ///  * every diagnostic fixes trigger range touches the input cursor position
-    ///  * that the contents of the file containing the cursor match `after` after each diagnostic fix is applied
-    pub(crate) fn check_fixes(ra_fixture_before: &str, ra_fixtures_after: Vec<&str>) {
-        for (i, ra_fixture_after) in ra_fixtures_after.iter().enumerate() {
-            check_nth_fix(i, ra_fixture_before, ra_fixture_after)
-        }
-    }
-    #[track_caller]
-    fn check_nth_fix(nth: usize, ra_fixture_before: &str, ra_fixture_after: &str) {
-        let after = trim_indent(ra_fixture_after);
-        let (analysis, file_position) = fixture::position(ra_fixture_before);
-        let diagnostic = analysis
-            .diagnostics(
-                &DiagnosticsConfig::default(),
-                AssistResolveStrategy::All,
-                file_position.file_id,
-            )
-            .unwrap()
-            .pop()
-            .unwrap();
-        let fix = &diagnostic.fixes.unwrap()[nth];
-        let actual = {
-            let source_change = fix.source_change.as_ref().unwrap();
-            let file_id = *source_change.source_file_edits.keys().next().unwrap();
-            let mut actual = analysis.file_text(file_id).unwrap().to_string();
-            for edit in source_change.source_file_edits.values() {
-                edit.apply(&mut actual);
-            }
-            actual
-        };
-        assert_eq_text!(&after, &actual);
-        assert!(
-            fix.target.contains_inclusive(file_position.offset),
-            "diagnostic fix range {:?} does not touch cursor position {:?}",
-            fix.target,
-            file_position.offset
-        );
-    }
-    /// Checks that there's a diagnostic *without* fix at `$0`.
-    fn check_no_fix(ra_fixture: &str) {
-        let (analysis, file_position) = fixture::position(ra_fixture);
-        let diagnostic = analysis
-            .diagnostics(
-                &DiagnosticsConfig::default(),
-                AssistResolveStrategy::All,
-                file_position.file_id,
-            )
-            .unwrap()
-            .pop()
-            .unwrap();
-        assert!(diagnostic.fixes.is_none(), "got a fix when none was expected: {:?}", diagnostic);
-    }
-    /// Takes a multi-file input fixture with annotated cursor position and checks that no diagnostics
-    /// apply to the file containing the cursor.
-    pub(crate) fn check_no_diagnostics(ra_fixture: &str) {
-        let (analysis, files) = fixture::files(ra_fixture);
-        let diagnostics = files
-            .into_iter()
-            .flat_map(|file_id| {
-                analysis
-                    .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
-                    .unwrap()
-            })
-            .collect::<Vec<_>>();
-        assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
-    }
-    pub(crate) fn check_expect(ra_fixture: &str, expect: Expect) {
-        let (analysis, file_id) = fixture::file(ra_fixture);
-        let diagnostics = analysis
-            .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
-            .unwrap();
-        expect.assert_debug_eq(&diagnostics)
-    }
-    pub(crate) fn check_diagnostics(ra_fixture: &str) {
-        let (analysis, file_id) = fixture::file(ra_fixture);
-        let diagnostics = analysis
-            .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
-            .unwrap();
-        let expected = extract_annotations(&*analysis.file_text(file_id).unwrap());
-        let actual = diagnostics.into_iter().map(|d| (d.range, d.message)).collect::<Vec<_>>();
-        assert_eq!(expected, actual);
-    }
-    #[test]
-    fn test_unresolved_macro_range() {
-        check_diagnostics(
-            r#"
-foo::bar!(92);
-   //^^^ unresolved macro `foo::bar!`
-"#,
-        );
-    }
-    #[test]
-    fn unresolved_import_in_use_tree() {
-        // Only the relevant part of a nested `use` item should be highlighted.
-        check_diagnostics(
-            r#"
-use does_exist::{Exists, DoesntExist};
-                       //^^^^^^^^^^^ unresolved import
-use {does_not_exist::*, does_exist};
-   //^^^^^^^^^^^^^^^^^ unresolved import
-use does_not_exist::{
-    a,
-  //^ unresolved import
-    b,
-  //^ unresolved import
-    c,
-  //^ unresolved import
-};
-mod does_exist {
-    pub struct Exists;
-}
-"#,
-        );
-    }
-    #[test]
-    fn range_mapping_out_of_macros() {
-        // FIXME: this is very wrong, but somewhat tricky to fix.
-        check_fix(
-            r#"
-fn some() {}
-fn items() {}
-fn here() {}
-macro_rules! id { ($($tt:tt)*) => { $($tt)*}; }
-fn main() {
-    let _x = id![Foo { a: $042 }];
-}
-pub struct Foo { pub a: i32, pub b: i32 }
-"#,
-            r#"
-fn some(, b: () ) {}
-fn items() {}
-fn here() {}
-macro_rules! id { ($($tt:tt)*) => { $($tt)*}; }
-fn main() {
-    let _x = id![Foo { a: 42 }];
-}
-pub struct Foo { pub a: i32, pub b: i32 }
-"#,
-        );
-    }
-    #[test]
-    fn test_check_unnecessary_braces_in_use_statement() {
-        check_no_diagnostics(
-            r#"
-use a;
-use a::{c, d::e};
-mod a {
-    mod c {}
-    mod d {
-        mod e {}
-    }
-}
-"#,
-        );
-        check_no_diagnostics(
-            r#"
-use a;
-use a::{
-    c,
-    // d::e
-};
-mod a {
-    mod c {}
-    mod d {
-        mod e {}
-    }
-}
-"#,
-        );
-        check_fix(
-            r"
-            mod b {}
-            use {$0b};
-            ",
-            r"
-            mod b {}
-            use b;
-            ",
-        );
-        check_fix(
-            r"
-            mod b {}
-            use {b$0};
-            ",
-            r"
-            mod b {}
-            use b;
-            ",
-        );
-        check_fix(
-            r"
-            mod a { mod c {} }
-            use a::{c$0};
-            ",
-            r"
-            mod a { mod c {} }
-            use a::c;
-            ",
-        );
-        check_fix(
-            r"
-            mod a {}
-            use a::{self$0};
-            ",
-            r"
-            mod a {}
-            use a;
-            ",
-        );
-        check_fix(
-            r"
-            mod a { mod c {} mod d { mod e {} } }
-            use a::{c, d::{e$0}};
-            ",
-            r"
-            mod a { mod c {} mod d { mod e {} } }
-            use a::{c, d::e};
-            ",
-        );
-    }
-    #[test]
-    fn test_disabled_diagnostics() {
-        let mut config = DiagnosticsConfig::default();
-        config.disabled.insert("unresolved-module".into());
-        let (analysis, file_id) = fixture::file(r#"mod foo;"#);
-        let diagnostics =
-            analysis.diagnostics(&config, AssistResolveStrategy::All, file_id).unwrap();
-        assert!(diagnostics.is_empty());
-        let diagnostics = analysis
-            .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
-            .unwrap();
-        assert!(!diagnostics.is_empty());
-    }
-    #[test]
-    fn unlinked_file_prepend_first_item() {
-        cov_mark::check!(unlinked_file_prepend_before_first_item);
-        // Only tests the first one for `pub mod` since the rest are the same
-        check_fixes(
-            r#"
-//- /main.rs
-fn f() {}
-//- /foo.rs
-$0
-"#,
-            vec![
-                r#"
-mod foo;
-fn f() {}
-"#,
-                r#"
-pub mod foo;
-fn f() {}
-"#,
-            ],
-        );
-    }
-    #[test]
-    fn unlinked_file_append_mod() {
-        cov_mark::check!(unlinked_file_append_to_existing_mods);
-        check_fix(
-            r#"
-//- /main.rs
-//! Comment on top
-mod preexisting;
-mod preexisting2;
-struct S;
-mod preexisting_bottom;)
-//- /foo.rs
-$0
-"#,
-            r#"
-//! Comment on top
-mod preexisting;
-mod preexisting2;
-mod foo;
-struct S;
-mod preexisting_bottom;)
-"#,
-        );
-    }
-    #[test]
-    fn unlinked_file_insert_in_empty_file() {
-        cov_mark::check!(unlinked_file_empty_file);
-        check_fix(
-            r#"
-//- /main.rs
-//- /foo.rs
-$0
-"#,
-            r#"
-mod foo;
-"#,
-        );
-    }
-    #[test]
-    fn unlinked_file_old_style_modrs() {
-        check_fix(
-            r#"
-//- /main.rs
-mod submod;
-//- /submod/mod.rs
-// in mod.rs
-//- /submod/foo.rs
-$0
-"#,
-            r#"
-// in mod.rs
-mod foo;
-"#,
-        );
-    }
-    #[test]
-    fn unlinked_file_new_style_mod() {
-        check_fix(
-            r#"
-//- /main.rs
-mod submod;
-//- /submod.rs
-//- /submod/foo.rs
-$0
-"#,
-            r#"
-mod foo;
-"#,
-        );
-    }
-    #[test]
-    fn unlinked_file_with_cfg_off() {
-        cov_mark::check!(unlinked_file_skip_fix_when_mod_already_exists);
-        check_no_fix(
-            r#"
-//- /main.rs
-#[cfg(never)]
-mod foo;
-//- /foo.rs
-$0
-"#,
-        );
-    }
-    #[test]
-    fn unlinked_file_with_cfg_on() {
-        check_no_diagnostics(
-            r#"
-//- /main.rs
-#[cfg(not(never))]
-mod foo;
-//- /foo.rs
-"#,
-        );
-    }
-}
diff --git a/crates/ide/src/diagnostics/field_shorthand.rs b/crates/ide/src/diagnostics/field_shorthand.rs
deleted file mode 100644
index 01bd2dba6..000000000
--- a/crates/ide/src/diagnostics/field_shorthand.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-//! Suggests shortening `Foo { field: field }` to `Foo { field }` in both
-//! expressions and patterns.
-use ide_db::{base_db::FileId, source_change::SourceChange};
-use syntax::{ast, match_ast, AstNode, SyntaxNode};
-use text_edit::TextEdit;
-use crate::{diagnostics::fix, Diagnostic};
-pub(super) fn check(acc: &mut Vec<Diagnostic>, file_id: FileId, node: &SyntaxNode) {
-    match_ast! {
-        match node {
-            ast::RecordExpr(it) => check_expr_field_shorthand(acc, file_id, it),
-            ast::RecordPat(it) => check_pat_field_shorthand(acc, file_id, it),
-            _ => ()
-        }
-    };
-}
-fn check_expr_field_shorthand(
-    acc: &mut Vec<Diagnostic>,
-    file_id: FileId,
-    record_expr: ast::RecordExpr,
-) {
-    let record_field_list = match record_expr.record_expr_field_list() {
-        Some(it) => it,
-        None => return,
-    };
-    for record_field in record_field_list.fields() {
-        let (name_ref, expr) = match record_field.name_ref().zip(record_field.expr()) {
-            Some(it) => it,
-            None => continue,
-        };
-        let field_name = name_ref.syntax().text().to_string();
-        let field_expr = expr.syntax().text().to_string();
-        let field_name_is_tup_index = name_ref.as_tuple_field().is_some();
-        if field_name != field_expr || field_name_is_tup_index {
-            continue;
-        }
-        let mut edit_builder = TextEdit::builder();
-        edit_builder.delete(record_field.syntax().text_range());
-        edit_builder.insert(record_field.syntax().text_range().start(), field_name);
-        let edit = edit_builder.finish();
-        let field_range = record_field.syntax().text_range();
-        acc.push(
-            Diagnostic::hint(field_range, "Shorthand struct initialization".to_string())
-                .with_fixes(Some(vec![fix(
-                    "use_expr_field_shorthand",
-                    "Use struct shorthand initialization",
-                    SourceChange::from_text_edit(file_id, edit),
-                    field_range,
-                )])),
-        );
-    }
-}
-fn check_pat_field_shorthand(
-    acc: &mut Vec<Diagnostic>,
-    file_id: FileId,
-    record_pat: ast::RecordPat,
-) {
-    let record_pat_field_list = match record_pat.record_pat_field_list() {
-        Some(it) => it,
-        None => return,
-    };
-    for record_pat_field in record_pat_field_list.fields() {
-        let (name_ref, pat) = match record_pat_field.name_ref().zip(record_pat_field.pat()) {
-            Some(it) => it,
-            None => continue,
-        };
-        let field_name = name_ref.syntax().text().to_string();
-        let field_pat = pat.syntax().text().to_string();
-        let field_name_is_tup_index = name_ref.as_tuple_field().is_some();
-        if field_name != field_pat || field_name_is_tup_index {
-            continue;
-        }
-        let mut edit_builder = TextEdit::builder();
-        edit_builder.delete(record_pat_field.syntax().text_range());
-        edit_builder.insert(record_pat_field.syntax().text_range().start(), field_name);
-        let edit = edit_builder.finish();
-        let field_range = record_pat_field.syntax().text_range();
-        acc.push(Diagnostic::hint(field_range, "Shorthand struct pattern".to_string()).with_fixes(
-            Some(vec![fix(
-                "use_pat_field_shorthand",
-                "Use struct field shorthand",
-                SourceChange::from_text_edit(file_id, edit),
-                field_range,
-            )]),
-        ));
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::diagnostics::tests::{check_fix, check_no_diagnostics};
-    #[test]
-    fn test_check_expr_field_shorthand() {
-        check_no_diagnostics(
-            r#"
-struct A { a: &'static str }
-fn main() { A { a: "hello" } }
-"#,
-        );
-        check_no_diagnostics(
-            r#"
-struct A(usize);
-fn main() { A { 0: 0 } }
-"#,
-        );
-        check_fix(
-            r#"
-struct A { a: &'static str }
-fn main() {
-    let a = "haha";
-    A { a$0: a }
-}
-"#,
-            r#"
-struct A { a: &'static str }
-fn main() {
-    let a = "haha";
-    A { a }
-}
-"#,
-        );
-        check_fix(
-            r#"
-struct A { a: &'static str, b: &'static str }
-fn main() {
-    let a = "haha";
-    let b = "bb";
-    A { a$0: a, b }
-}
-"#,
-            r#"
-struct A { a: &'static str, b: &'static str }
-fn main() {
-    let a = "haha";
-    let b = "bb";
-    A { a, b }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_check_pat_field_shorthand() {
-        check_no_diagnostics(
-            r#"
-struct A { a: &'static str }
-fn f(a: A) { let A { a: hello } = a; }
-"#,
-        );
-        check_no_diagnostics(
-            r#"
-struct A(usize);
-fn f(a: A) { let A { 0: 0 } = a; }
-"#,
-        );
-        check_fix(
-            r#"
-struct A { a: &'static str }
-fn f(a: A) {
-    let A { a$0: a } = a;
-}
-"#,
-            r#"
-struct A { a: &'static str }
-fn f(a: A) {
-    let A { a } = a;
-}
-"#,
-        );
-        check_fix(
-            r#"
-struct A { a: &'static str, b: &'static str }
-fn f(a: A) {
-    let A { a$0: a, b } = a;
-}
-"#,
-            r#"
-struct A { a: &'static str, b: &'static str }
-fn f(a: A) {
-    let A { a, b } = a;
-}
-"#,
-        );
-    }
-}
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
deleted file mode 100644
index 258ac6974..000000000
--- a/crates/ide/src/diagnostics/fixes.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//! Provides a way to attach fixes to the diagnostics.
-//! The same module also has all curret custom fixes for the diagnostics implemented.
-mod change_case;
-mod create_field;
-mod fill_missing_fields;
-mod remove_semicolon;
-mod replace_with_find_map;
-mod unresolved_module;
-mod wrap_tail_expr;
-use hir::{diagnostics::Diagnostic, Semantics};
-use ide_assists::AssistResolveStrategy;
-use ide_db::RootDatabase;
-use crate::Assist;
-/// A [Diagnostic] that potentially has some fixes available.
-///
-/// [Diagnostic]: hir::diagnostics::Diagnostic
-pub(crate) trait DiagnosticWithFixes: Diagnostic {
-    /// `resolve` determines if the diagnostic should fill in the `edit` field
-    /// of the assist.
-    ///
-    /// If `resolve` is false, the edit will be computed later, on demand, and
-    /// can be omitted.
-    fn fixes(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Vec<Assist>>;
-}
diff --git a/crates/ide/src/diagnostics/fixes/change_case.rs b/crates/ide/src/diagnostics/fixes/change_case.rs
deleted file mode 100644
index 42be3375f..000000000
--- a/crates/ide/src/diagnostics/fixes/change_case.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-use hir::{db::AstDatabase, diagnostics::IncorrectCase, InFile, Semantics};
-use ide_assists::{Assist, AssistResolveStrategy};
-use ide_db::{base_db::FilePosition, RootDatabase};
-use syntax::AstNode;
-use crate::{
-    diagnostics::{unresolved_fix, DiagnosticWithFixes},
-    references::rename::rename_with_semantics,
-};
-impl DiagnosticWithFixes for IncorrectCase {
-    fn fixes(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        resolve: &AssistResolveStrategy,
-    ) -> Option<Vec<Assist>> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        let name_node = self.ident.to_node(&root);
-        let name_node = InFile::new(self.file, name_node.syntax());
-        let frange = name_node.original_file_range(sema.db);
-        let file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
-        let label = format!("Rename to {}", self.suggested_text);
-        let mut res = unresolved_fix("change_case", &label, frange.range);
-        if resolve.should_resolve(&res.id) {
-            let source_change = rename_with_semantics(sema, file_position, &self.suggested_text);
-            res.source_change = Some(source_change.ok().unwrap_or_default());
-        }
-        Some(vec![res])
-    }
-}
-#[cfg(test)]
-mod change_case {
-    use crate::{
-        diagnostics::tests::{check_fix, check_no_diagnostics},
-        fixture, AssistResolveStrategy, DiagnosticsConfig,
-    };
-    #[test]
-    fn test_rename_incorrect_case() {
-        check_fix(
-            r#"
-pub struct test_struct$0 { one: i32 }
-pub fn some_fn(val: test_struct) -> test_struct {
-    test_struct { one: val.one + 1 }
-}
-"#,
-            r#"
-pub struct TestStruct { one: i32 }
-pub fn some_fn(val: TestStruct) -> TestStruct {
-    TestStruct { one: val.one + 1 }
-}
-"#,
-        );
-        check_fix(
-            r#"
-pub fn some_fn(NonSnakeCase$0: u8) -> u8 {
-    NonSnakeCase
-}
-"#,
-            r#"
-pub fn some_fn(non_snake_case: u8) -> u8 {
-    non_snake_case
-}
-"#,
-        );
-        check_fix(
-            r#"
-pub fn SomeFn$0(val: u8) -> u8 {
-    if val != 0 { SomeFn(val - 1) } else { val }
-}
-"#,
-            r#"
-pub fn some_fn(val: u8) -> u8 {
-    if val != 0 { some_fn(val - 1) } else { val }
-}
-"#,
-        );
-        check_fix(
-            r#"
-fn some_fn() {
-    let whatAWeird_Formatting$0 = 10;
-    another_func(whatAWeird_Formatting);
-}
-"#,
-            r#"
-fn some_fn() {
-    let what_a_weird_formatting = 10;
-    another_func(what_a_weird_formatting);
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_uppercase_const_no_diagnostics() {
-        check_no_diagnostics(
-            r#"
-fn foo() {
-    const ANOTHER_ITEM$0: &str = "some_item";
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_rename_incorrect_case_struct_method() {
-        check_fix(
-            r#"
-pub struct TestStruct;
-impl TestStruct {
-    pub fn SomeFn$0() -> TestStruct {
-        TestStruct
-    }
-}
-"#,
-            r#"
-pub struct TestStruct;
-impl TestStruct {
-    pub fn some_fn() -> TestStruct {
-        TestStruct
-    }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_single_incorrect_case_diagnostic_in_function_name_issue_6970() {
-        let input = r#"fn FOO$0() {}"#;
-        let expected = r#"fn foo() {}"#;
-        let (analysis, file_position) = fixture::position(input);
-        let diagnostics = analysis
-            .diagnostics(
-                &DiagnosticsConfig::default(),
-                AssistResolveStrategy::All,
-                file_position.file_id,
-            )
-            .unwrap();
-        assert_eq!(diagnostics.len(), 1);
-        check_fix(input, expected);
-    }
-}
diff --git a/crates/ide/src/diagnostics/fixes/create_field.rs b/crates/ide/src/diagnostics/fixes/create_field.rs
deleted file mode 100644
index a5f457dce..000000000
--- a/crates/ide/src/diagnostics/fixes/create_field.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-use hir::{db::AstDatabase, diagnostics::NoSuchField, HasSource, HirDisplay, Semantics};
-use ide_db::{base_db::FileId, source_change::SourceChange, RootDatabase};
-use syntax::{
-    ast::{self, edit::IndentLevel, make},
-    AstNode,
-};
-use text_edit::TextEdit;
-use crate::{
-    diagnostics::{fix, DiagnosticWithFixes},
-    Assist, AssistResolveStrategy,
-};
-impl DiagnosticWithFixes for NoSuchField {
-    fn fixes(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Vec<Assist>> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        missing_record_expr_field_fixes(
-            &sema,
-            self.file.original_file(sema.db),
-            &self.field.to_node(&root),
-        )
-    }
-}
-fn missing_record_expr_field_fixes(
-    sema: &Semantics<RootDatabase>,
-    usage_file_id: FileId,
-    record_expr_field: &ast::RecordExprField,
-) -> Option<Vec<Assist>> {
-    let record_lit = ast::RecordExpr::cast(record_expr_field.syntax().parent()?.parent()?)?;
-    let def_id = sema.resolve_variant(record_lit)?;
-    let module;
-    let def_file_id;
-    let record_fields = match def_id {
-        hir::VariantDef::Struct(s) => {
-            module = s.module(sema.db);
-            let source = s.source(sema.db)?;
-            def_file_id = source.file_id;
-            let fields = source.value.field_list()?;
-            record_field_list(fields)?
-        }
-        hir::VariantDef::Union(u) => {
-            module = u.module(sema.db);
-            let source = u.source(sema.db)?;
-            def_file_id = source.file_id;
-            source.value.record_field_list()?
-        }
-        hir::VariantDef::Variant(e) => {
-            module = e.module(sema.db);
-            let source = e.source(sema.db)?;
-            def_file_id = source.file_id;
-            let fields = source.value.field_list()?;
-            record_field_list(fields)?
-        }
-    };
-    let def_file_id = def_file_id.original_file(sema.db);
-    let new_field_type = sema.type_of_expr(&record_expr_field.expr()?)?;
-    if new_field_type.is_unknown() {
-        return None;
-    }
-    let new_field = make::record_field(
-        None,
-        make::name(&record_expr_field.field_name()?.text()),
-        make::ty(&new_field_type.display_source_code(sema.db, module.into()).ok()?),
-    );
-    let last_field = record_fields.fields().last()?;
-    let last_field_syntax = last_field.syntax();
-    let indent = IndentLevel::from_node(last_field_syntax);
-    let mut new_field = new_field.to_string();
-    if usage_file_id != def_file_id {
-        new_field = format!("pub(crate) {}", new_field);
-    }
-    new_field = format!("\n{}{}", indent, new_field);
-    let needs_comma = !last_field_syntax.to_string().ends_with(',');
-    if needs_comma {
-        new_field = format!(",{}", new_field);
-    }
-    let source_change = SourceChange::from_text_edit(
-        def_file_id,
-        TextEdit::insert(last_field_syntax.text_range().end(), new_field),
-    );
-    return Some(vec![fix(
-        "create_field",
-        "Create field",
-        source_change,
-        record_expr_field.syntax().text_range(),
-    )]);
-    fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> {
-        match field_def_list {
-            ast::FieldList::RecordFieldList(it) => Some(it),
-            ast::FieldList::TupleFieldList(_) => None,
-        }
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::diagnostics::tests::check_fix;
-    #[test]
-    fn test_add_field_from_usage() {
-        check_fix(
-            r"
-fn main() {
-    Foo { bar: 3, baz$0: false};
-}
-struct Foo {
-    bar: i32
-}
-",
-            r"
-fn main() {
-    Foo { bar: 3, baz: false};
-}
-struct Foo {
-    bar: i32,
-    baz: bool
-}
-",
-        )
-    }
-    #[test]
-    fn test_add_field_in_other_file_from_usage() {
-        check_fix(
-            r#"
-//- /main.rs
-mod foo;
-fn main() {
-    foo::Foo { bar: 3, $0baz: false};
-}
-//- /foo.rs
-struct Foo {
-    bar: i32
-}
-"#,
-            r#"
-struct Foo {
-    bar: i32,
-    pub(crate) baz: bool
-}
-"#,
-        )
-    }
-}
diff --git a/crates/ide/src/diagnostics/fixes/fill_missing_fields.rs b/crates/ide/src/diagnostics/fixes/fill_missing_fields.rs
deleted file mode 100644
index b5dd64c08..000000000
--- a/crates/ide/src/diagnostics/fixes/fill_missing_fields.rs
+++ /dev/null
@@ -1,217 +0,0 @@
-use hir::{db::AstDatabase, diagnostics::MissingFields, Semantics};
-use ide_assists::AssistResolveStrategy;
-use ide_db::{source_change::SourceChange, RootDatabase};
-use syntax::{algo, ast::make, AstNode};
-use text_edit::TextEdit;
-use crate::{
-    diagnostics::{fix, fixes::DiagnosticWithFixes},
-    Assist,
-};
-impl DiagnosticWithFixes for MissingFields {
-    fn fixes(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Vec<Assist>> {
-        // Note that although we could add a diagnostics to
-        // fill the missing tuple field, e.g :
-        // `struct A(usize);`
-        // `let a = A { 0: () }`
-        // but it is uncommon usage and it should not be encouraged.
-        if self.missed_fields.iter().any(|it| it.as_tuple_index().is_some()) {
-            return None;
-        }
-        let root = sema.db.parse_or_expand(self.file)?;
-        let field_list_parent = self.field_list_parent.to_node(&root);
-        let old_field_list = field_list_parent.record_expr_field_list()?;
-        let new_field_list = old_field_list.clone_for_update();
-        for f in self.missed_fields.iter() {
-            let field =
-                make::record_expr_field(make::name_ref(&f.to_string()), Some(make::expr_unit()))
-                    .clone_for_update();
-            new_field_list.add_field(field);
-        }
-        let edit = {
-            let mut builder = TextEdit::builder();
-            algo::diff(&old_field_list.syntax(), &new_field_list.syntax())
-                .into_text_edit(&mut builder);
-            builder.finish()
-        };
-        Some(vec![fix(
-            "fill_missing_fields",
-            "Fill struct fields",
-            SourceChange::from_text_edit(self.file.original_file(sema.db), edit),
-            sema.original_range(&field_list_parent.syntax()).range,
-        )])
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::diagnostics::tests::{check_fix, check_no_diagnostics};
-    #[test]
-    fn test_fill_struct_fields_empty() {
-        check_fix(
-            r#"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let s = TestStruct {$0};
-}
-"#,
-            r#"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let s = TestStruct { one: (), two: () };
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_self() {
-        check_fix(
-            r#"
-struct TestStruct { one: i32 }
-impl TestStruct {
-    fn test_fn() { let s = Self {$0}; }
-}
-"#,
-            r#"
-struct TestStruct { one: i32 }
-impl TestStruct {
-    fn test_fn() { let s = Self { one: () }; }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_enum() {
-        check_fix(
-            r#"
-enum Expr {
-    Bin { lhs: Box<Expr>, rhs: Box<Expr> }
-}
-impl Expr {
-    fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
-        Expr::Bin {$0 }
-    }
-}
-"#,
-            r#"
-enum Expr {
-    Bin { lhs: Box<Expr>, rhs: Box<Expr> }
-}
-impl Expr {
-    fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
-        Expr::Bin { lhs: (), rhs: () }
-    }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_partial() {
-        check_fix(
-            r#"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let s = TestStruct{ two: 2$0 };
-}
-"#,
-            r"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let s = TestStruct{ two: 2, one: () };
-}
-",
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_raw_ident() {
-        check_fix(
-            r#"
-struct TestStruct { r#type: u8 }
-fn test_fn() {
-    TestStruct { $0 };
-}
-"#,
-            r"
-struct TestStruct { r#type: u8 }
-fn test_fn() {
-    TestStruct { r#type: ()  };
-}
-",
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_no_diagnostic() {
-        check_no_diagnostics(
-            r#"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let one = 1;
-    let s = TestStruct{ one, two: 2 };
-}
-        "#,
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_no_diagnostic_on_spread() {
-        check_no_diagnostics(
-            r#"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let one = 1;
-    let s = TestStruct{ ..a };
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_blank_line() {
-        check_fix(
-            r#"
-struct S { a: (), b: () }
-fn f() {
-    S {
-        $0
-    };
-}
-"#,
-            r#"
-struct S { a: (), b: () }
-fn f() {
-    S {
-        a: (),
-        b: (),
-    };
-}
-"#,
-        );
-    }
-}
diff --git a/crates/ide/src/diagnostics/fixes/remove_semicolon.rs b/crates/ide/src/diagnostics/fixes/remove_semicolon.rs
deleted file mode 100644
index f1724d479..000000000
--- a/crates/ide/src/diagnostics/fixes/remove_semicolon.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use hir::{db::AstDatabase, diagnostics::RemoveThisSemicolon, Semantics};
-use ide_assists::{Assist, AssistResolveStrategy};
-use ide_db::{source_change::SourceChange, RootDatabase};
-use syntax::{ast, AstNode};
-use text_edit::TextEdit;
-use crate::diagnostics::{fix, DiagnosticWithFixes};
-impl DiagnosticWithFixes for RemoveThisSemicolon {
-    fn fixes(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Vec<Assist>> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        let semicolon = self
-            .expr
-            .to_node(&root)
-            .syntax()
-            .parent()
-            .and_then(ast::ExprStmt::cast)
-            .and_then(|expr| expr.semicolon_token())?
-            .text_range();
-        let edit = TextEdit::delete(semicolon);
-        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-        Some(vec![fix("remove_semicolon", "Remove this semicolon", source_change, semicolon)])
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::diagnostics::tests::check_fix;
-    #[test]
-    fn remove_semicolon() {
-        check_fix(r#"fn f() -> i32 { 92$0; }"#, r#"fn f() -> i32 { 92 }"#);
-    }
-}
diff --git a/crates/ide/src/diagnostics/fixes/replace_with_find_map.rs b/crates/ide/src/diagnostics/fixes/replace_with_find_map.rs
deleted file mode 100644
index 444bf563b..000000000
--- a/crates/ide/src/diagnostics/fixes/replace_with_find_map.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use hir::{db::AstDatabase, diagnostics::ReplaceFilterMapNextWithFindMap, Semantics};
-use ide_assists::{Assist, AssistResolveStrategy};
-use ide_db::{source_change::SourceChange, RootDatabase};
-use syntax::{
-    ast::{self, ArgListOwner},
-    AstNode, TextRange,
-};
-use text_edit::TextEdit;
-use crate::diagnostics::{fix, DiagnosticWithFixes};
-impl DiagnosticWithFixes for ReplaceFilterMapNextWithFindMap {
-    fn fixes(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Vec<Assist>> {
-        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(vec![fix(
-            "replace_with_find_map",
-            "Replace filter_map(..).next() with find_map()",
-            source_change,
-            trigger_range,
-        )])
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::diagnostics::tests::check_fix;
-    #[test]
-    fn replace_with_wind_map() {
-        check_fix(
-            r#"
-//- /main.rs crate:main deps:core
-use core::iter::Iterator;
-use core::option::Option::{self, Some, None};
-fn foo() {
-    let m = [1, 2, 3].iter().$0filter_map(|x| if *x == 2 { Some (4) } else { None }).next();
-}
-//- /core/lib.rs crate:core
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-pub mod iter {
-    pub trait Iterator {
-        type Item;
-        fn filter_map<B, F>(self, f: F) -> FilterMap where F: FnMut(Self::Item) -> Option<B> { FilterMap }
-        fn next(&mut self) -> Option<Self::Item>;
-    }
-    pub struct FilterMap {}
-    impl Iterator for FilterMap {
-        type Item = i32;
-        fn next(&mut self) -> i32 { 7 }
-    }
-}
-"#,
-            r#"
-use core::iter::Iterator;
-use core::option::Option::{self, Some, None};
-fn foo() {
-    let m = [1, 2, 3].iter().find_map(|x| if *x == 2 { Some (4) } else { None });
-}
-"#,
-        )
-    }
-}
diff --git a/crates/ide/src/diagnostics/fixes/unresolved_module.rs b/crates/ide/src/diagnostics/fixes/unresolved_module.rs
deleted file mode 100644
index b3d0283bb..000000000
--- a/crates/ide/src/diagnostics/fixes/unresolved_module.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use hir::{db::AstDatabase, diagnostics::UnresolvedModule, Semantics};
-use ide_assists::{Assist, AssistResolveStrategy};
-use ide_db::{base_db::AnchoredPathBuf, source_change::FileSystemEdit, RootDatabase};
-use syntax::AstNode;
-use crate::diagnostics::{fix, DiagnosticWithFixes};
-impl DiagnosticWithFixes for UnresolvedModule {
-    fn fixes(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Vec<Assist>> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        let unresolved_module = self.decl.to_node(&root);
-        Some(vec![fix(
-            "create_module",
-            "Create module",
-            FileSystemEdit::CreateFile {
-                dst: AnchoredPathBuf {
-                    anchor: self.file.original_file(sema.db),
-                    path: self.candidate.clone(),
-                },
-                initial_contents: "".to_string(),
-            }
-            .into(),
-            unresolved_module.syntax().text_range(),
-        )])
-    }
-}
-#[cfg(test)]
-mod tests {
-    use expect_test::expect;
-    use crate::diagnostics::tests::check_expect;
-    #[test]
-    fn test_unresolved_module_diagnostic() {
-        check_expect(
-            r#"mod foo;"#,
-            expect![[r#"
-                [
-                    Diagnostic {
-                        message: "unresolved module",
-                        range: 0..8,
-                        severity: Error,
-                        fixes: Some(
-                            [
-                                Assist {
-                                    id: AssistId(
-                                        "create_module",
-                                        QuickFix,
-                                    ),
-                                    label: "Create module",
-                                    group: None,
-                                    target: 0..8,
-                                    source_change: Some(
-                                        SourceChange {
-                                            source_file_edits: {},
-                                            file_system_edits: [
-                                                CreateFile {
-                                                    dst: AnchoredPathBuf {
-                                                        anchor: FileId(
-                                                            0,
-                                                        ),
-                                                        path: "foo.rs",
-                                                    },
-                                                    initial_contents: "",
-                                                },
-                                            ],
-                                            is_snippet: false,
-                                        },
-                                    ),
-                                },
-                            ],
-                        ),
-                        unused: false,
-                        code: Some(
-                            DiagnosticCode(
-                                "unresolved-module",
-                            ),
-                        ),
-                    },
-                ]
-            "#]],
-        );
-    }
-}
diff --git a/crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs b/crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs
deleted file mode 100644
index 715a403b9..000000000
--- a/crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-use hir::{db::AstDatabase, diagnostics::MissingOkOrSomeInTailExpr, Semantics};
-use ide_assists::{Assist, AssistResolveStrategy};
-use ide_db::{source_change::SourceChange, RootDatabase};
-use syntax::AstNode;
-use text_edit::TextEdit;
-use crate::diagnostics::{fix, DiagnosticWithFixes};
-impl DiagnosticWithFixes for MissingOkOrSomeInTailExpr {
-    fn fixes(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Vec<Assist>> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        let tail_expr = self.expr.to_node(&root);
-        let tail_expr_range = tail_expr.syntax().text_range();
-        let replacement = format!("{}({})", self.required, tail_expr.syntax());
-        let edit = TextEdit::replace(tail_expr_range, replacement);
-        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-        let name = if self.required == "Ok" { "Wrap with Ok" } else { "Wrap with Some" };
-        Some(vec![fix("wrap_tail_expr", name, source_change, tail_expr_range)])
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::diagnostics::tests::{check_fix, check_no_diagnostics};
-    #[test]
-    fn test_wrap_return_type_option() {
-        check_fix(
-            r#"
-//- /main.rs crate:main deps:core
-use core::option::Option::{self, Some, None};
-fn div(x: i32, y: i32) -> Option<i32> {
-    if y == 0 {
-        return None;
-    }
-    x / y$0
-}
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-            r#"
-use core::option::Option::{self, Some, None};
-fn div(x: i32, y: i32) -> Option<i32> {
-    if y == 0 {
-        return None;
-    }
-    Some(x / y)
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type() {
-        check_fix(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-fn div(x: i32, y: i32) -> Result<i32, ()> {
-    if y == 0 {
-        return Err(());
-    }
-    x / y$0
-}
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-            r#"
-use core::result::Result::{self, Ok, Err};
-fn div(x: i32, y: i32) -> Result<i32, ()> {
-    if y == 0 {
-        return Err(());
-    }
-    Ok(x / y)
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type_handles_generic_functions() {
-        check_fix(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-fn div<T>(x: T) -> Result<T, i32> {
-    if x == 0 {
-        return Err(7);
-    }
-    $0x
-}
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-            r#"
-use core::result::Result::{self, Ok, Err};
-fn div<T>(x: T) -> Result<T, i32> {
-    if x == 0 {
-        return Err(7);
-    }
-    Ok(x)
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type_handles_type_aliases() {
-        check_fix(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-type MyResult<T> = Result<T, ()>;
-fn div(x: i32, y: i32) -> MyResult<i32> {
-    if y == 0 {
-        return Err(());
-    }
-    x $0/ y
-}
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-            r#"
-use core::result::Result::{self, Ok, Err};
-type MyResult<T> = Result<T, ()>;
-fn div(x: i32, y: i32) -> MyResult<i32> {
-    if y == 0 {
-        return Err(());
-    }
-    Ok(x / y)
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type_not_applicable_when_expr_type_does_not_match_ok_type() {
-        check_no_diagnostics(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-fn foo() -> Result<(), i32> { 0 }
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type_not_applicable_when_return_type_is_not_result_or_option() {
-        check_no_diagnostics(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-enum SomeOtherEnum { Ok(i32), Err(String) }
-fn foo() -> SomeOtherEnum { 0 }
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-        );
-    }
-}
diff --git a/crates/ide/src/diagnostics/unlinked_file.rs b/crates/ide/src/diagnostics/unlinked_file.rs
deleted file mode 100644
index 51fe0f360..000000000
--- a/crates/ide/src/diagnostics/unlinked_file.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-//! Diagnostic emitted for files that aren't part of any crate.
-use hir::{
-    db::DefDatabase,
-    diagnostics::{Diagnostic, DiagnosticCode},
-    InFile,
-};
-use ide_assists::AssistResolveStrategy;
-use ide_db::{
-    base_db::{FileId, FileLoader, SourceDatabase, SourceDatabaseExt},
-    source_change::SourceChange,
-    RootDatabase,
-};
-use syntax::{
-    ast::{self, ModuleItemOwner, NameOwner},
-    AstNode, SyntaxNodePtr,
-};
-use text_edit::TextEdit;
-use crate::{
-    diagnostics::{fix, fixes::DiagnosticWithFixes},
-    Assist,
-};
-// Diagnostic: unlinked-file
-//
-// This diagnostic is shown for files that are not included in any crate, or files that are part of
-// crates rust-analyzer failed to discover. The file will not have IDE features available.
-#[derive(Debug)]
-pub(crate) struct UnlinkedFile {
-    pub(crate) file_id: FileId,
-    pub(crate) node: SyntaxNodePtr,
-}
-impl Diagnostic for UnlinkedFile {
-    fn code(&self) -> DiagnosticCode {
-        DiagnosticCode("unlinked-file")
-    }
-    fn message(&self) -> String {
-        "file not included in module tree".to_string()
-    }
-    fn display_source(&self) -> InFile<SyntaxNodePtr> {
-        InFile::new(self.file_id.into(), self.node.clone())
-    }
-    fn as_any(&self) -> &(dyn std::any::Any + Send + 'static) {
-        self
-    }
-}
-impl DiagnosticWithFixes for UnlinkedFile {
-    fn fixes(
-        &self,
-        sema: &hir::Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Vec<Assist>> {
-        // If there's an existing module that could add `mod` or `pub mod` items to include the unlinked file,
-        // suggest that as a fix.
-        let source_root = sema.db.source_root(sema.db.file_source_root(self.file_id));
-        let our_path = source_root.path_for_file(&self.file_id)?;
-        let module_name = our_path.name_and_extension()?.0;
-        // Candidates to look for:
-        // - `mod.rs` in the same folder
-        //   - we also check `main.rs` and `lib.rs`
-        // - `$dir.rs` in the parent folder, where `$dir` is the directory containing `self.file_id`
-        let parent = our_path.parent()?;
-        let mut paths =
-            vec![parent.join("mod.rs")?, parent.join("lib.rs")?, parent.join("main.rs")?];
-        // `submod/bla.rs` -> `submod.rs`
-        if let Some(newmod) = (|| {
-            let name = parent.name_and_extension()?.0;
-            parent.parent()?.join(&format!("{}.rs", name))
-        })() {
-            paths.push(newmod);
-        }
-        for path in &paths {
-            if let Some(parent_id) = source_root.file_for_path(path) {
-                for krate in sema.db.relevant_crates(*parent_id).iter() {
-                    let crate_def_map = sema.db.crate_def_map(*krate);
-                    for (_, module) in crate_def_map.modules() {
-                        if module.origin.is_inline() {
-                            // We don't handle inline `mod parent {}`s, they use different paths.
-                            continue;
-                        }
-                        if module.origin.file_id() == Some(*parent_id) {
-                            return make_fixes(sema.db, *parent_id, module_name, self.file_id);
-                        }
-                    }
-                }
-            }
-        }
-        None
-    }
-}
-fn make_fixes(
-    db: &RootDatabase,
-    parent_file_id: FileId,
-    new_mod_name: &str,
-    added_file_id: FileId,
-) -> Option<Vec<Assist>> {
-    fn is_outline_mod(item: &ast::Item) -> bool {
-        matches!(item, ast::Item::Module(m) if m.item_list().is_none())
-    }
-    let mod_decl = format!("mod {};", new_mod_name);
-    let pub_mod_decl = format!("pub mod {};", new_mod_name);
-    let ast: ast::SourceFile = db.parse(parent_file_id).tree();
-    let mut mod_decl_builder = TextEdit::builder();
-    let mut pub_mod_decl_builder = TextEdit::builder();
-    // If there's an existing `mod m;` statement matching the new one, don't emit a fix (it's
-    // probably `#[cfg]`d out).
-    for item in ast.items() {
-        if let ast::Item::Module(m) = item {
-            if let Some(name) = m.name() {
-                if m.item_list().is_none() && name.to_string() == new_mod_name {
-                    cov_mark::hit!(unlinked_file_skip_fix_when_mod_already_exists);
-                    return None;
-                }
-            }
-        }
-    }
-    // If there are existing `mod m;` items, append after them (after the first group of them, rather).
-    match ast
-        .items()
-        .skip_while(|item| !is_outline_mod(item))
-        .take_while(|item| is_outline_mod(item))
-        .last()
-    {
-        Some(last) => {
-            cov_mark::hit!(unlinked_file_append_to_existing_mods);
-            let offset = last.syntax().text_range().end();
-            mod_decl_builder.insert(offset, format!("\n{}", mod_decl));
-            pub_mod_decl_builder.insert(offset, format!("\n{}", pub_mod_decl));
-        }
-        None => {
-            // Prepend before the first item in the file.
-            match ast.items().next() {
-                Some(item) => {
-                    cov_mark::hit!(unlinked_file_prepend_before_first_item);
-                    let offset = item.syntax().text_range().start();
-                    mod_decl_builder.insert(offset, format!("{}\n\n", mod_decl));
-                    pub_mod_decl_builder.insert(offset, format!("{}\n\n", pub_mod_decl));
-                }
-                None => {
-                    // No items in the file, so just append at the end.
-                    cov_mark::hit!(unlinked_file_empty_file);
-                    let offset = ast.syntax().text_range().end();
-                    mod_decl_builder.insert(offset, format!("{}\n", mod_decl));
-                    pub_mod_decl_builder.insert(offset, format!("{}\n", pub_mod_decl));
-                }
-            }
-        }
-    }
-    let trigger_range = db.parse(added_file_id).tree().syntax().text_range();
-    Some(vec![
-        fix(
-            "add_mod_declaration",
-            &format!("Insert `{}`", mod_decl),
-            SourceChange::from_text_edit(parent_file_id, mod_decl_builder.finish()),
-            trigger_range,
-        ),
-        fix(
-            "add_pub_mod_declaration",
-            &format!("Insert `{}`", pub_mod_decl),
-            SourceChange::from_text_edit(parent_file_id, pub_mod_decl_builder.finish()),
-            trigger_range,
-        ),
-    ])
-}
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index b75ec411c..455b32456 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -442,10 +442,10 @@ 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
+            Either::Left(type_param) => type_param.syntax().text_range(),
+            Either::Right(trait_) => trait_
                .name()
-                .map_or_else(|| it.syntax().text_range(), |name| name.syntax().text_range()),
+                .map_or_else(|| trait_.syntax().text_range(), |name| name.syntax().text_range()),
-            Either::Right(it) => it.syntax().text_range(),
        };
        let focus_range = match &src.value {
            Either::Left(it) => it.name(),
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index ec3828ab2..7ac0118fe 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -151,18 +151,18 @@ pub(crate) fn resolve_doc_path_for_def(
 ) -> Option<hir::ModuleDef> {
    match def {
        Definition::ModuleDef(def) => match def {
-            hir::ModuleDef::Module(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Module(it) => it.resolve_doc_path(db, link, ns),
-            hir::ModuleDef::Function(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Function(it) => it.resolve_doc_path(db, link, ns),
-            hir::ModuleDef::Adt(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Adt(it) => it.resolve_doc_path(db, link, ns),
-            hir::ModuleDef::Variant(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Variant(it) => it.resolve_doc_path(db, link, ns),
-            hir::ModuleDef::Const(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Const(it) => it.resolve_doc_path(db, link, ns),
-            hir::ModuleDef::Static(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Static(it) => it.resolve_doc_path(db, link, ns),
-            hir::ModuleDef::Trait(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Trait(it) => it.resolve_doc_path(db, link, ns),
-            hir::ModuleDef::TypeAlias(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::TypeAlias(it) => it.resolve_doc_path(db, link, ns),
            hir::ModuleDef::BuiltinType(_) => None,
        },
-        Definition::Macro(it) => it.resolve_doc_path(db, &link, ns),
+        Definition::Macro(it) => it.resolve_doc_path(db, link, ns),
-        Definition::Field(it) => it.resolve_doc_path(db, &link, ns),
+        Definition::Field(it) => it.resolve_doc_path(db, link, ns),
        Definition::SelfType(_)
        | Definition::Local(_)
        | Definition::GenericParam(_)
@@ -192,7 +192,7 @@ pub(crate) fn doc_attributes(
            ast::TupleField(it)  => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Field(def))),
            ast::Macro(it)       => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Macro(def))),
            // ast::Use(it) => sema.to_def(&it).map(|def| (Box::new(it) as _, def.attrs(sema.db))),
-            _ => return None
+            _ => None
        }
    }
 }
@@ -241,6 +241,10 @@ fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
        Definition::ModuleDef(ModuleDef::Module(module)) => module.krate(),
        _ => definition.module(db)?.krate(),
    };
+    // FIXME: using import map doesn't make sense here. What we want here is
+    // canonical path. What import map returns is the shortest path suitable for
+    // import. See this test:
+    cov_mark::hit!(test_reexport_order);
    let import_map = db.import_map(krate.into());
    let mut base = krate.display_name(db)?.to_string();
@@ -642,13 +646,15 @@ pub mod foo {
        )
    }
-    // FIXME: ImportMap will return re-export paths instead of public module
-    // paths. The correct path to documentation will never be a re-export.
-    // This problem stops us from resolving stdlib items included in the prelude
-    // such as `Option::Some` correctly.
-    #[ignore = "ImportMap may return re-exports"]
    #[test]
    fn test_reexport_order() {
+        cov_mark::check!(test_reexport_order);
+        // FIXME: This should return
+        //
+        //    https://docs.rs/test/*/test/wrapper/modulestruct.Item.html
+        //
+        // That is, we should point inside the module, rather than at the
+        // re-export.
        check(
            r#"
 pub mod wrapper {
@@ -663,7 +669,7 @@ fn foo() {
    let bar: wrapper::It$0em;
 }
        "#,
-            expect![[r#"https://docs.rs/test/*/test/wrapper/module/struct.Item.html"#]],
+            expect![[r#"https://docs.rs/test/*/test/wrapper/struct.Item.html"#]],
        )
    }
 }
diff --git a/crates/ide/src/extend_selection.rs b/crates/ide/src/extend_selection.rs
index 7032889ac..c7ec87edf 100644
--- a/crates/ide/src/extend_selection.rs
+++ b/crates/ide/src/extend_selection.rs
@@ -328,7 +328,7 @@ mod tests {
    use super::*;
    fn do_check(before: &str, afters: &[&str]) {
-        let (analysis, position) = fixture::position(&before);
+        let (analysis, position) = fixture::position(before);
        let before = analysis.file_text(position.file_id).unwrap();
        let range = TextRange::empty(position.offset);
        let mut frange = FileRange { file_id: position.file_id, range };
diff --git a/crates/ide/src/fixture.rs b/crates/ide/src/fixture.rs
index 6780af617..cf679edd3 100644
--- a/crates/ide/src/fixture.rs
+++ b/crates/ide/src/fixture.rs
@@ -1,6 +1,5 @@
 //! Utilities for creating `Analysis` instances for tests.
 use ide_db::base_db::fixture::ChangeFixture;
-use syntax::{TextRange, TextSize};
 use test_utils::extract_annotations;
 use crate::{Analysis, AnalysisHost, FileId, FilePosition, FileRange};
@@ -13,14 +12,6 @@ pub(crate) fn file(ra_fixture: &str) -> (Analysis, FileId) {
    (host.analysis(), change_fixture.files[0])
 }
-/// Creates analysis for many files.
-pub(crate) fn files(ra_fixture: &str) -> (Analysis, Vec<FileId>) {
-    let mut host = AnalysisHost::default();
-    let change_fixture = ChangeFixture::parse(ra_fixture);
-    host.db.apply_change(change_fixture.change);
-    (host.analysis(), change_fixture.files)
-}
 /// Creates analysis from a multi-file fixture, returns positions marked with $0.
 pub(crate) fn position(ra_fixture: &str) -> (Analysis, FilePosition) {
    let mut host = AnalysisHost::default();
@@ -63,15 +54,8 @@ pub(crate) fn annotations(ra_fixture: &str) -> (Analysis, FilePosition, Vec<(Fil
 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();
+    let (expected, data) = annotations.pop().unwrap();
    assert!(annotations.is_empty());
-    match data.as_str() {
+    assert_eq!(data, "");
-        "" => (),
-        "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/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 2d36c34e9..d8e0dc4d5 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -43,7 +43,7 @@ pub(crate) fn goto_definition(
        let (docs, doc_mapping) = attributes.docs_with_rangemap(db)?;
        let (_, link, ns) =
            extract_definitions_from_markdown(docs.as_str()).into_iter().find(|(range, ..)| {
-                doc_mapping.map(range.clone()).map_or(false, |InFile { file_id, value: range }| {
+                doc_mapping.map(*range).map_or(false, |InFile { file_id, value: range }| {
                    file_id == position.file_id.into() && range.contains(position.offset)
                })
            })?;
@@ -57,7 +57,7 @@ pub(crate) fn goto_definition(
            },
            ast::Name(name) => {
                let def = NameClass::classify(&sema, &name)?.referenced_or_defined(sema.db);
-                try_find_trait_item_definition(&sema.db, &def)
+                try_find_trait_item_definition(sema.db, &def)
                    .or_else(|| def.try_to_nav(sema.db))
            },
            ast::Lifetime(lt) => if let Some(name_class) = NameClass::classify_lifetime(&sema, &lt) {
@@ -185,7 +185,7 @@ mod tests {
 extern crate std$0;
 //- /std/lib.rs crate:std
 // empty
-//^ file
+//^file
 "#,
        )
    }
@@ -198,7 +198,7 @@ extern crate std$0;
 extern crate std as abc$0;
 //- /std/lib.rs crate:std
 // empty
-//^ file
+//^file
 "#,
        )
    }
@@ -253,7 +253,7 @@ mod $0foo;
 //- /foo.rs
 // empty
-//^ file
+//^file
 "#,
        );
@@ -264,7 +264,7 @@ mod $0foo;
 //- /foo/mod.rs
 // empty
-//^ file
+//^file
 "#,
        );
    }
@@ -395,7 +395,7 @@ use foo as bar$0;
 //- /foo/lib.rs crate:foo
 // empty
-//^ file
+//^file
 "#,
        );
    }
@@ -1130,15 +1130,15 @@ fn foo<'foobar>(_: &'foobar ()) {
    }
    #[test]
-    #[ignore] // requires the HIR to somehow track these hrtb lifetimes
    fn goto_lifetime_hrtb() {
-        check(
+        // FIXME: requires the HIR to somehow track these hrtb lifetimes
+        check_unresolved(
            r#"trait Foo<T> {}
 fn foo<T>() where for<'a> T: Foo<&'a$0 (u8, u16)>, {}
                    //^^
 "#,
        );
-        check(
+        check_unresolved(
            r#"trait Foo<T> {}
 fn foo<T>() where for<'a$0> T: Foo<&'a (u8, u16)>, {}
                    //^^
@@ -1147,9 +1147,9 @@ fn foo<T>() where for<'a$0> T: Foo<&'a (u8, u16)>, {}
    }
    #[test]
-    #[ignore] // requires ForTypes to be implemented
    fn goto_lifetime_hrtb_for_type() {
-        check(
+        // FIXME: requires ForTypes to be implemented
+        check_unresolved(
            r#"trait Foo<T> {}
 fn foo<T>() where T: for<'a> Foo<&'a$0 (u8, u16)>, {}
                       //^^
@@ -1287,7 +1287,7 @@ fn main() {
 }
 //- /foo.txt
 // empty
-//^ file
+//^file
 "#,
        );
    }
diff --git a/crates/ide/src/goto_implementation.rs b/crates/ide/src/goto_implementation.rs
index 95fd39850..0013820b4 100644
--- a/crates/ide/src/goto_implementation.rs
+++ b/crates/ide/src/goto_implementation.rs
@@ -87,7 +87,7 @@ fn impls_for_trait_item(
        .filter_map(|imp| {
            let item = imp.items(sema.db).iter().find_map(|itm| {
                let itm_name = itm.name(sema.db)?;
-                (itm_name == fun_name).then(|| itm.clone())
+                (itm_name == fun_name).then(|| *itm)
            })?;
            item.try_to_nav(sema.db)
        })
diff --git a/crates/ide/src/goto_type_definition.rs b/crates/ide/src/goto_type_definition.rs
index 004d9cb68..ca3c02bf6 100644
--- a/crates/ide/src/goto_type_definition.rs
+++ b/crates/ide/src/goto_type_definition.rs
@@ -25,7 +25,7 @@ pub(crate) fn goto_type_definition(
    let token: SyntaxToken = pick_best(file.syntax().token_at_offset(position.offset))?;
    let token: SyntaxToken = sema.descend_into_macros(token);
-    let (ty, node) = sema.token_ancestors_with_macros(token).find_map(|node| {
+    let (ty, node) = sema.token_ancestors_with_macros(token.clone()).find_map(|node| {
        let ty = match_ast! {
            match node {
                ast::Expr(it) => sema.type_of_expr(&it)?,
@@ -33,13 +33,23 @@ pub(crate) fn goto_type_definition(
                ast::SelfParam(it) => sema.type_of_self(&it)?,
                ast::Type(it) => sema.resolve_type(&it)?,
                ast::RecordField(it) => sema.to_def(&it).map(|d| d.ty(db.upcast()))?,
+                ast::RecordField(it) => sema.to_def(&it).map(|d| d.ty(db.upcast()))?,
+                // can't match on RecordExprField directly as `ast::Expr` will match an iteration too early otherwise
+                ast::NameRef(it) => {
+                    if let Some(record_field) = ast::RecordExprField::for_name_ref(&it) {
+                        let (_, _, ty) = sema.resolve_record_field(&record_field)?;
+                        ty
+                    } else {
+                        let record_field = ast::RecordPatField::for_field_name_ref(&it)?;
+                        sema.resolve_record_pat_field(&record_field)?.ty(db)
+                    }
+                },
                _ => return None,
            }
        };
        Some((ty, node))
    })?;
    let adt_def = ty.autoderef(db).filter_map(|ty| ty.as_adt()).last()?;
    let nav = adt_def.try_to_nav(db)?;
@@ -88,6 +98,54 @@ fn foo() {
    }
    #[test]
+    fn goto_type_definition_record_expr_field() {
+        check(
+            r#"
+struct Bar;
+    // ^^^
+struct Foo { foo: Bar }
+fn foo() {
+    Foo { foo$0 }
+}
+"#,
+        );
+        check(
+            r#"
+struct Bar;
+    // ^^^
+struct Foo { foo: Bar }
+fn foo() {
+    Foo { foo$0: Bar }
+}
+"#,
+        );
+    }
+    #[test]
+    fn goto_type_definition_record_pat_field() {
+        check(
+            r#"
+struct Bar;
+    // ^^^
+struct Foo { foo: Bar }
+fn foo() {
+    let Foo { foo$0 };
+}
+"#,
+        );
+        check(
+            r#"
+struct Bar;
+    // ^^^
+struct Foo { foo: Bar }
+fn foo() {
+    let Foo { foo$0: bar };
+}
+"#,
+        );
+    }
+    #[test]
    fn goto_type_definition_works_simple_ref() {
        check(
            r#"
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 1c6d36939..529cf5f33 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -131,7 +131,7 @@ pub(crate) fn hover(
                    let (docs, doc_mapping) = attributes.docs_with_rangemap(db)?;
                    let (idl_range, link, ns) =
                        extract_definitions_from_markdown(docs.as_str()).into_iter().find_map(|(range, link, ns)| {
-                            let InFile { file_id, value: range } = doc_mapping.map(range.clone())?;
+                            let InFile { file_id, value: range } = doc_mapping.map(range)?;
                            if file_id == position.file_id.into() && range.contains(position.offset) {
                                Some((range, link, ns))
                            } else {
@@ -288,7 +288,7 @@ fn runnable_action(
 ) -> Option<HoverAction> {
    match def {
        Definition::ModuleDef(it) => match it {
-            ModuleDef::Module(it) => runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it)),
+            ModuleDef::Module(it) => runnable_mod(sema, it).map(HoverAction::Runnable),
            ModuleDef::Function(func) => {
                let src = func.source(sema.db)?;
                if src.file_id != file_id.into() {
@@ -297,7 +297,7 @@ fn runnable_action(
                    return None;
                }
-                runnable_fn(&sema, func).map(HoverAction::Runnable)
+                runnable_fn(sema, func).map(HoverAction::Runnable)
            }
            _ => None,
        },
@@ -432,7 +432,7 @@ fn hover_for_definition(
    return match def {
        Definition::Macro(it) => match &it.source(db)?.value {
            Either::Left(mac) => {
-                let label = macro_label(&mac);
+                let label = macro_label(mac);
                from_def_source_labeled(db, it, Some(label), mod_path)
            }
            Either::Right(_) => {
@@ -516,7 +516,7 @@ fn hover_for_keyword(
    if !token.kind().is_keyword() {
        return None;
    }
-    let famous_defs = FamousDefs(&sema, sema.scope(&token.parent()?).krate());
+    let famous_defs = FamousDefs(sema, sema.scope(&token.parent()?).krate());
    // std exposes {}_keyword modules with docstrings on the root to document keywords
    let keyword_mod = format!("{}_keyword", token.text());
    let doc_owner = find_std_module(&famous_defs, &keyword_mod)?;
@@ -1821,9 +1821,10 @@ pub struct B$0ar
        );
    }
-    #[ignore = "path based links currently only support documentation on ModuleDef items"]
    #[test]
    fn test_hover_path_link_field() {
+        // FIXME: Should be
+        //  [Foo](https://docs.rs/test/*/test/struct.Foo.html)
        check(
            r#"
 pub struct Foo;
@@ -1845,7 +1846,7 @@ pub struct Bar {
                ---
-                [Foo](https://docs.rs/test/*/test/struct.Foo.html)
+                [Foo](struct.Foo.html)
            "#]],
        );
    }
@@ -2999,29 +3000,24 @@ fn foo(ar$0g: &impl Foo + Bar<S>) {}
    fn test_hover_async_block_impl_trait_has_goto_type_action() {
        check_actions(
            r#"
+//- minicore: future
 struct S;
 fn foo() {
    let fo$0o = async { S };
 }
-#[prelude_import] use future::*;
-mod future {
-    #[lang = "future_trait"]
-    pub trait Future { type Output; }
-}
 "#,
            expect![[r#"
                [
                    GoToType(
                        [
                            HoverGotoTypeData {
-                                mod_path: "test::future::Future",
+                                mod_path: "core::future::Future",
                                nav: NavigationTarget {
                                    file_id: FileId(
-                                        0,
+                                        1,
                                    ),
-                                    full_range: 101..163,
+                                    full_range: 245..427,
-                                    focus_range: 140..146,
+                                    focus_range: 284..290,
                                    name: "Future",
                                    kind: Trait,
                                    description: "pub trait Future",
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 821c61403..9cd33d0e4 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -96,7 +96,7 @@ fn get_chaining_hints(
    }
    let krate = sema.scope(expr.syntax()).module().map(|it| it.krate());
-    let famous_defs = FamousDefs(&sema, krate);
+    let famous_defs = FamousDefs(sema, krate);
    let mut tokens = expr
        .syntax()
@@ -165,7 +165,7 @@ fn get_param_name_hints(
            };
            Some((param_name, arg))
        })
-        .filter(|(param_name, arg)| !should_hide_param_name_hint(sema, &callable, param_name, &arg))
+        .filter(|(param_name, arg)| !should_hide_param_name_hint(sema, &callable, param_name, arg))
        .map(|(param_name, arg)| InlayHint {
            range: arg.syntax().text_range(),
            kind: InlayKind::ParameterHint,
@@ -187,7 +187,7 @@ fn get_bind_pat_hints(
    }
    let krate = sema.scope(pat.syntax()).module().map(|it| it.krate());
-    let famous_defs = FamousDefs(&sema, krate);
+    let famous_defs = FamousDefs(sema, krate);
    let ty = sema.type_of_pat(&pat.clone().into())?;
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index c67ccd1a9..93d3760bf 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -60,7 +60,7 @@ fn remove_newlines(edit: &mut TextEditBuilder, token: &SyntaxToken, range: TextR
        let pos: TextSize = (pos as u32).into();
        let offset = token.text_range().start() + range.start() + pos;
        if !edit.invalidates_offset(offset) {
-            remove_newline(edit, &token, offset);
+            remove_newline(edit, token, offset);
        }
    }
 }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 97c9e5d2b..4bd073cc3 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -24,7 +24,6 @@ mod display;
 mod annotations;
 mod call_hierarchy;
-mod diagnostics;
 mod expand_macro;
 mod extend_selection;
 mod file_structure;
@@ -40,6 +39,7 @@ mod matching_brace;
 mod move_item;
 mod parent_module;
 mod references;
+mod rename;
 mod fn_references;
 mod runnables;
 mod ssr;
@@ -71,7 +71,6 @@ use crate::display::ToNav;
 pub use crate::{
    annotations::{Annotation, AnnotationConfig, AnnotationKind},
    call_hierarchy::CallItem,
-    diagnostics::{Diagnostic, DiagnosticsConfig, Severity},
    display::navigation_target::NavigationTarget,
    expand_macro::ExpandedMacro,
    file_structure::{StructureNode, StructureNodeKind},
@@ -81,7 +80,8 @@ pub use crate::{
    markup::Markup,
    move_item::Direction,
    prime_caches::PrimeCachesProgress,
-    references::{rename::RenameError, ReferenceSearchResult},
+    references::ReferenceSearchResult,
+    rename::RenameError,
    runnables::{Runnable, RunnableKind, TestId},
    syntax_highlighting::{
        tags::{Highlight, HlMod, HlMods, HlOperator, HlPunct, HlTag},
@@ -109,6 +109,7 @@ pub use ide_db::{
    symbol_index::Query,
    RootDatabase, SymbolKind,
 };
+pub use ide_diagnostics::{Diagnostic, DiagnosticsConfig, Severity};
 pub use ide_ssr::SsrError;
 pub use syntax::{TextRange, TextSize};
 pub use text_edit::{Indel, TextEdit};
@@ -282,20 +283,20 @@ impl Analysis {
        file_id: FileId,
        text_range: Option<TextRange>,
    ) -> Cancellable<String> {
-        self.with_db(|db| syntax_tree::syntax_tree(&db, file_id, text_range))
+        self.with_db(|db| syntax_tree::syntax_tree(db, file_id, text_range))
    }
    pub fn view_hir(&self, position: FilePosition) -> Cancellable<String> {
-        self.with_db(|db| view_hir::view_hir(&db, position))
+        self.with_db(|db| view_hir::view_hir(db, position))
    }
    pub fn view_item_tree(&self, file_id: FileId) -> Cancellable<String> {
-        self.with_db(|db| view_item_tree::view_item_tree(&db, file_id))
+        self.with_db(|db| view_item_tree::view_item_tree(db, file_id))
    }
    /// Renders the crate graph to GraphViz "dot" syntax.
    pub fn view_crate_graph(&self) -> Cancellable<Result<String, String>> {
-        self.with_db(|db| view_crate_graph::view_crate_graph(&db))
+        self.with_db(|db| view_crate_graph::view_crate_graph(db))
    }
    pub fn expand_macro(&self, position: FilePosition) -> Cancellable<Option<ExpandedMacro>> {
@@ -315,7 +316,7 @@ impl Analysis {
    /// up minor stuff like continuing the comment.
    /// The edit will be a snippet (with `$0`).
    pub fn on_enter(&self, position: FilePosition) -> Cancellable<Option<TextEdit>> {
-        self.with_db(|db| typing::on_enter(&db, position))
+        self.with_db(|db| typing::on_enter(db, position))
    }
    /// Returns an edit which should be applied after a character was typed.
@@ -331,7 +332,7 @@ impl Analysis {
        if !typing::TRIGGER_CHARS.contains(char_typed) {
            return Ok(None);
        }
-        self.with_db(|db| typing::on_char_typed(&db, position, char_typed))
+        self.with_db(|db| typing::on_char_typed(db, position, char_typed))
    }
    /// Returns a tree representation of symbols in the file. Useful to draw a
@@ -536,7 +537,7 @@ impl Analysis {
    ) -> Cancellable<Vec<Assist>> {
        self.with_db(|db| {
            let ssr_assists = ssr::ssr_assists(db, &resolve, frange);
-            let mut acc = Assist::get(db, config, resolve, frange);
+            let mut acc = ide_assists::assists(db, config, resolve, frange);
            acc.extend(ssr_assists.into_iter());
            acc
        })
@@ -549,7 +550,7 @@ impl Analysis {
        resolve: AssistResolveStrategy,
        file_id: FileId,
    ) -> Cancellable<Vec<Diagnostic>> {
-        self.with_db(|db| diagnostics::diagnostics(db, config, &resolve, file_id))
+        self.with_db(|db| ide_diagnostics::diagnostics(db, config, &resolve, file_id))
    }
    /// Convenience function to return assists + quick fixes for diagnostics
@@ -566,9 +567,8 @@ impl Analysis {
        };
        self.with_db(|db| {
-            let ssr_assists = ssr::ssr_assists(db, &resolve, frange);
            let diagnostic_assists = if include_fixes {
-                diagnostics::diagnostics(db, diagnostics_config, &resolve, frange.file_id)
+                ide_diagnostics::diagnostics(db, diagnostics_config, &resolve, frange.file_id)
                    .into_iter()
                    .flat_map(|it| it.fixes.unwrap_or_default())
                    .filter(|it| it.target.intersect(frange.range).is_some())
@@ -576,10 +576,12 @@ impl Analysis {
            } else {
                Vec::new()
            };
+            let ssr_assists = ssr::ssr_assists(db, &resolve, frange);
+            let assists = ide_assists::assists(db, assist_config, resolve, frange);
-            let mut res = Assist::get(db, assist_config, resolve, frange);
+            let mut res = diagnostic_assists;
            res.extend(ssr_assists.into_iter());
-            res.extend(diagnostic_assists.into_iter());
+            res.extend(assists.into_iter());
            res
        })
@@ -592,14 +594,14 @@ impl Analysis {
        position: FilePosition,
        new_name: &str,
    ) -> Cancellable<Result<SourceChange, RenameError>> {
-        self.with_db(|db| references::rename::rename(db, position, new_name))
+        self.with_db(|db| rename::rename(db, position, new_name))
    }
    pub fn prepare_rename(
        &self,
        position: FilePosition,
    ) -> Cancellable<Result<RangeInfo<()>, RenameError>> {
-        self.with_db(|db| references::rename::prepare_rename(db, position))
+        self.with_db(|db| rename::prepare_rename(db, position))
    }
    pub fn will_rename_file(
@@ -607,7 +609,7 @@ impl Analysis {
        file_id: FileId,
        new_name_stem: &str,
    ) -> Cancellable<Option<SourceChange>> {
-        self.with_db(|db| references::rename::will_rename_file(db, file_id, new_name_stem))
+        self.with_db(|db| rename::will_rename_file(db, file_id, new_name_stem))
    }
    pub fn structural_search_replace(
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index f8b64a669..945c9b9e1 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -9,8 +9,6 @@
 //! at the index that the match starts at and its tree parent is
 //! resolved to the search element definition, we get a reference.
-pub(crate) mod rename;
 use hir::{PathResolution, Semantics};
 use ide_db::{
    base_db::FileId,
@@ -62,7 +60,7 @@ pub(crate) fn find_all_refs(
        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)
+            (find_def(sema, &syntax, position)?, false)
        };
    let mut usages = def.usages(sema).set_scope(search_scope).include_self_refs().all();
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/rename.rs
index 7dfc5043e..8096dfa0e 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/rename.rs
@@ -1,45 +1,25 @@
-//! Renaming functionality
+//! Renaming functionality.
 //!
-//! All reference and file rename requests go through here where the corresponding [`SourceChange`]s
+//! This is mostly front-end for [`ide_db::rename`], but it also includes the
-//! will be calculated.
+//! tests. This module also implements a couple of magic tricks, like renaming
-use std::fmt::{self, Display};
+//! `self` and to `self` (to switch between associated function and method).
+use hir::{AsAssocItem, InFile, Semantics};
-use either::Either;
-use hir::{AsAssocItem, InFile, Module, ModuleDef, ModuleSource, Semantics};
 use ide_db::{
-    base_db::{AnchoredPathBuf, FileId},
+    base_db::FileId,
    defs::{Definition, NameClass, NameRefClass},
-    search::FileReference,
+    rename::{bail, format_err, source_edit_from_references, IdentifierKind},
    RootDatabase,
 };
 use stdx::never;
-use syntax::{
+use syntax::{ast, AstNode, SyntaxNode};
-    ast::{self, NameOwner},
-    lex_single_syntax_kind, AstNode, SyntaxKind, SyntaxNode, T,
-};
 use text_edit::TextEdit;
-use crate::{display::TryToNav, FilePosition, FileSystemEdit, RangeInfo, SourceChange, TextRange};
+use crate::{FilePosition, RangeInfo, SourceChange};
-type RenameResult<T> = Result<T, RenameError>;
-#[derive(Debug)]
-pub struct RenameError(String);
-impl fmt::Display for RenameError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Display::fmt(&self.0, f)
-    }
-}
-macro_rules! format_err {
+pub use ide_db::rename::RenameError;
-    ($fmt:expr) => {RenameError(format!($fmt))};
-    ($fmt:expr, $($arg:tt)+) => {RenameError(format!($fmt, $($arg)+))}
-}
-macro_rules! bail {
+type RenameResult<T> = Result<T, RenameError>;
-    ($($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.
@@ -52,26 +32,10 @@ pub(crate) fn prepare_rename(
    let syntax = source_file.syntax();
    let def = find_definition(&sema, syntax, position)?;
-    match def {
+    let frange = def
-        Definition::SelfType(_) => bail!("Cannot rename `Self`"),
+        .range_for_rename(&sema)
-        Definition::ModuleDef(ModuleDef::BuiltinType(_)) => bail!("Cannot rename builtin type"),
-        Definition::ModuleDef(ModuleDef::Module(_)) => (),
-        _ => {
-            let nav = def
-                .try_to_nav(sema.db)
-                .ok_or_else(|| format_err!("No references found at position"))?;
-            nav.focus_range.ok_or_else(|| format_err!("No identifier available to rename"))?;
-        }
-    };
-    let name_like = sema
-        .find_node_at_offset_with_descend(&syntax, position.offset)
        .ok_or_else(|| format_err!("No references found at position"))?;
-    let node = match &name_like {
+    Ok(RangeInfo::new(frange.range, ()))
-        ast::NameLike::Name(it) => it.syntax(),
-        ast::NameLike::NameRef(it) => it.syntax(),
-        ast::NameLike::Lifetime(it) => it.syntax(),
-    };
-    Ok(RangeInfo::new(sema.original_range(node).range, ()))
 }
 // Feature: Rename
@@ -103,12 +67,19 @@ pub(crate) fn rename_with_semantics(
    let syntax = source_file.syntax();
    let def = find_definition(sema, syntax, position)?;
-    match def {
-        Definition::ModuleDef(ModuleDef::Module(module)) => rename_mod(&sema, module, new_name),
+    if let Definition::Local(local) = def {
-        Definition::SelfType(_) => bail!("Cannot rename `Self`"),
+        if let Some(self_param) = local.as_self_param(sema.db) {
-        Definition::ModuleDef(ModuleDef::BuiltinType(_)) => bail!("Cannot rename builtin type"),
+            cov_mark::hit!(rename_self_to_param);
-        def => rename_reference(sema, def, new_name),
+            return rename_self_to_param(sema, local, self_param, new_name);
+        }
+        if new_name == "self" {
+            cov_mark::hit!(rename_to_self);
+            return rename_to_self(sema, local);
+        }
    }
+    def.rename(sema, new_name)
 }
 /// Called by the client when it is about to rename a file.
@@ -119,38 +90,12 @@ pub(crate) fn will_rename_file(
 ) -> Option<SourceChange> {
    let sema = Semantics::new(db);
    let module = sema.to_module_def(file_id)?;
-    let mut change = rename_mod(&sema, module, new_name_stem).ok()?;
+    let def = Definition::ModuleDef(module.into());
+    let mut change = def.rename(&sema, new_name_stem).ok()?;
    change.file_system_edits.clear();
    Some(change)
 }
-#[derive(Copy, Clone, Debug, PartialEq)]
-enum IdentifierKind {
-    Ident,
-    Lifetime,
-    ToSelf,
-    Underscore,
-}
-fn check_identifier(new_name: &str) -> RenameResult<IdentifierKind> {
-    match lex_single_syntax_kind(new_name) {
-        Some(res) => match res {
-            (SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident),
-            (T![_], _) => Ok(IdentifierKind::Underscore),
-            (T![self], _) => Ok(IdentifierKind::ToSelf),
-            (SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => {
-                Ok(IdentifierKind::Lifetime)
-            }
-            (SyntaxKind::LIFETIME_IDENT, _) => {
-                bail!("Invalid name `{}`: not a lifetime identifier", new_name)
-            }
-            (_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
-            (_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
-        },
-        None => bail!("Invalid name `{}`: not an identifier", new_name),
-    }
-}
 fn find_definition(
    sema: &Semantics<RootDatabase>,
    syntax: &SyntaxNode,
@@ -192,145 +137,6 @@ fn find_definition(
    .ok_or_else(|| format_err!("No references found at position"))
 }
-fn rename_mod(
-    sema: &Semantics<RootDatabase>,
-    module: Module,
-    new_name: &str,
-) -> 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 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()),
-            ),
-            _ => never!("Module source node is missing a name"),
-        }
-    }
-    let def = Definition::ModuleDef(ModuleDef::Module(module));
-    let usages = def.usages(sema).all();
-    let ref_edits = usages.iter().map(|(&file_id, references)| {
-        (file_id, source_edit_from_references(references, def, new_name))
-    });
-    source_change.extend(ref_edits);
-    Ok(source_change)
-}
-fn rename_reference(
-    sema: &Semantics<RootDatabase>,
-    mut def: Definition,
-    new_name: &str,
-) -> RenameResult<SourceChange> {
-    let ident_kind = check_identifier(new_name)?;
-    if matches!(
-        def, // is target a lifetime?
-        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
-    ) {
-        match ident_kind {
-            IdentifierKind::Ident | IdentifierKind::ToSelf | IdentifierKind::Underscore => {
-                cov_mark::hit!(rename_not_a_lifetime_ident_ref);
-                bail!("Invalid name `{}`: not a lifetime identifier", new_name);
-            }
-            IdentifierKind::Lifetime => cov_mark::hit!(rename_lifetime),
-        }
-    } else {
-        match (ident_kind, def) {
-            (IdentifierKind::Lifetime, _) => {
-                cov_mark::hit!(rename_not_an_ident_ref);
-                bail!("Invalid name `{}`: not an identifier", new_name);
-            }
-            (IdentifierKind::ToSelf, Definition::Local(local)) => {
-                if local.is_self(sema.db) {
-                    // no-op
-                    cov_mark::hit!(rename_self_to_self);
-                    return Ok(SourceChange::default());
-                } else {
-                    cov_mark::hit!(rename_to_self);
-                    return rename_to_self(sema, local);
-                }
-            }
-            (ident_kind, Definition::Local(local)) => {
-                if let Some(self_param) = local.as_self_param(sema.db) {
-                    cov_mark::hit!(rename_self_to_param);
-                    return rename_self_to_param(sema, local, self_param, new_name, ident_kind);
-                } else {
-                    cov_mark::hit!(rename_local);
-                }
-            }
-            (IdentifierKind::ToSelf, _) => bail!("Invalid name `{}`: not an identifier", new_name),
-            (IdentifierKind::Ident, _) => cov_mark::hit!(rename_non_local),
-            (IdentifierKind::Underscore, _) => (),
-        }
-    }
-    def = match def {
-        // HACK: resolve trait impl items to the item def of the trait definition
-        // so that we properly resolve all trait item references
-        Definition::ModuleDef(mod_def) => mod_def
-            .as_assoc_item(sema.db)
-            .and_then(|it| it.containing_trait_impl(sema.db))
-            .and_then(|it| {
-                it.items(sema.db).into_iter().find_map(|it| match (it, mod_def) {
-                    (hir::AssocItem::Function(trait_func), ModuleDef::Function(func))
-                        if trait_func.name(sema.db) == func.name(sema.db) =>
-                    {
-                        Some(Definition::ModuleDef(ModuleDef::Function(trait_func)))
-                    }
-                    (hir::AssocItem::Const(trait_konst), ModuleDef::Const(konst))
-                        if trait_konst.name(sema.db) == konst.name(sema.db) =>
-                    {
-                        Some(Definition::ModuleDef(ModuleDef::Const(trait_konst)))
-                    }
-                    (
-                        hir::AssocItem::TypeAlias(trait_type_alias),
-                        ModuleDef::TypeAlias(type_alias),
-                    ) if trait_type_alias.name(sema.db) == type_alias.name(sema.db) => {
-                        Some(Definition::ModuleDef(ModuleDef::TypeAlias(trait_type_alias)))
-                    }
-                    _ => None,
-                })
-            })
-            .unwrap_or(def),
-        _ => def,
-    };
-    let usages = def.usages(sema).all();
-    if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
-        cov_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(usages.iter().map(|(&file_id, references)| {
-        (file_id, source_edit_from_references(&references, def, new_name))
-    }));
-    let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
-    source_change.insert_source_edit(file_id, edit);
-    Ok(source_change)
-}
 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");
@@ -398,8 +204,15 @@ fn rename_self_to_param(
    local: hir::Local,
    self_param: hir::SelfParam,
    new_name: &str,
-    identifier_kind: IdentifierKind,
 ) -> RenameResult<SourceChange> {
+    if new_name == "self" {
+        // Let's do nothing rather than complain.
+        cov_mark::hit!(rename_self_to_self);
+        return Ok(SourceChange::default());
+    }
+    let identifier_kind = IdentifierKind::classify(new_name)?;
    let InFile { file_id, value: self_param } =
        self_param.source(sema.db).ok_or_else(|| format_err!("cannot find function source"))?;
@@ -413,7 +226,7 @@ fn rename_self_to_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)| {
-        (file_id, source_edit_from_references(&references, def, new_name))
+        (file_id, source_edit_from_references(references, def, new_name))
    }));
    Ok(source_change)
 }
@@ -426,7 +239,7 @@ fn text_edit_from_self_param(self_param: &ast::SelfParam, new_name: &str) -> Opt
        None
    }
-    let impl_def = self_param.syntax().ancestors().find_map(|it| ast::Impl::cast(it))?;
+    let impl_def = self_param.syntax().ancestors().find_map(ast::Impl::cast)?;
    let type_name = target_type_name(&impl_def)?;
    let mut replacement_text = String::from(new_name);
@@ -441,150 +254,6 @@ fn text_edit_from_self_param(self_param: &ast::SelfParam, new_name: &str) -> Opt
    Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))
 }
-fn source_edit_from_references(
-    references: &[FileReference],
-    def: Definition,
-    new_name: &str,
-) -> TextEdit {
-    let mut edit = TextEdit::builder();
-    for reference in references {
-        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)
-            }
-            ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => {
-                source_edit_from_name(name, new_name)
-            }
-            _ => None,
-        }
-        .unwrap_or_else(|| (reference.range, new_name.to_string()));
-        edit.replace(range, replacement);
-    }
-    edit.finish()
-}
-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()),
-                [new_name, ": "].concat(),
-            ));
-        }
-    }
-    None
-}
-fn source_edit_from_name_ref(
-    name_ref: &ast::NameRef,
-    new_name: &str,
-    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 {
-                        cov_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()));
-                    }
-                } else if init == *name_ref {
-                    if field_name.text() == new_name {
-                        cov_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(_)) => {
-                cov_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(_)) => {
-                cov_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) {
-                    cov_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 source_edit_from_def(
-    sema: &Semantics<RootDatabase>,
-    def: Definition,
-    new_name: &str,
-) -> RenameResult<(FileId, TextEdit)> {
-    let nav =
-        def.try_to_nav(sema.db).ok_or_else(|| format_err!("No references found at position"))?;
-    let mut replacement_text = String::new();
-    let mut repl_range =
-        nav.focus_range.ok_or_else(|| format_err!("No identifier available to rename"))?;
-    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)]
 mod tests {
    use expect_test::{expect, Expect};
@@ -659,7 +328,7 @@ mod tests {
    fn test_prepare_rename_namelikes() {
        check_prepare(r"fn name$0<'lifetime>() {}", expect![[r#"3..7: name"#]]);
        check_prepare(r"fn name<'lifetime$0>() {}", expect![[r#"8..17: 'lifetime"#]]);
-        check_prepare(r"fn name<'lifetime>() { name$0(); }", expect![[r#"23..27: name"#]]);
+        check_prepare(r"fn name<'lifetime>() { name$0(); }", expect![[r#"3..7: name"#]]);
    }
    #[test]
@@ -691,7 +360,7 @@ fn baz() {
    x.0$0 = 5;
 }
 "#,
-            expect![[r#"No identifier available to rename"#]],
+            expect![[r#"No references found at position"#]],
        );
    }
@@ -703,7 +372,7 @@ fn foo() {
    let x: i32$0 = 0;
 }
 "#,
-            expect![[r#"Cannot rename builtin type"#]],
+            expect![[r#"No references found at position"#]],
        );
    }
@@ -719,7 +388,7 @@ impl Foo {
    }
 }
 "#,
-            expect![[r#"Cannot rename `Self`"#]],
+            expect![[r#"No references found at position"#]],
        );
    }
@@ -801,7 +470,6 @@ impl Foo {
    #[test]
    fn test_rename_for_local() {
-        cov_mark::check!(rename_local);
        check(
            "k",
            r#"
@@ -2101,4 +1769,22 @@ fn f() { <()>::BAR$0; }"#,
            res,
        );
    }
+    #[test]
+    fn macros_are_broken_lol() {
+        cov_mark::check!(macros_are_broken_lol);
+        check(
+            "lol",
+            r#"
+macro_rules! m { () => { fn f() {} } }
+m!();
+fn main() { f$0()  }
+"#,
+            r#"
+macro_rules! m { () => { fn f() {} } }
+lol
+fn main() { lol()  }
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 552054951..03faabadc 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -158,7 +158,7 @@ fn find_related_tests(
    search_scope: Option<SearchScope>,
    tests: &mut FxHashSet<Runnable>,
 ) {
-    if let Some(refs) = references::find_all_refs(&sema, position, search_scope) {
+    if let Some(refs) = references::find_all_refs(sema, position, search_scope) {
        for (file_id, refs) in refs.references {
            let file = sema.parse(file_id);
            let file = file.syntax();
@@ -169,10 +169,10 @@ fn find_related_tests(
            });
            for fn_def in functions {
-                if let Some(runnable) = as_test_runnable(&sema, &fn_def) {
+                if let Some(runnable) = as_test_runnable(sema, &fn_def) {
                    // direct test
                    tests.insert(runnable);
-                } else if let Some(module) = parent_test_module(&sema, &fn_def) {
+                } else if let Some(module) = parent_test_module(sema, &fn_def) {
                    // indirect test
                    find_related_tests_in_module(sema, &fn_def, &module, tests);
                }
@@ -203,7 +203,7 @@ fn find_related_tests_in_module(
 }
 fn as_test_runnable(sema: &Semantics<RootDatabase>, fn_def: &ast::Fn) -> Option<Runnable> {
-    if test_related_attribute(&fn_def).is_some() {
+    if test_related_attribute(fn_def).is_some() {
        let function = sema.to_def(fn_def)?;
        runnable_fn(sema, function)
    } else {
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index b03f1c71f..e186b82b7 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -323,7 +323,7 @@ fn traverse(
        if let Some(token) = element.as_token().cloned().and_then(ast::String::cast) {
            if token.is_raw() {
                let expanded = element_to_highlight.as_token().unwrap().clone();
-                if inject::ra_fixture(hl, &sema, token, expanded).is_some() {
+                if inject::ra_fixture(hl, sema, token, expanded).is_some() {
                    continue;
                }
            }
@@ -334,7 +334,7 @@ fn traverse(
        }
        if let Some((mut highlight, binding_hash)) = highlight::element(
-            &sema,
+            sema,
            krate,
            &mut bindings_shadow_count,
            syntactic_name_ref_highlighting,
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 9503c936d..6834fe11a 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -48,7 +48,13 @@ pub(super) fn element(
            match name_kind {
                Some(NameClass::ExternCrate(_)) => SymbolKind::Module.into(),
                Some(NameClass::Definition(def)) => {
-                    highlight_def(db, krate, def) | HlMod::Definition
+                    let mut h = highlight_def(db, krate, def) | HlMod::Definition;
+                    if let Definition::ModuleDef(hir::ModuleDef::Trait(trait_)) = &def {
+                        if trait_.is_unsafe(db) {
+                            h |= HlMod::Unsafe;
+                        }
+                    }
+                    h
                }
                Some(NameClass::ConstReference(def)) => highlight_def(db, krate, def),
                Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
@@ -87,20 +93,34 @@ pub(super) fn element(
                            let mut h = highlight_def(db, krate, def);
-                            if let Definition::Local(local) = &def {
+                            match def {
-                                if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
+                                Definition::Local(local)
+                                    if is_consumed_lvalue(
+                                        name_ref.syntax().clone().into(),
+                                        &local,
+                                        db,
+                                    ) =>
+                                {
                                    h |= HlMod::Consuming;
                                }
-                            }
+                                Definition::ModuleDef(hir::ModuleDef::Trait(trait_))
+                                    if trait_.is_unsafe(db) =>
-                            if let Some(parent) = name_ref.syntax().parent() {
+                                {
-                                if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
+                                    if ast::Impl::for_trait_name_ref(&name_ref).is_some() {
-                                    if let Definition::Field(field) = def {
+                                        h |= HlMod::Unsafe;
-                                        if let hir::VariantDef::Union(_) = field.parent_def(db) {
+                                    }
-                                            h |= HlMod::Unsafe;
+                                }
+                                Definition::Field(field) => {
+                                    if let Some(parent) = name_ref.syntax().parent() {
+                                        if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
+                                            if let hir::VariantDef::Union(_) = field.parent_def(db)
+                                            {
+                                                h |= HlMod::Unsafe;
+                                            }
                                        }
                                    }
                                }
+                                _ => (),
                            }
                            h
@@ -131,6 +151,9 @@ pub(super) fn element(
        }
        STRING | BYTE_STRING => HlTag::StringLiteral.into(),
        ATTR => HlTag::Attribute.into(),
+        INT_NUMBER if element.ancestors().nth(1).map_or(false, |it| it.kind() == FIELD_EXPR) => {
+            SymbolKind::Field.into()
+        }
        INT_NUMBER | FLOAT_NUMBER => HlTag::NumericLiteral.into(),
        BYTE => HlTag::ByteLiteral.into(),
        CHAR => HlTag::CharLiteral.into(),
@@ -351,15 +374,7 @@ fn highlight_def(db: &RootDatabase, krate: Option<hir::Crate>, def: Definition)
                h
            }
-            hir::ModuleDef::Trait(trait_) => {
+            hir::ModuleDef::Trait(_) => Highlight::new(HlTag::Symbol(SymbolKind::Trait)),
-                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Trait));
-                if trait_.is_unsafe(db) {
-                    h |= HlMod::Unsafe;
-                }
-                h
-            }
            hir::ModuleDef::TypeAlias(type_) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
@@ -446,12 +461,12 @@ fn highlight_method_call(
    krate: Option<hir::Crate>,
    method_call: &ast::MethodCallExpr,
 ) -> Option<Highlight> {
-    let func = sema.resolve_method_call(&method_call)?;
+    let func = sema.resolve_method_call(method_call)?;
    let mut h = SymbolKind::Function.into();
    h |= HlMod::Associated;
-    if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) {
+    if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(method_call) {
        h |= HlMod::Unsafe;
    }
    if func.is_async(sema.db) {
@@ -523,11 +538,9 @@ fn highlight_name_ref_by_syntax(
    };
    match parent.kind() {
-        METHOD_CALL_EXPR => {
+        METHOD_CALL_EXPR => ast::MethodCallExpr::cast(parent)
-            return ast::MethodCallExpr::cast(parent)
+            .and_then(|it| highlight_method_call(sema, krate, &it))
-                .and_then(|it| highlight_method_call(sema, krate, &it))
+            .unwrap_or_else(|| SymbolKind::Function.into()),
-                .unwrap_or_else(|| SymbolKind::Function.into());
-        }
        FIELD_EXPR => {
            let h = HlTag::Symbol(SymbolKind::Field);
            let is_union = ast::FieldExpr::cast(parent)
diff --git a/crates/ide/src/syntax_highlighting/html.rs b/crates/ide/src/syntax_highlighting/html.rs
index 5327af845..21376a7ae 100644
--- a/crates/ide/src/syntax_highlighting/html.rs
+++ b/crates/ide/src/syntax_highlighting/html.rs
@@ -23,7 +23,7 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
    let hl_ranges = highlight(db, file_id, None, false);
    let text = parse.tree().syntax().to_string();
    let mut buf = String::new();
-    buf.push_str(&STYLE);
+    buf.push_str(STYLE);
    buf.push_str("<pre><code>");
    for r in &hl_ranges {
        let chunk = html_escape(&text[r.range]);
@@ -67,6 +67,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
diff --git a/crates/ide/src/syntax_highlighting/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
index 4269d339e..ec43c8579 100644
--- a/crates/ide/src/syntax_highlighting/inject.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -23,7 +23,7 @@ pub(super) fn ra_fixture(
    literal: ast::String,
    expanded: SyntaxToken,
 ) -> Option<()> {
-    let active_parameter = ActiveParameter::at_token(&sema, expanded)?;
+    let active_parameter = ActiveParameter::at_token(sema, expanded)?;
    if !active_parameter.ident().map_or(false, |name| name.text().starts_with("ra_fixture")) {
        return None;
    }
@@ -124,7 +124,7 @@ pub(super) fn doc_comment(
    }
    for attr in attributes.by_key("doc").attrs() {
-        let InFile { file_id, value: src } = attrs_source_map.source_of(&attr);
+        let InFile { file_id, value: src } = attrs_source_map.source_of(attr);
        if file_id != node.file_id {
            continue;
        }
@@ -232,7 +232,7 @@ fn find_doc_string_in_attr(attr: &hir::Attr, it: &ast::Attr) -> Option<ast::Stri
                    string.text().get(1..string.text().len() - 1).map_or(false, |it| it == text)
                })
        }
-        _ => return None,
+        _ => None,
    }
 }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
index a0ea1db34..4e85f7c0b 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
@@ -15,6 +15,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 921a956e6..79a285107 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -15,6 +15,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
index ca9bb1e7d..13f589cc0 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
@@ -15,6 +15,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
index 6202a03ce..50df376ae 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
@@ -15,6 +15,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
index e860d713e..96cb09642 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -15,6 +15,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index 68165bdbf..55453468b 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -15,6 +15,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
@@ -61,6 +62,11 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="field declaration">a</span><span class="colon">:</span> <span class="builtin_type">u16</span><span class="comma">,</span>
 <span class="brace">}</span>
+<span class="keyword unsafe">unsafe</span> <span class="keyword">trait</span> <span class="trait declaration unsafe">UnsafeTrait</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="keyword unsafe">unsafe</span> <span class="keyword">impl</span> <span class="trait unsafe">UnsafeTrait</span> <span class="keyword">for</span> <span class="struct">Packed</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="keyword">fn</span> <span class="function declaration">require_unsafe_trait</span><span class="angle">&lt;</span><span class="type_param declaration">T</span><span class="colon">:</span> <span class="trait">UnsafeTrait</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="punctuation">_</span><span class="colon">:</span> <span class="type_param">T</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="keyword">trait</span> <span class="trait declaration">DoTheAutoref</span> <span class="brace">{</span>
    <span class="keyword">fn</span> <span class="function associated declaration trait">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword declaration">self</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 <span class="brace">}</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index a7b5c3b89..9232cf905 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -15,6 +15,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
@@ -215,8 +216,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">let</span> <span class="variable callable declaration">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param declaration">x</span><span class="punctuation">|</span> <span class="value_param">x</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="variable callable declaration">bar</span> <span class="operator">=</span> <span class="struct">Foo</span><span class="operator">::</span><span class="function associated">baz</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="numeric_literal">-</span><span class="numeric_literal">42</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="parenthesis">(</span><span class="numeric_literal">-</span><span class="numeric_literal">42</span><span class="comma">,</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="operator">-</span><span class="variable">baz</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="operator">-</span><span class="variable">baz</span><span class="operator">.</span><span class="field">0</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="logical">!</span><span class="bool_literal">true</span><span class="semicolon">;</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/injection.html b/crates/ide/src/syntax_highlighting/test_data/injection.html
index 9ab46d05c..082837328 100644
--- a/crates/ide/src/syntax_highlighting/test_data/injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/injection.html
@@ -15,6 +15,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
index 666b0b228..763917714 100644
--- a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
@@ -15,6 +15,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .field              { color: #94BFF3; }
 .function           { color: #93E0E3; }
 .function.unsafe    { color: #BC8383; }
+.trait.unsafe       { color: #BC8383; }
 .operator.unsafe    { color: #BC8383; }
 .parameter          { color: #94BFF3; }
 .text               { color: #DCDCCC; }
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 6ad2a362a..4f0b1ce85 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -189,8 +189,8 @@ fn main() {
    let a = |x| x;
    let bar = Foo::baz;
-    let baz = -42;
+    let baz = (-42,);
-    let baz = -baz;
+    let baz = -baz.0;
    let _ = !true;
@@ -527,6 +527,11 @@ struct Packed {
    a: u16,
 }
+unsafe trait UnsafeTrait {}
+unsafe impl UnsafeTrait for Packed {}
+fn require_unsafe_trait<T: UnsafeTrait>(_: T) {}
 trait DoTheAutoref {
    fn calls_autoref(&self);
 }
diff --git a/crates/ide/src/typing/on_enter.rs b/crates/ide/src/typing/on_enter.rs
index 81c4d95b1..5cba9d11d 100644
--- a/crates/ide/src/typing/on_enter.rs
+++ b/crates/ide/src/typing/on_enter.rs
@@ -88,12 +88,12 @@ fn on_enter_in_comment(
        if comment.text().ends_with(' ') {
            cov_mark::hit!(continues_end_of_line_comment_with_space);
            remove_trailing_whitespace = true;
-        } else if !followed_by_comment(&comment) {
+        } else if !followed_by_comment(comment) {
            return None;
        }
    }
-    let indent = node_indent(&file, comment.syntax())?;
+    let indent = node_indent(file, comment.syntax())?;
    let inserted = format!("\n{}{} $0", indent, prefix);
    let delete = if remove_trailing_whitespace {
        let trimmed_len = comment.text().trim_end().len() as u32;
@@ -188,7 +188,7 @@ mod tests {
    use crate::fixture;
    fn apply_on_enter(before: &str) -> Option<String> {
-        let (analysis, position) = fixture::position(&before);
+        let (analysis, position) = fixture::position(before);
        let result = analysis.on_enter(position).unwrap()?;
        let mut actual = analysis.file_text(position.file_id).unwrap().to_string();