79 files changed, 3511 insertions, 3187 deletions

diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index da4afb5eb..d56b20b83 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -9,8 +9,8 @@ use test_utils::{
 use vfs::{file_set::FileSet, VfsPath};
 
 use crate::{
-    input::CrateName, Change, CrateGraph, CrateId, Edition, Env, FileId, FilePosition, FileRange,
-    SourceDatabaseExt, SourceRoot, SourceRootId,
+    input::CrateName, Change, CrateDisplayName, CrateGraph, CrateId, Edition, Env, FileId,
+    FilePosition, FileRange, SourceDatabaseExt, SourceRoot, SourceRootId,
 };
 
 pub const WORKSPACE: SourceRootId = SourceRootId(0);
@@ -24,6 +24,14 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
         (db, fixture.files[0])
     }
 
+    fn with_many_files(ra_fixture: &str) -> (Self, Vec<FileId>) {
+        let fixture = ChangeFixture::parse(ra_fixture);
+        let mut db = Self::default();
+        fixture.change.apply(&mut db);
+        assert!(fixture.file_position.is_none());
+        (db, fixture.files)
+    }
+
     fn with_files(ra_fixture: &str) -> Self {
         let fixture = ChangeFixture::parse(ra_fixture);
         let mut db = Self::default();
@@ -73,7 +81,7 @@ pub struct ChangeFixture {
 
 impl ChangeFixture {
     pub fn parse(ra_fixture: &str) -> ChangeFixture {
-        let fixture = Fixture::parse(ra_fixture);
+        let (mini_core, fixture) = Fixture::parse(ra_fixture);
         let mut change = Change::new();
 
         let mut files = Vec::new();
@@ -158,6 +166,31 @@ impl ChangeFixture {
             }
         }
 
+        if let Some(mini_core) = mini_core {
+            let core_file = file_id;
+            file_id.0 += 1;
+
+            let mut fs = FileSet::default();
+            fs.insert(core_file, VfsPath::new_virtual_path("/sysroot/core/lib.rs".to_string()));
+            roots.push(SourceRoot::new_library(fs));
+
+            change.change_file(core_file, Some(Arc::new(mini_core.source_code())));
+
+            let all_crates = crate_graph.crates_in_topological_order();
+
+            let core_crate = crate_graph.add_crate_root(
+                core_file,
+                Edition::Edition2021,
+                Some(CrateDisplayName::from_canonical_name("core".to_string())),
+                CfgOptions::default(),
+                Env::default(),
+                Vec::new(),
+            );
+
+            for krate in all_crates {
+                crate_graph.add_dep(krate, CrateName::new("core").unwrap(), core_crate).unwrap();
+            }
+        }
         roots.push(SourceRoot::new_local(mem::take(&mut file_set)));
         change.set_roots(roots);
         change.set_crate_graph(crate_graph);
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index dc10a4d0f..197149c5e 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -127,7 +127,7 @@ impl HasSource for Impl {
 }
 
 impl HasSource for TypeParam {
-    type Ast = Either<ast::Trait, ast::TypeParam>;
+    type Ast = Either<ast::TypeParam, ast::Trait>;
     fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
         let child_source = self.id.parent.child_source(db.upcast());
         Some(child_source.map(|it| it[self.id.local_id].clone()))
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index 6933f6e3c..0f04b2bae 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -92,7 +92,7 @@ pub enum WherePredicateTypeTarget {
 
 #[derive(Default)]
 pub(crate) struct SourceMap {
-    pub(crate) type_params: ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>,
+    pub(crate) type_params: ArenaMap<LocalTypeParamId, Either<ast::TypeParam, ast::Trait>>,
     lifetime_params: ArenaMap<LocalLifetimeParamId, ast::LifetimeParam>,
     const_params: ArenaMap<LocalConstParamId, ast::ConstParam>,
 }
@@ -199,7 +199,7 @@ impl GenericParams {
                     default: None,
                     provenance: TypeParamProvenance::TraitSelf,
                 });
-                sm.type_params.insert(self_param_id, Either::Left(src.value.clone()));
+                sm.type_params.insert(self_param_id, Either::Right(src.value.clone()));
                 // add super traits as bounds on Self
                 // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                 let self_param = TypeRef::Path(name![Self].into());
@@ -277,7 +277,7 @@ impl GenericParams {
                 provenance: TypeParamProvenance::TypeParamList,
             };
             let param_id = self.types.alloc(param);
-            sm.type_params.insert(param_id, Either::Right(type_param.clone()));
+            sm.type_params.insert(param_id, Either::Left(type_param.clone()));
 
             let type_ref = TypeRef::Path(name.into());
             self.fill_bounds(lower_ctx, &type_param, Either::Left(type_ref));
@@ -413,7 +413,7 @@ impl GenericParams {
 }
 
 impl HasChildSource<LocalTypeParamId> for GenericDefId {
-    type Value = Either<ast::Trait, ast::TypeParam>;
+    type Value = Either<ast::TypeParam, ast::Trait>;
     fn child_source(
         &self,
         db: &dyn DefDatabase,
@@ -449,7 +449,7 @@ impl ChildBySource for GenericDefId {
         let sm = sm.as_ref();
         for (local_id, src) in sm.value.type_params.iter() {
             let id = TypeParamId { parent: *self, local_id };
-            if let Either::Right(type_param) = src {
+            if let Either::Left(type_param) = src {
                 res[keys::TYPE_PARAM].insert(sm.with_value(type_param.clone()), id)
             }
         }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 3f90bda74..5b1386406 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -674,7 +674,7 @@ impl<'a> Ctx<'a> {
                     default: None,
                     provenance: TypeParamProvenance::TraitSelf,
                 });
-                sm.type_params.insert(self_param_id, Either::Left(trait_def.clone()));
+                sm.type_params.insert(self_param_id, Either::Right(trait_def.clone()));
                 // add super traits as bounds on Self
                 // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                 let self_param = TypeRef::Path(name![Self].into());
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 6fab58f15..fc2c50fb8 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -1992,8 +1992,8 @@ mod tests {
         collector.def_map
     }
 
-    fn do_resolve(code: &str) -> DefMap {
-        let (db, _file_id) = TestDB::with_single_file(code);
+    fn do_resolve(not_ra_fixture: &str) -> DefMap {
+        let (db, _file_id) = TestDB::with_single_file(not_ra_fixture);
         let krate = db.test_crate();
 
         let edition = db.crate_graph()[krate].edition;
@@ -2005,24 +2005,37 @@ mod tests {
     fn test_macro_expand_will_stop_1() {
         do_resolve(
             r#"
-        macro_rules! foo {
-            ($($ty:ty)*) => { foo!($($ty)*); }
-        }
-        foo!(KABOOM);
-        "#,
+macro_rules! foo {
+    ($($ty:ty)*) => { foo!($($ty)*); }
+}
+foo!(KABOOM);
+"#,
+        );
+        do_resolve(
+            r#"
+macro_rules! foo {
+    ($($ty:ty)*) => { foo!(() $($ty)*); }
+}
+foo!(KABOOM);
+"#,
         );
     }
 
-    #[ignore] // this test does succeed, but takes quite a while :/
+    #[ignore]
     #[test]
     fn test_macro_expand_will_stop_2() {
+        // FIXME: this test does succeed, but takes quite a while: 90 seconds in
+        // the release mode. That's why the argument is not an ra_fixture --
+        // otherwise injection highlighting gets stuck.
+        //
+        // We need to find a way to fail this faster.
         do_resolve(
             r#"
-        macro_rules! foo {
-            ($($ty:ty)*) => { foo!($($ty)* $($ty)*); }
-        }
-        foo!(KABOOM);
-        "#,
+macro_rules! foo {
+    ($($ty:ty)*) => { foo!($($ty)* $($ty)*); }
+}
+foo!(KABOOM);
+"#,
         );
     }
 }
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index a1894e8d8..74129eb21 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -20,7 +20,7 @@ rustc-hash = "1.1.0"
 scoped-tls = "1"
 chalk-solve = { version = "0.68", default-features = false }
 chalk-ir = "0.68"
-chalk-recursive = "0.68"
+chalk-recursive = { version = "0.68", default-features = false }
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 once_cell = { version = "1.5.0" }
 
diff --git a/crates/hir_ty/src/tests/coercion.rs b/crates/hir_ty/src/tests/coercion.rs
index 71047703d..713b74165 100644
--- a/crates/hir_ty/src/tests/coercion.rs
+++ b/crates/hir_ty/src/tests/coercion.rs
@@ -23,38 +23,29 @@ fn infer_block_expr_type_mismatch() {
 fn coerce_places() {
     check_infer(
         r#"
-        struct S<T> { a: T }
+//- minicore: coerce_unsized
+struct S<T> { a: T }
 
-        fn f<T>(_: &[T]) -> T { loop {} }
-        fn g<T>(_: S<&[T]>) -> T { loop {} }
+fn f<T>(_: &[T]) -> T { loop {} }
+fn g<T>(_: S<&[T]>) -> T { loop {} }
 
-        fn gen<T>() -> *mut [T; 2] { loop {} }
-        fn test1<U>() -> *mut [U] {
-            gen()
-        }
-
-        fn test2() {
-            let arr: &[u8; 1] = &[1];
-
-            let a: &[_] = arr;
-            let b = f(arr);
-            let c: &[_] = { arr };
-            let d = g(S { a: arr });
-            let e: [&[_]; 1] = [arr];
-            let f: [&[_]; 2] = [arr; 2];
-            let g: (&[_], &[_]) = (arr, arr);
-        }
+fn gen<T>() -> *mut [T; 2] { loop {} }
+fn test1<U>() -> *mut [U] {
+    gen()
+}
 
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
+fn test2() {
+    let arr: &[u8; 1] = &[1];
 
-        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
-        "#,
+    let a: &[_] = arr;
+    let b = f(arr);
+    let c: &[_] = { arr };
+    let d = g(S { a: arr });
+    let e: [&[_]; 1] = [arr];
+    let f: [&[_]; 2] = [arr; 2];
+    let g: (&[_], &[_]) = (arr, arr);
+}
+"#,
         expect![[r#"
             30..31 '_': &[T]
             44..55 '{ loop {} }': T
@@ -131,60 +122,52 @@ fn infer_let_stmt_coerce() {
 fn infer_custom_coerce_unsized() {
     check_infer(
         r#"
-        struct A<T: ?Sized>(*const T);
-        struct B<T: ?Sized>(*const T);
-        struct C<T: ?Sized> { inner: *const T }
+//- minicore: coerce_unsized
+use core::{marker::Unsize, ops::CoerceUnsized};
 
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {}
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<C<U>> for C<T> {}
+struct A<T: ?Sized>(*const T);
+struct B<T: ?Sized>(*const T);
+struct C<T: ?Sized> { inner: *const T }
 
-        fn foo1<T>(x: A<[T]>) -> A<[T]> { x }
-        fn foo2<T>(x: B<[T]>) -> B<[T]> { x }
-        fn foo3<T>(x: C<[T]>) -> C<[T]> { x }
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<C<U>> for C<T> {}
 
-        fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
-            let d = foo1(a);
-            let e = foo2(b);
-            let f = foo3(c);
-        }
-
-
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
+fn foo1<T>(x: A<[T]>) -> A<[T]> { x }
+fn foo2<T>(x: B<[T]>) -> B<[T]> { x }
+fn foo3<T>(x: C<[T]>) -> C<[T]> { x }
 
-        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
-        "#,
+fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
+    let d = foo1(a);
+    let e = foo2(b);
+    let f = foo3(c);
+}
+"#,
         expect![[r#"
-            257..258 'x': A<[T]>
-            278..283 '{ x }': A<[T]>
-            280..281 'x': A<[T]>
-            295..296 'x': B<[T]>
-            316..321 '{ x }': B<[T]>
-            318..319 'x': B<[T]>
-            333..334 'x': C<[T]>
-            354..359 '{ x }': C<[T]>
-            356..357 'x': C<[T]>
-            369..370 'a': A<[u8; 2]>
-            384..385 'b': B<[u8; 2]>
-            399..400 'c': C<[u8; 2]>
-            414..480 '{     ...(c); }': ()
-            424..425 'd': A<[{unknown}]>
-            428..432 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
-            428..435 'foo1(a)': A<[{unknown}]>
-            433..434 'a': A<[u8; 2]>
-            445..446 'e': B<[u8]>
-            449..453 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
-            449..456 'foo2(b)': B<[u8]>
-            454..455 'b': B<[u8; 2]>
-            466..467 'f': C<[u8]>
-            470..474 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
-            470..477 'foo3(c)': C<[u8]>
-            475..476 'c': C<[u8; 2]>
+            306..307 'x': A<[T]>
+            327..332 '{ x }': A<[T]>
+            329..330 'x': A<[T]>
+            344..345 'x': B<[T]>
+            365..370 '{ x }': B<[T]>
+            367..368 'x': B<[T]>
+            382..383 'x': C<[T]>
+            403..408 '{ x }': C<[T]>
+            405..406 'x': C<[T]>
+            418..419 'a': A<[u8; 2]>
+            433..434 'b': B<[u8; 2]>
+            448..449 'c': C<[u8; 2]>
+            463..529 '{     ...(c); }': ()
+            473..474 'd': A<[{unknown}]>
+            477..481 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
+            477..484 'foo1(a)': A<[{unknown}]>
+            482..483 'a': A<[u8; 2]>
+            494..495 'e': B<[u8]>
+            498..502 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
+            498..505 'foo2(b)': B<[u8]>
+            503..504 'b': B<[u8; 2]>
+            515..516 'f': C<[u8]>
+            519..523 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
+            519..526 'foo3(c)': C<[u8]>
+            524..525 'c': C<[u8; 2]>
         "#]],
     );
 }
@@ -193,21 +176,16 @@ fn infer_custom_coerce_unsized() {
 fn infer_if_coerce() {
     check_infer(
         r#"
-        fn foo<T>(x: &[T]) -> &[T] { loop {} }
-        fn test() {
-            let x = if true {
-                foo(&[1])
-            } else {
-                &[1]
-            };
-        }
-
-
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        "#,
+//- minicore: unsize
+fn foo<T>(x: &[T]) -> &[T] { loop {} }
+fn test() {
+    let x = if true {
+        foo(&[1])
+    } else {
+        &[1]
+    };
+}
+"#,
         expect![[r#"
             10..11 'x': &[T]
             27..38 '{ loop {} }': &[T]
@@ -235,25 +213,16 @@ fn infer_if_coerce() {
 fn infer_if_else_coerce() {
     check_infer(
         r#"
-        fn foo<T>(x: &[T]) -> &[T] { loop {} }
-        fn test() {
-            let x = if true {
-                &[1]
-            } else {
-                foo(&[1])
-            };
-        }
-
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-
-        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
-        "#,
+//- minicore: coerce_unsized
+fn foo<T>(x: &[T]) -> &[T] { loop {} }
+fn test() {
+    let x = if true {
+        &[1]
+    } else {
+        foo(&[1])
+    };
+}
+"#,
         expect![[r#"
             10..11 'x': &[T]
             27..38 '{ loop {} }': &[T]
@@ -281,20 +250,16 @@ fn infer_if_else_coerce() {
 fn infer_match_first_coerce() {
     check_infer(
         r#"
-        fn foo<T>(x: &[T]) -> &[T] { loop {} }
-        fn test(i: i32) {
-            let x = match i {
-                2 => foo(&[2]),
-                1 => &[1],
-                _ => &[3],
-            };
-        }
-
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        "#,
+//- minicore: unsize
+fn foo<T>(x: &[T]) -> &[T] { loop {} }
+fn test(i: i32) {
+    let x = match i {
+        2 => foo(&[2]),
+        1 => &[1],
+        _ => &[3],
+    };
+}
+"#,
         expect![[r#"
             10..11 'x': &[T]
             27..38 '{ loop {} }': &[T]
@@ -329,25 +294,16 @@ fn infer_match_first_coerce() {
 fn infer_match_second_coerce() {
     check_infer(
         r#"
-        fn foo<T>(x: &[T]) -> &[T] { loop {} }
-        fn test(i: i32) {
-            let x = match i {
-                1 => &[1],
-                2 => foo(&[2]),
-                _ => &[3],
-            };
-        }
-
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T: ?Sized> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-
-        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
-        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
-        "#,
+//- minicore: coerce_unsized
+fn foo<T>(x: &[T]) -> &[T] { loop {} }
+fn test(i: i32) {
+    let x = match i {
+        1 => &[1],
+        2 => foo(&[2]),
+        _ => &[3],
+    };
+}
+"#,
         expect![[r#"
             10..11 'x': &[T]
             27..38 '{ loop {} }': &[T]
@@ -470,15 +426,15 @@ fn coerce_autoderef() {
 #[test]
 fn coerce_autoderef_generic() {
     check_infer_with_mismatches(
-        r"
-        struct Foo;
-        fn takes_ref<T>(x: &T) -> T { *x }
-        fn test() {
-            takes_ref(&Foo);
-            takes_ref(&&Foo);
-            takes_ref(&&&Foo);
-        }
-        ",
+        r#"
+struct Foo;
+fn takes_ref<T>(x: &T) -> T { *x }
+fn test() {
+    takes_ref(&Foo);
+    takes_ref(&&Foo);
+    takes_ref(&&&Foo);
+}
+"#,
         expect![[r"
             28..29 'x': &T
             40..46 '{ *x }': T
@@ -508,30 +464,29 @@ fn coerce_autoderef_generic() {
 fn coerce_autoderef_block() {
     check_infer_with_mismatches(
         r#"
-        struct String {}
-        #[lang = "deref"]
-        trait Deref { type Target; }
-        impl Deref for String { type Target = str; }
-        fn takes_ref_str(x: &str) {}
-        fn returns_string() -> String { loop {} }
-        fn test() {
-            takes_ref_str(&{ returns_string() });
-        }
-        "#,
-        expect![[r"
-            126..127 'x': &str
-            135..137 '{}': ()
-            168..179 '{ loop {} }': String
-            170..177 'loop {}': !
-            175..177 '{}': ()
-            190..235 '{     ... }); }': ()
-            196..209 'takes_ref_str': fn takes_ref_str(&str)
-            196..232 'takes_...g() })': ()
-            210..231 '&{ ret...ng() }': &String
-            211..231 '{ retu...ng() }': String
-            213..227 'returns_string': fn returns_string() -> String
-            213..229 'return...ring()': String
-        "]],
+//- minicore: deref
+struct String {}
+impl core::ops::Deref for String { type Target = str; }
+fn takes_ref_str(x: &str) {}
+fn returns_string() -> String { loop {} }
+fn test() {
+    takes_ref_str(&{ returns_string() });
+}
+"#,
+        expect![[r#"
+            90..91 'x': &str
+            99..101 '{}': ()
+            132..143 '{ loop {} }': String
+            134..141 'loop {}': !
+            139..141 '{}': ()
+            154..199 '{     ... }); }': ()
+            160..173 'takes_ref_str': fn takes_ref_str(&str)
+            160..196 'takes_...g() })': ()
+            174..195 '&{ ret...ng() }': &String
+            175..195 '{ retu...ng() }': String
+            177..191 'returns_string': fn returns_string() -> String
+            177..193 'return...ring()': String
+        "#]],
     );
 }
 
@@ -674,25 +629,19 @@ fn coerce_placeholder_ref() {
 fn coerce_unsize_array() {
     check_infer_with_mismatches(
         r#"
-        #[lang = "unsize"]
-        pub trait Unsize<T> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
-
-        fn test() {
-            let f: &[usize] = &[1, 2, 3];
-        }
+//- minicore: coerce_unsized
+fn test() {
+    let f: &[usize] = &[1, 2, 3];
+}
         "#,
         expect![[r#"
-            161..198 '{     ... 3]; }': ()
-            171..172 'f': &[usize]
-            185..195 '&[1, 2, 3]': &[usize; 3]
-            186..195 '[1, 2, 3]': [usize; 3]
-            187..188 '1': usize
-            190..191 '2': usize
-            193..194 '3': usize
+            10..47 '{     ... 3]; }': ()
+            20..21 'f': &[usize]
+            34..44 '&[1, 2, 3]': &[usize; 3]
+            35..44 '[1, 2, 3]': [usize; 3]
+            36..37 '1': usize
+            39..40 '2': usize
+            42..43 '3': usize
         "#]],
     );
 }
@@ -701,93 +650,94 @@ fn coerce_unsize_array() {
 fn coerce_unsize_trait_object_simple() {
     check_infer_with_mismatches(
         r#"
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
-
-        trait Foo<T, U> {}
-        trait Bar<U, T, X>: Foo<T, U> {}
-        trait Baz<T, X>: Bar<usize, T, X> {}
-
-        struct S<T, X>;
-        impl<T, X> Foo<T, usize> for S<T, X> {}
-        impl<T, X> Bar<usize, T, X> for S<T, X> {}
-        impl<T, X> Baz<T, X> for S<T, X> {}
-
-        fn test() {
-            let obj: &dyn Baz<i8, i16> = &S;
-            let obj: &dyn Bar<_, i8, i16> = &S;
-            let obj: &dyn Foo<i8, _> = &S;
-        }
-        "#,
-        expect![[r"
-            424..539 '{     ... &S; }': ()
-            434..437 'obj': &dyn Baz<i8, i16>
-            459..461 '&S': &S<i8, i16>
-            460..461 'S': S<i8, i16>
-            471..474 'obj': &dyn Bar<usize, i8, i16>
-            499..501 '&S': &S<i8, i16>
-            500..501 'S': S<i8, i16>
-            511..514 'obj': &dyn Foo<i8, usize>
-            534..536 '&S': &S<i8, {unknown}>
-            535..536 'S': S<i8, {unknown}>
-        "]],
+//- minicore: coerce_unsized
+trait Foo<T, U> {}
+trait Bar<U, T, X>: Foo<T, U> {}
+trait Baz<T, X>: Bar<usize, T, X> {}
+
+struct S<T, X>;
+impl<T, X> Foo<T, usize> for S<T, X> {}
+impl<T, X> Bar<usize, T, X> for S<T, X> {}
+impl<T, X> Baz<T, X> for S<T, X> {}
+
+fn test() {
+    let obj: &dyn Baz<i8, i16> = &S;
+    let obj: &dyn Bar<_, i8, i16> = &S;
+    let obj: &dyn Foo<i8, _> = &S;
+}
+"#,
+        expect![[r#"
+            236..351 '{     ... &S; }': ()
+            246..249 'obj': &dyn Baz<i8, i16>
+            271..273 '&S': &S<i8, i16>
+            272..273 'S': S<i8, i16>
+            283..286 'obj': &dyn Bar<usize, i8, i16>
+            311..313 '&S': &S<i8, i16>
+            312..313 'S': S<i8, i16>
+            323..326 'obj': &dyn Foo<i8, usize>
+            346..348 '&S': &S<i8, {unknown}>
+            347..348 'S': S<i8, {unknown}>
+        "#]],
     );
 }
 
 #[test]
-// The rust reference says this should be possible, but rustc doesn't implement
-// it. We used to support it, but Chalk doesn't.
-#[ignore]
 fn coerce_unsize_trait_object_to_trait_object() {
+    // FIXME: The rust reference says this should be possible, but rustc doesn't
+    // implement it. We used to support it, but Chalk doesn't. Here's the
+    // correct expect:
+    //
+    //     424..609 '{     ...bj2; }': ()
+    //     434..437 'obj': &dyn Baz<i8, i16>
+    //     459..461 '&S': &S<i8, i16>
+    //     460..461 'S': S<i8, i16>
+    //     471..474 'obj': &dyn Bar<usize, i8, i16>
+    //     496..499 'obj': &dyn Baz<i8, i16>
+    //     509..512 'obj': &dyn Foo<i8, usize>
+    //     531..534 'obj': &dyn Bar<usize, i8, i16>
+    //     544..548 'obj2': &dyn Baz<i8, i16>
+    //     570..572 '&S': &S<i8, i16>
+    //     571..572 'S': S<i8, i16>
+    //     582..583 '_': &dyn Foo<i8, usize>
+    //     602..606 'obj2': &dyn Baz<i8, i16>
     check_infer_with_mismatches(
         r#"
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
-
-        trait Foo<T, U> {}
-        trait Bar<U, T, X>: Foo<T, U> {}
-        trait Baz<T, X>: Bar<usize, T, X> {}
-
-        struct S<T, X>;
-        impl<T, X> Foo<T, usize> for S<T, X> {}
-        impl<T, X> Bar<usize, T, X> for S<T, X> {}
-        impl<T, X> Baz<T, X> for S<T, X> {}
-
-        fn test() {
-            let obj: &dyn Baz<i8, i16> = &S;
-            let obj: &dyn Bar<_, _, _> = obj;
-            let obj: &dyn Foo<_, _> = obj;
-            let obj2: &dyn Baz<i8, i16> = &S;
-            let _: &dyn Foo<_, _> = obj2;
-        }
-        "#,
-        expect![[r"
-            424..609 '{     ...bj2; }': ()
-            434..437 'obj': &dyn Baz<i8, i16>
-            459..461 '&S': &S<i8, i16>
-            460..461 'S': S<i8, i16>
-            471..474 'obj': &dyn Bar<usize, i8, i16>
-            496..499 'obj': &dyn Baz<i8, i16>
-            509..512 'obj': &dyn Foo<i8, usize>
-            531..534 'obj': &dyn Bar<usize, i8, i16>
-            544..548 'obj2': &dyn Baz<i8, i16>
-            570..572 '&S': &S<i8, i16>
-            571..572 'S': S<i8, i16>
-            582..583 '_': &dyn Foo<i8, usize>
-            602..606 'obj2': &dyn Baz<i8, i16>
-        "]],
+//- minicore: coerce_unsized
+trait Foo<T, U> {}
+trait Bar<U, T, X>: Foo<T, U> {}
+trait Baz<T, X>: Bar<usize, T, X> {}
+
+struct S<T, X>;
+impl<T, X> Foo<T, usize> for S<T, X> {}
+impl<T, X> Bar<usize, T, X> for S<T, X> {}
+impl<T, X> Baz<T, X> for S<T, X> {}
+
+fn test() {
+    let obj: &dyn Baz<i8, i16> = &S;
+    let obj: &dyn Bar<_, _, _> = obj;
+    let obj: &dyn Foo<_, _> = obj;
+    let obj2: &dyn Baz<i8, i16> = &S;
+    let _: &dyn Foo<_, _> = obj2;
+}
+"#,
+        expect![[r#"
+            236..421 '{     ...bj2; }': ()
+            246..249 'obj': &dyn Baz<i8, i16>
+            271..273 '&S': &S<i8, i16>
+            272..273 'S': S<i8, i16>
+            283..286 'obj': &dyn Bar<{unknown}, {unknown}, {unknown}>
+            308..311 'obj': &dyn Baz<i8, i16>
+            321..324 'obj': &dyn Foo<{unknown}, {unknown}>
+            343..346 'obj': &dyn Bar<{unknown}, {unknown}, {unknown}>
+            356..360 'obj2': &dyn Baz<i8, i16>
+            382..384 '&S': &S<i8, i16>
+            383..384 'S': S<i8, i16>
+            394..395 '_': &dyn Foo<{unknown}, {unknown}>
+            414..418 'obj2': &dyn Baz<i8, i16>
+            308..311: expected &dyn Bar<{unknown}, {unknown}, {unknown}>, got &dyn Baz<i8, i16>
+            343..346: expected &dyn Foo<{unknown}, {unknown}>, got &dyn Bar<{unknown}, {unknown}, {unknown}>
+            414..418: expected &dyn Foo<{unknown}, {unknown}>, got &dyn Baz<i8, i16>
+        "#]],
     );
 }
 
@@ -795,40 +745,32 @@ fn coerce_unsize_trait_object_to_trait_object() {
 fn coerce_unsize_super_trait_cycle() {
     check_infer_with_mismatches(
         r#"
-        #[lang = "sized"]
-        pub trait Sized {}
-        #[lang = "unsize"]
-        pub trait Unsize<T> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
-
-        trait A {}
-        trait B: C + A {}
-        trait C: B {}
-        trait D: C
-
-        struct S;
-        impl A for S {}
-        impl B for S {}
-        impl C for S {}
-        impl D for S {}
-
-        fn test() {
-            let obj: &dyn D = &S;
-            let obj: &dyn A = &S;
-        }
-        "#,
-        expect![[r"
-            328..383 '{     ... &S; }': ()
-            338..341 'obj': &dyn D
-            352..354 '&S': &S
-            353..354 'S': S
-            364..367 'obj': &dyn A
-            378..380 '&S': &S
-            379..380 'S': S
-        "]],
+//- minicore: coerce_unsized
+trait A {}
+trait B: C + A {}
+trait C: B {}
+trait D: C
+
+struct S;
+impl A for S {}
+impl B for S {}
+impl C for S {}
+impl D for S {}
+
+fn test() {
+    let obj: &dyn D = &S;
+    let obj: &dyn A = &S;
+}
+"#,
+        expect![[r#"
+            140..195 '{     ... &S; }': ()
+            150..153 'obj': &dyn D
+            164..166 '&S': &S
+            165..166 'S': S
+            176..179 'obj': &dyn A
+            190..192 '&S': &S
+            191..192 'S': S
+        "#]],
     );
 }
 
@@ -837,41 +779,35 @@ fn coerce_unsize_generic() {
     // FIXME: fix the type mismatches here
     check_infer_with_mismatches(
         r#"
-        #[lang = "unsize"]
-        pub trait Unsize<T> {}
-        #[lang = "coerce_unsized"]
-        pub trait CoerceUnsized<T> {}
-
-        impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
+//- minicore: coerce_unsized
+struct Foo<T> { t: T };
+struct Bar<T>(Foo<T>);
 
-        struct Foo<T> { t: T };
-        struct Bar<T>(Foo<T>);
-
-        fn test() {
-            let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] };
-            let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] });
-        }
-        "#,
+fn test() {
+    let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] };
+    let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] });
+}
+"#,
         expect![[r#"
-            209..317 '{     ... }); }': ()
-            219..220 '_': &Foo<[usize]>
-            238..259 '&Foo {..., 3] }': &Foo<[usize]>
-            239..259 'Foo { ..., 3] }': Foo<[usize]>
-            248..257 '[1, 2, 3]': [usize; 3]
-            249..250 '1': usize
-            252..253 '2': usize
-            255..256 '3': usize
-            269..270 '_': &Bar<[usize]>
-            288..314 '&Bar(F... 3] })': &Bar<[i32; 3]>
-            289..292 'Bar': Bar<[i32; 3]>(Foo<[i32; 3]>) -> Bar<[i32; 3]>
-            289..314 'Bar(Fo... 3] })': Bar<[i32; 3]>
-            293..313 'Foo { ..., 3] }': Foo<[i32; 3]>
-            302..311 '[1, 2, 3]': [i32; 3]
-            303..304 '1': i32
-            306..307 '2': i32
-            309..310 '3': i32
-            248..257: expected [usize], got [usize; 3]
-            288..314: expected &Bar<[usize]>, got &Bar<[i32; 3]>
+            58..166 '{     ... }); }': ()
+            68..69 '_': &Foo<[usize]>
+            87..108 '&Foo {..., 3] }': &Foo<[usize]>
+            88..108 'Foo { ..., 3] }': Foo<[usize]>
+            97..106 '[1, 2, 3]': [usize; 3]
+            98..99 '1': usize
+            101..102 '2': usize
+            104..105 '3': usize
+            118..119 '_': &Bar<[usize]>
+            137..163 '&Bar(F... 3] })': &Bar<[i32; 3]>
+            138..141 'Bar': Bar<[i32; 3]>(Foo<[i32; 3]>) -> Bar<[i32; 3]>
+            138..163 'Bar(Fo... 3] })': Bar<[i32; 3]>
+            142..162 'Foo { ..., 3] }': Foo<[i32; 3]>
+            151..160 '[1, 2, 3]': [i32; 3]
+            152..153 '1': i32
+            155..156 '2': i32
+            158..159 '3': i32
+            97..106: expected [usize], got [usize; 3]
+            137..163: expected &Bar<[usize]>, got &Bar<[i32; 3]>
         "#]],
     );
 }
@@ -881,15 +817,7 @@ fn coerce_unsize_apit() {
     // FIXME: #8984
     check_infer_with_mismatches(
         r#"
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "unsize"]
-pub trait Unsize<T> {}
-#[lang = "coerce_unsized"]
-pub trait CoerceUnsized<T> {}
-
-impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
-
+//- minicore: coerce_unsized
 trait Foo {}
 
 fn test(f: impl Foo) {
@@ -897,12 +825,12 @@ fn test(f: impl Foo) {
 }
         "#,
         expect![[r#"
-            210..211 'f': impl Foo
-            223..252 '{     ... &f; }': ()
-            233..234 '_': &dyn Foo
-            247..249 '&f': &impl Foo
-            248..249 'f': impl Foo
-            247..249: expected &dyn Foo, got &impl Foo
+            22..23 'f': impl Foo
+            35..64 '{     ... &f; }': ()
+            45..46 '_': &dyn Foo
+            59..61 '&f': &impl Foo
+            60..61 'f': impl Foo
+            59..61: expected &dyn Foo, got &impl Foo
         "#]],
     );
 }
@@ -998,15 +926,7 @@ fn main() {
 fn coerce_unsize_expected_type() {
     check_no_mismatches(
         r#"
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "unsize"]
-pub trait Unsize<T> {}
-#[lang = "coerce_unsized"]
-pub trait CoerceUnsized<T> {}
-
-impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
-
+//- minicore: coerce_unsized
 fn main() {
     let foo: &[u32] = &[1, 2];
     let foo: &[u32] = match true {
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index f26b2c8a7..d9b5ee9cf 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -780,10 +780,7 @@ fn test() { (&S).foo(); }
 fn method_resolution_unsize_array() {
     check_types(
         r#"
-#[lang = "slice"]
-impl<T> [T] {
-    fn len(&self) -> usize { loop {} }
-}
+//- minicore: slice
 fn test() {
     let a = [1, 2, 3];
     a.len();
@@ -1178,11 +1175,7 @@ fn main() {
 fn autoderef_visibility_field() {
     check_infer(
         r#"
-#[lang = "deref"]
-pub trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
+//- minicore: deref
 mod a {
     pub struct Foo(pub char);
     pub struct Bar(i32);
@@ -1191,7 +1184,7 @@ mod a {
             Self(0)
         }
     }
-    impl super::Deref for Bar {
+    impl core::ops::Deref for Bar {
         type Target = Foo;
         fn deref(&self) -> &Foo {
             &Foo('z')
@@ -1205,22 +1198,21 @@ mod b {
 }
         "#,
         expect![[r#"
-            67..71 'self': &Self
-            200..231 '{     ...     }': Bar
-            214..218 'Self': Bar(i32) -> Bar
-            214..221 'Self(0)': Bar
-            219..220 '0': i32
-            315..319 'self': &Bar
-            329..362 '{     ...     }': &Foo
-            343..352 '&Foo('z')': &Foo
-            344..347 'Foo': Foo(char) -> Foo
-            344..352 'Foo('z')': Foo
-            348..351 ''z'': char
-            392..439 '{     ...     }': ()
-            406..407 'x': char
-            410..428 'super:...r::new': fn new() -> Bar
-            410..430 'super:...:new()': Bar
-            410..432 'super:...ew().0': char
+            107..138 '{     ...     }': Bar
+            121..125 'Self': Bar(i32) -> Bar
+            121..128 'Self(0)': Bar
+            126..127 '0': i32
+            226..230 'self': &Bar
+            240..273 '{     ...     }': &Foo
+            254..263 '&Foo('z')': &Foo
+            255..258 'Foo': Foo(char) -> Foo
+            255..263 'Foo('z')': Foo
+            259..262 ''z'': char
+            303..350 '{     ...     }': ()
+            317..318 'x': char
+            321..339 'super:...r::new': fn new() -> Bar
+            321..341 'super:...:new()': Bar
+            321..343 'super:...ew().0': char
         "#]],
     )
 }
@@ -1230,11 +1222,7 @@ fn autoderef_visibility_method() {
     cov_mark::check!(autoderef_candidate_not_visible);
     check_infer(
         r#"
-#[lang = "deref"]
-pub trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
+//- minicore: deref
 mod a {
     pub struct Foo(pub char);
     impl Foo {
@@ -1251,7 +1239,7 @@ mod a {
             self.0
         }
     }
-    impl super::Deref for Bar {
+    impl core::ops::Deref for Bar {
         type Target = Foo;
         fn deref(&self) -> &Foo {
             &Foo('z')
@@ -1265,30 +1253,29 @@ mod b {
 }
         "#,
         expect![[r#"
-            67..71 'self': &Self
-            168..172 'self': &Foo
-            182..212 '{     ...     }': char
-            196..200 'self': &Foo
-            196..202 'self.0': char
-            288..319 '{     ...     }': Bar
-            302..306 'Self': Bar(i32) -> Bar
-            302..309 'Self(0)': Bar
-            307..308 '0': i32
-            338..342 'self': &Bar
-            351..381 '{     ...     }': i32
-            365..369 'self': &Bar
-            365..371 'self.0': i32
-            465..469 'self': &Bar
-            479..512 '{     ...     }': &Foo
-            493..502 '&Foo('z')': &Foo
-            494..497 'Foo': Foo(char) -> Foo
-            494..502 'Foo('z')': Foo
-            498..501 ''z'': char
-            542..595 '{     ...     }': ()
-            556..557 'x': char
-            560..578 'super:...r::new': fn new() -> Bar
-            560..580 'super:...:new()': Bar
-            560..588 'super:...ango()': char
+            75..79 'self': &Foo
+            89..119 '{     ...     }': char
+            103..107 'self': &Foo
+            103..109 'self.0': char
+            195..226 '{     ...     }': Bar
+            209..213 'Self': Bar(i32) -> Bar
+            209..216 'Self(0)': Bar
+            214..215 '0': i32
+            245..249 'self': &Bar
+            258..288 '{     ...     }': i32
+            272..276 'self': &Bar
+            272..278 'self.0': i32
+            376..380 'self': &Bar
+            390..423 '{     ...     }': &Foo
+            404..413 '&Foo('z')': &Foo
+            405..408 'Foo': Foo(char) -> Foo
+            405..413 'Foo('z')': Foo
+            409..412 ''z'': char
+            453..506 '{     ...     }': ()
+            467..468 'x': char
+            471..489 'super:...r::new': fn new() -> Bar
+            471..491 'super:...:new()': Bar
+            471..499 'super:...ango()': char
         "#]],
     )
 }
diff --git a/crates/hir_ty/src/tests/regression.rs b/crates/hir_ty/src/tests/regression.rs
index 1019e783b..abd9c385a 100644
--- a/crates/hir_ty/src/tests/regression.rs
+++ b/crates/hir_ty/src/tests/regression.rs
@@ -927,35 +927,33 @@ fn issue_6628() {
 fn issue_6852() {
     check_infer(
         r#"
-        #[lang = "deref"]
-        pub trait Deref {
-            type Target;
-        }
+//- minicore: deref
+use core::ops::Deref;
 
-        struct BufWriter {}
+struct BufWriter {}
 
-        struct Mutex<T> {}
-        struct MutexGuard<'a, T> {}
-        impl<T> Mutex<T> {
-            fn lock(&self) -> MutexGuard<'_, T> {}
-        }
-        impl<'a, T: 'a> Deref for MutexGuard<'a, T> {
-            type Target = T;
-        }
-        fn flush(&self) {
-            let w: &Mutex<BufWriter>;
-            *(w.lock());
-        }
-        "#,
+struct Mutex<T> {}
+struct MutexGuard<'a, T> {}
+impl<T> Mutex<T> {
+    fn lock(&self) -> MutexGuard<'_, T> {}
+}
+impl<'a, T: 'a> Deref for MutexGuard<'a, T> {
+    type Target = T;
+}
+fn flush(&self) {
+    let w: &Mutex<BufWriter>;
+    *(w.lock());
+}
+"#,
         expect![[r#"
-            156..160 'self': &Mutex<T>
-            183..185 '{}': ()
-            267..271 'self': &{unknown}
-            273..323 '{     ...()); }': ()
-            283..284 'w': &Mutex<BufWriter>
-            309..320 '*(w.lock())': BufWriter
-            311..312 'w': &Mutex<BufWriter>
-            311..319 'w.lock()': MutexGuard<BufWriter>
+            123..127 'self': &Mutex<T>
+            150..152 '{}': ()
+            234..238 'self': &{unknown}
+            240..290 '{     ...()); }': ()
+            250..251 'w': &Mutex<BufWriter>
+            276..287 '*(w.lock())': BufWriter
+            278..279 'w': &Mutex<BufWriter>
+            278..286 'w.lock()': MutexGuard<BufWriter>
         "#]],
     );
 }
@@ -977,37 +975,33 @@ fn param_overrides_fn() {
 fn lifetime_from_chalk_during_deref() {
     check_types(
         r#"
-        #[lang = "deref"]
-        pub trait Deref {
-            type Target;
-        }
-
-        struct Box<T: ?Sized> {}
-        impl<T> Deref for Box<T> {
-            type Target = T;
+//- minicore: deref
+struct Box<T: ?Sized> {}
+impl<T> core::ops::Deref for Box<T> {
+    type Target = T;
 
-            fn deref(&self) -> &Self::Target {
-                loop {}
-            }
-        }
+    fn deref(&self) -> &Self::Target {
+        loop {}
+    }
+}
 
-        trait Iterator {
-            type Item;
-        }
+trait Iterator {
+    type Item;
+}
 
-        pub struct Iter<'a, T: 'a> {
-            inner: Box<dyn IterTrait<'a, T, Item = &'a T> + 'a>,
-        }
+pub struct Iter<'a, T: 'a> {
+    inner: Box<dyn IterTrait<'a, T, Item = &'a T> + 'a>,
+}
 
-        trait IterTrait<'a, T: 'a>: Iterator<Item = &'a T> {
-            fn clone_box(&self);
-        }
+trait IterTrait<'a, T: 'a>: Iterator<Item = &'a T> {
+    fn clone_box(&self);
+}
 
-        fn clone_iter<T>(s: Iter<T>) {
-            s.inner.clone_box();
-          //^^^^^^^^^^^^^^^^^^^ ()
-        }
-        "#,
+fn clone_iter<T>(s: Iter<T>) {
+    s.inner.clone_box();
+    //^^^^^^^^^^^^^^^^^^^ ()
+}
+"#,
     )
 }
 
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 3418ed21e..68776f3c0 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -113,7 +113,7 @@ fn type_alias_in_struct_lit() {
 fn infer_ranges() {
     check_types(
         r#"
-//- /main.rs crate:main deps:core
+//- minicore: range
 fn test() {
     let a = ..;
     let b = 1..;
@@ -125,32 +125,6 @@ fn test() {
     let t = (a, b, c, d, e, f);
     t;
 } //^ (RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>)
-
-//- /core.rs crate:core
-#[prelude_import] use prelude::*;
-mod prelude {}
-
-pub mod ops {
-    pub struct Range<Idx> {
-        pub start: Idx,
-        pub end: Idx,
-    }
-    pub struct RangeFrom<Idx> {
-        pub start: Idx,
-    }
-    struct RangeFull;
-    pub struct RangeInclusive<Idx> {
-        start: Idx,
-        end: Idx,
-        is_empty: u8,
-    }
-    pub struct RangeTo<Idx> {
-        pub end: Idx,
-    }
-    pub struct RangeToInclusive<Idx> {
-        pub end: Idx,
-    }
-}
 "#,
     );
 }
@@ -175,16 +149,17 @@ fn test() {
 fn infer_basics() {
     check_infer(
         r#"
-        fn test(a: u32, b: isize, c: !, d: &str) {
-            a;
-            b;
-            c;
-            d;
-            1usize;
-            1isize;
-            "test";
-            1.0f32;
-        }"#,
+fn test(a: u32, b: isize, c: !, d: &str) {
+    a;
+    b;
+    c;
+    d;
+    1usize;
+    1isize;
+    "test";
+    1.0f32;
+}
+"#,
         expect![[r#"
             8..9 'a': u32
             16..17 'b': isize
@@ -207,15 +182,15 @@ fn infer_basics() {
 fn infer_let() {
     check_infer(
         r#"
-        fn test() {
-            let a = 1isize;
-            let b: usize = 1;
-            let c = b;
-            let d: u32;
-            let e;
-            let f: i32 = e;
-        }
-        "#,
+fn test() {
+    let a = 1isize;
+    let b: usize = 1;
+    let c = b;
+    let d: u32;
+    let e;
+    let f: i32 = e;
+}
+"#,
         expect![[r#"
             10..117 '{     ...= e; }': ()
             20..21 'a': isize
@@ -236,17 +211,17 @@ fn infer_let() {
 fn infer_paths() {
     check_infer(
         r#"
-        fn a() -> u32 { 1 }
+fn a() -> u32 { 1 }
 
-        mod b {
-            fn c() -> u32 { 1 }
-        }
+mod b {
+    fn c() -> u32 { 1 }
+}
 
-        fn test() {
-            a();
-            b::c();
-        }
-        "#,
+fn test() {
+    a();
+    b::c();
+}
+"#,
         expect![[r#"
             14..19 '{ 1 }': u32
             16..17 '1': u32
@@ -265,17 +240,17 @@ fn infer_paths() {
 fn infer_path_type() {
     check_infer(
         r#"
-        struct S;
+struct S;
 
-        impl S {
-            fn foo() -> i32 { 1 }
-        }
+impl S {
+    fn foo() -> i32 { 1 }
+}
 
-        fn test() {
-            S::foo();
-            <S>::foo();
-        }
-        "#,
+fn test() {
+    S::foo();
+    <S>::foo();
+}
+"#,
         expect![[r#"
             40..45 '{ 1 }': i32
             42..43 '1': i32
@@ -292,21 +267,21 @@ fn infer_path_type() {
 fn infer_struct() {
     check_infer(
         r#"
-        struct A {
-            b: B,
-            c: C,
-        }
-        struct B;
-        struct C(usize);
+struct A {
+    b: B,
+    c: C,
+}
+struct B;
+struct C(usize);
 
-        fn test() {
-            let c = C(1);
-            B;
-            let a: A = A { b: B, c: C(1) };
-            a.b;
-            a.c;
-        }
-        "#,
+fn test() {
+    let c = C(1);
+    B;
+    let a: A = A { b: B, c: C(1) };
+    a.b;
+    a.c;
+}
+"#,
         expect![[r#"
             71..153 '{     ...a.c; }': ()
             81..82 'c': C
@@ -332,14 +307,15 @@ fn infer_struct() {
 fn infer_enum() {
     check_infer(
         r#"
-        enum E {
-            V1 { field: u32 },
-            V2
-        }
-        fn test() {
-            E::V1 { field: 1 };
-            E::V2;
-        }"#,
+enum E {
+    V1 { field: u32 },
+    V2
+}
+fn test() {
+    E::V1 { field: 1 };
+    E::V2;
+}
+"#,
         expect![[r#"
             51..89 '{     ...:V2; }': ()
             57..75 'E::V1 ...d: 1 }': E
@@ -353,23 +329,23 @@ fn infer_enum() {
 fn infer_union() {
     check_infer(
         r#"
-        union MyUnion {
-            foo: u32,
-            bar: f32,
-        }
+union MyUnion {
+    foo: u32,
+    bar: f32,
+}
 
-        fn test() {
-            let u = MyUnion { foo: 0 };
-            unsafe { baz(u); }
-            let u = MyUnion { bar: 0.0 };
-            unsafe { baz(u); }
-        }
+fn test() {
+    let u = MyUnion { foo: 0 };
+    unsafe { baz(u); }
+    let u = MyUnion { bar: 0.0 };
+    unsafe { baz(u); }
+}
 
-        unsafe fn baz(u: MyUnion) {
-            let inner = u.foo;
-            let inner = u.bar;
-        }
-        "#,
+unsafe fn baz(u: MyUnion) {
+    let inner = u.foo;
+    let inner = u.bar;
+}
+"#,
         expect![[r#"
             57..172 '{     ...); } }': ()
             67..68 'u': MyUnion
@@ -404,19 +380,19 @@ fn infer_union() {
 fn infer_refs() {
     check_infer(
         r#"
-        fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
-            a;
-            *a;
-            &a;
-            &mut a;
-            b;
-            *b;
-            &b;
-            c;
-            *c;
-            d;
-            *d;
-        }
+fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
+    a;
+    *a;
+    &a;
+    &mut a;
+    b;
+    *b;
+    &b;
+    c;
+    *c;
+    d;
+    *d;
+}
         "#,
         expect![[r#"
             8..9 'a': &u32
@@ -450,11 +426,11 @@ fn infer_refs() {
 fn infer_raw_ref() {
     check_infer(
         r#"
-        fn test(a: i32) {
-            &raw mut a;
-            &raw const a;
-        }
-        "#,
+fn test(a: i32) {
+    &raw mut a;
+    &raw const a;
+}
+"#,
         expect![[r#"
             8..9 'a': i32
             16..53 '{     ...t a; }': ()
@@ -524,26 +500,26 @@ h";
 fn infer_unary_op() {
     check_infer(
         r#"
-        enum SomeType {}
-
-        fn test(x: SomeType) {
-            let b = false;
-            let c = !b;
-            let a = 100;
-            let d: i128 = -a;
-            let e = -100;
-            let f = !!!true;
-            let g = !42;
-            let h = !10u32;
-            let j = !a;
-            -3.14;
-            !3;
-            -x;
-            !x;
-            -"hello";
-            !"hello";
-        }
-        "#,
+enum SomeType {}
+
+fn test(x: SomeType) {
+    let b = false;
+    let c = !b;
+    let a = 100;
+    let d: i128 = -a;
+    let e = -100;
+    let f = !!!true;
+    let g = !42;
+    let h = !10u32;
+    let j = !a;
+    -3.14;
+    !3;
+    -x;
+    !x;
+    -"hello";
+    !"hello";
+}
+"#,
         expect![[r#"
             26..27 'x': SomeType
             39..271 '{     ...lo"; }': ()
@@ -594,19 +570,19 @@ fn infer_unary_op() {
 fn infer_backwards() {
     check_infer(
         r#"
-        fn takes_u32(x: u32) {}
+fn takes_u32(x: u32) {}
 
-        struct S { i32_field: i32 }
+struct S { i32_field: i32 }
 
-        fn test() -> &mut &f64 {
-            let a = unknown_function();
-            takes_u32(a);
-            let b = unknown_function();
-            S { i32_field: b };
-            let c = unknown_function();
-            &mut &c
-        }
-        "#,
+fn test() -> &mut &f64 {
+    let a = unknown_function();
+    takes_u32(a);
+    let b = unknown_function();
+    S { i32_field: b };
+    let c = unknown_function();
+    &mut &c
+}
+"#,
         expect![[r#"
             13..14 'x': u32
             21..23 '{}': ()
@@ -636,23 +612,23 @@ fn infer_backwards() {
 fn infer_self() {
     check_infer(
         r#"
-        struct S;
+struct S;
 
-        impl S {
-            fn test(&self) {
-                self;
-            }
-            fn test2(self: &Self) {
-                self;
-            }
-            fn test3() -> Self {
-                S {}
-            }
-            fn test4() -> Self {
-                Self {}
-            }
-        }
-        "#,
+impl S {
+    fn test(&self) {
+        self;
+    }
+    fn test2(self: &Self) {
+        self;
+    }
+    fn test3() -> Self {
+        S {}
+    }
+    fn test4() -> Self {
+        Self {}
+    }
+}
+"#,
         expect![[r#"
             33..37 'self': &S
             39..60 '{     ...     }': ()
@@ -672,30 +648,30 @@ fn infer_self() {
 fn infer_self_as_path() {
     check_infer(
         r#"
-        struct S1;
-        struct S2(isize);
-        enum E {
-            V1,
-            V2(u32),
-        }
+struct S1;
+struct S2(isize);
+enum E {
+    V1,
+    V2(u32),
+}
 
-        impl S1 {
-            fn test() {
-                Self;
-            }
-        }
-        impl S2 {
-            fn test() {
-                Self(1);
-            }
-        }
-        impl E {
-            fn test() {
-                Self::V1;
-                Self::V2(1);
-            }
-        }
-        "#,
+impl S1 {
+    fn test() {
+        Self;
+    }
+}
+impl S2 {
+    fn test() {
+        Self(1);
+    }
+}
+impl E {
+    fn test() {
+        Self::V1;
+        Self::V2(1);
+    }
+}
+"#,
         expect![[r#"
             86..107 '{     ...     }': ()
             96..100 'Self': S1
@@ -716,26 +692,26 @@ fn infer_self_as_path() {
 fn infer_binary_op() {
     check_infer(
         r#"
-        fn f(x: bool) -> i32 {
-            0i32
-        }
+fn f(x: bool) -> i32 {
+    0i32
+}
 
-        fn test() -> bool {
-            let x = a && b;
-            let y = true || false;
-            let z = x == y;
-            let t = x != y;
-            let minus_forty: isize = -40isize;
-            let h = minus_forty <= CONST_2;
-            let c = f(z || y) + 5;
-            let d = b;
-            let g = minus_forty ^= i;
-            let ten: usize = 10;
-            let ten_is_eleven = ten == some_num;
-
-            ten < 3
-        }
-        "#,
+fn test() -> bool {
+    let x = a && b;
+    let y = true || false;
+    let z = x == y;
+    let t = x != y;
+    let minus_forty: isize = -40isize;
+    let h = minus_forty <= CONST_2;
+    let c = f(z || y) + 5;
+    let d = b;
+    let g = minus_forty ^= i;
+    let ten: usize = 10;
+    let ten_is_eleven = ten == some_num;
+
+    ten < 3
+}
+"#,
         expect![[r#"
             5..6 'x': bool
             21..33 '{     0i32 }': i32
@@ -795,11 +771,11 @@ fn infer_binary_op() {
 fn infer_shift_op() {
     check_infer(
         r#"
-        fn test() {
-            1u32 << 5u8;
-            1u32 >> 5u8;
-        }
-        "#,
+fn test() {
+    1u32 << 5u8;
+    1u32 >> 5u8;
+}
+"#,
         expect![[r#"
             10..47 '{     ...5u8; }': ()
             16..20 '1u32': u32
@@ -816,29 +792,29 @@ fn infer_shift_op() {
 fn infer_field_autoderef() {
     check_infer(
         r#"
-        struct A {
-            b: B,
-        }
-        struct B;
-
-        fn test1(a: A) {
-            let a1 = a;
-            a1.b;
-            let a2 = &a;
-            a2.b;
-            let a3 = &mut a;
-            a3.b;
-            let a4 = &&&&&&&a;
-            a4.b;
-            let a5 = &mut &&mut &&mut a;
-            a5.b;
-        }
+struct A {
+    b: B,
+}
+struct B;
 
-        fn test2(a1: *const A, a2: *mut A) {
-            a1.b;
-            a2.b;
-        }
-        "#,
+fn test1(a: A) {
+    let a1 = a;
+    a1.b;
+    let a2 = &a;
+    a2.b;
+    let a3 = &mut a;
+    a3.b;
+    let a4 = &&&&&&&a;
+    a4.b;
+    let a5 = &mut &&mut &&mut a;
+    a5.b;
+}
+
+fn test2(a1: *const A, a2: *mut A) {
+    a1.b;
+    a2.b;
+}
+"#,
         expect![[r#"
             43..44 'a': A
             49..212 '{     ...5.b; }': ()
@@ -891,58 +867,53 @@ fn infer_field_autoderef() {
 fn infer_argument_autoderef() {
     check_infer(
         r#"
-        #[lang = "deref"]
-        pub trait Deref {
-            type Target;
-            fn deref(&self) -> &Self::Target;
-        }
-
-        struct A<T>(T);
+//- minicore: deref
+use core::ops::Deref;
+struct A<T>(T);
 
-        impl<T> A<T> {
-            fn foo(&self) -> &T {
-                &self.0
-            }
-        }
+impl<T> A<T> {
+    fn foo(&self) -> &T {
+        &self.0
+    }
+}
 
-        struct B<T>(T);
+struct B<T>(T);
 
-        impl<T> Deref for B<T> {
-            type Target = T;
-            fn deref(&self) -> &Self::Target {
-                &self.0
-            }
-        }
+impl<T> Deref for B<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
 
-        fn test() {
-            let t = A::foo(&&B(B(A(42))));
-        }
-        "#,
+fn test() {
+    let t = A::foo(&&B(B(A(42))));
+}
+"#,
         expect![[r#"
-            67..71 'self': &Self
-            138..142 'self': &A<T>
-            150..173 '{     ...     }': &T
-            160..167 '&self.0': &T
-            161..165 'self': &A<T>
-            161..167 'self.0': T
-            254..258 'self': &B<T>
-            277..300 '{     ...     }': &T
-            287..294 '&self.0': &T
-            288..292 'self': &B<T>
-            288..294 'self.0': T
-            314..352 '{     ...))); }': ()
-            324..325 't': &i32
-            328..334 'A::foo': fn foo<i32>(&A<i32>) -> &i32
-            328..349 'A::foo...42))))': &i32
-            335..348 '&&B(B(A(42)))': &&B<B<A<i32>>>
-            336..348 '&B(B(A(42)))': &B<B<A<i32>>>
-            337..338 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
-            337..348 'B(B(A(42)))': B<B<A<i32>>>
-            339..340 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
-            339..347 'B(A(42))': B<A<i32>>
-            341..342 'A': A<i32>(i32) -> A<i32>
-            341..346 'A(42)': A<i32>
-            343..345 '42': i32
+            66..70 'self': &A<T>
+            78..101 '{     ...     }': &T
+            88..95 '&self.0': &T
+            89..93 'self': &A<T>
+            89..95 'self.0': T
+            182..186 'self': &B<T>
+            205..228 '{     ...     }': &T
+            215..222 '&self.0': &T
+            216..220 'self': &B<T>
+            216..222 'self.0': T
+            242..280 '{     ...))); }': ()
+            252..253 't': &i32
+            256..262 'A::foo': fn foo<i32>(&A<i32>) -> &i32
+            256..277 'A::foo...42))))': &i32
+            263..276 '&&B(B(A(42)))': &&B<B<A<i32>>>
+            264..276 '&B(B(A(42)))': &B<B<A<i32>>>
+            265..266 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
+            265..276 'B(B(A(42)))': B<B<A<i32>>>
+            267..268 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
+            267..275 'B(A(42))': B<A<i32>>
+            269..270 'A': A<i32>(i32) -> A<i32>
+            269..274 'A(42)': A<i32>
+            271..273 '42': i32
         "#]],
     );
 }
@@ -951,62 +922,57 @@ fn infer_argument_autoderef() {
 fn infer_method_argument_autoderef() {
     check_infer(
         r#"
-        #[lang = "deref"]
-        pub trait Deref {
-            type Target;
-            fn deref(&self) -> &Self::Target;
-        }
+//- minicore: deref
+use core::ops::Deref;
+struct A<T>(*mut T);
 
-        struct A<T>(*mut T);
-
-        impl<T> A<T> {
-            fn foo(&self, x: &A<T>) -> &T {
-                &*x.0
-            }
-        }
+impl<T> A<T> {
+    fn foo(&self, x: &A<T>) -> &T {
+        &*x.0
+    }
+}
 
-        struct B<T>(T);
+struct B<T>(T);
 
-        impl<T> Deref for B<T> {
-            type Target = T;
-            fn deref(&self) -> &Self::Target {
-                &self.0
-            }
-        }
+impl<T> Deref for B<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
 
-        fn test(a: A<i32>) {
-            let t = A(0 as *mut _).foo(&&B(B(a)));
-        }
-        "#,
+fn test(a: A<i32>) {
+    let t = A(0 as *mut _).foo(&&B(B(a)));
+}
+"#,
         expect![[r#"
-            67..71 'self': &Self
-            143..147 'self': &A<T>
-            149..150 'x': &A<T>
-            165..186 '{     ...     }': &T
-            175..180 '&*x.0': &T
-            176..180 '*x.0': T
-            177..178 'x': &A<T>
-            177..180 'x.0': *mut T
-            267..271 'self': &B<T>
-            290..313 '{     ...     }': &T
-            300..307 '&self.0': &T
-            301..305 'self': &B<T>
-            301..307 'self.0': T
-            325..326 'a': A<i32>
-            336..382 '{     ...))); }': ()
-            346..347 't': &i32
-            350..351 'A': A<i32>(*mut i32) -> A<i32>
-            350..364 'A(0 as *mut _)': A<i32>
-            350..379 'A(0 as...B(a)))': &i32
-            352..353 '0': i32
-            352..363 '0 as *mut _': *mut i32
-            369..378 '&&B(B(a))': &&B<B<A<i32>>>
-            370..378 '&B(B(a))': &B<B<A<i32>>>
-            371..372 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
-            371..378 'B(B(a))': B<B<A<i32>>>
-            373..374 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
-            373..377 'B(a)': B<A<i32>>
-            375..376 'a': A<i32>
+            71..75 'self': &A<T>
+            77..78 'x': &A<T>
+            93..114 '{     ...     }': &T
+            103..108 '&*x.0': &T
+            104..108 '*x.0': T
+            105..106 'x': &A<T>
+            105..108 'x.0': *mut T
+            195..199 'self': &B<T>
+            218..241 '{     ...     }': &T
+            228..235 '&self.0': &T
+            229..233 'self': &B<T>
+            229..235 'self.0': T
+            253..254 'a': A<i32>
+            264..310 '{     ...))); }': ()
+            274..275 't': &i32
+            278..279 'A': A<i32>(*mut i32) -> A<i32>
+            278..292 'A(0 as *mut _)': A<i32>
+            278..307 'A(0 as...B(a)))': &i32
+            280..281 '0': i32
+            280..291 '0 as *mut _': *mut i32
+            297..306 '&&B(B(a))': &&B<B<A<i32>>>
+            298..306 '&B(B(a))': &B<B<A<i32>>>
+            299..300 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
+            299..306 'B(B(a))': B<B<A<i32>>>
+            301..302 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
+            301..305 'B(a)': B<A<i32>>
+            303..304 'a': A<i32>
         "#]],
     );
 }
@@ -1015,15 +981,15 @@ fn infer_method_argument_autoderef() {
 fn infer_in_elseif() {
     check_infer(
         r#"
-        struct Foo { field: i32 }
-        fn main(foo: Foo) {
-            if true {
+struct Foo { field: i32 }
+fn main(foo: Foo) {
+    if true {
 
-            } else if false {
-                foo.field
-            }
-        }
-        "#,
+    } else if false {
+        foo.field
+    }
+}
+"#,
         expect![[r#"
             34..37 'foo': Foo
             44..108 '{     ...   } }': ()
@@ -1043,28 +1009,29 @@ fn infer_in_elseif() {
 fn infer_if_match_with_return() {
     check_infer(
         r#"
-        fn foo() {
-            let _x1 = if true {
-                1
-            } else {
-                return;
-            };
-            let _x2 = if true {
-                2
-            } else {
-                return
-            };
-            let _x3 = match true {
-                true => 3,
-                _ => {
-                    return;
-                }
-            };
-            let _x4 = match true {
-                true => 4,
-                _ => return
-            };
-        }"#,
+fn foo() {
+    let _x1 = if true {
+        1
+    } else {
+        return;
+    };
+    let _x2 = if true {
+        2
+    } else {
+        return
+    };
+    let _x3 = match true {
+        true => 3,
+        _ => {
+            return;
+        }
+    };
+    let _x4 = match true {
+        true => 4,
+        _ => return
+    };
+}
+"#,
         expect![[r#"
             9..322 '{     ...  }; }': ()
             19..22 '_x1': i32
@@ -2639,11 +2606,8 @@ fn f() {
 fn infer_boxed_self_receiver() {
     check_infer(
         r#"
-#[lang = "deref"]
-pub trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
+//- minicore: deref
+use core::ops::Deref;
 
 struct Box<T>(T);
 
@@ -2675,40 +2639,39 @@ fn main() {
 }
         "#,
         expect![[r#"
-            67..71 'self': &Self
-            175..179 'self': &Box<T>
-            259..263 'self': &Box<Foo<T>>
-            289..291 '{}': ()
-            313..317 'self': &Box<Foo<T>>
-            346..348 '{}': ()
-            368..372 'self': Box<Foo<T>>
-            393..395 '{}': ()
-            409..630 '{     ...r(); }': ()
-            419..424 'boxed': Box<Foo<i32>>
-            427..430 'Box': Box<Foo<i32>>(Foo<i32>) -> Box<Foo<i32>>
-            427..442 'Box(Foo(0_i32))': Box<Foo<i32>>
-            431..434 'Foo': Foo<i32>(i32) -> Foo<i32>
-            431..441 'Foo(0_i32)': Foo<i32>
-            435..440 '0_i32': i32
-            453..457 'bad1': &i32
-            460..465 'boxed': Box<Foo<i32>>
-            460..477 'boxed....nner()': &i32
-            487..492 'good1': &i32
-            495..509 'Foo::get_inner': fn get_inner<i32>(&Box<Foo<i32>>) -> &i32
-            495..517 'Foo::g...boxed)': &i32
-            510..516 '&boxed': &Box<Foo<i32>>
-            511..516 'boxed': Box<Foo<i32>>
-            528..532 'bad2': &Foo<i32>
-            535..540 'boxed': Box<Foo<i32>>
-            535..551 'boxed....self()': &Foo<i32>
-            561..566 'good2': &Foo<i32>
-            569..582 'Foo::get_self': fn get_self<i32>(&Box<Foo<i32>>) -> &Foo<i32>
-            569..590 'Foo::g...boxed)': &Foo<i32>
-            583..589 '&boxed': &Box<Foo<i32>>
-            584..589 'boxed': Box<Foo<i32>>
-            601..606 'inner': Foo<i32>
-            609..614 'boxed': Box<Foo<i32>>
-            609..627 'boxed....nner()': Foo<i32>
+            104..108 'self': &Box<T>
+            188..192 'self': &Box<Foo<T>>
+            218..220 '{}': ()
+            242..246 'self': &Box<Foo<T>>
+            275..277 '{}': ()
+            297..301 'self': Box<Foo<T>>
+            322..324 '{}': ()
+            338..559 '{     ...r(); }': ()
+            348..353 'boxed': Box<Foo<i32>>
+            356..359 'Box': Box<Foo<i32>>(Foo<i32>) -> Box<Foo<i32>>
+            356..371 'Box(Foo(0_i32))': Box<Foo<i32>>
+            360..363 'Foo': Foo<i32>(i32) -> Foo<i32>
+            360..370 'Foo(0_i32)': Foo<i32>
+            364..369 '0_i32': i32
+            382..386 'bad1': &i32
+            389..394 'boxed': Box<Foo<i32>>
+            389..406 'boxed....nner()': &i32
+            416..421 'good1': &i32
+            424..438 'Foo::get_inner': fn get_inner<i32>(&Box<Foo<i32>>) -> &i32
+            424..446 'Foo::g...boxed)': &i32
+            439..445 '&boxed': &Box<Foo<i32>>
+            440..445 'boxed': Box<Foo<i32>>
+            457..461 'bad2': &Foo<i32>
+            464..469 'boxed': Box<Foo<i32>>
+            464..480 'boxed....self()': &Foo<i32>
+            490..495 'good2': &Foo<i32>
+            498..511 'Foo::get_self': fn get_self<i32>(&Box<Foo<i32>>) -> &Foo<i32>
+            498..519 'Foo::g...boxed)': &Foo<i32>
+            512..518 '&boxed': &Box<Foo<i32>>
+            513..518 'boxed': Box<Foo<i32>>
+            530..535 'inner': Foo<i32>
+            538..543 'boxed': Box<Foo<i32>>
+            538..556 'boxed....nner()': Foo<i32>
         "#]],
     );
 }
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 6bcede4c4..65fed02d2 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -6,10 +6,10 @@ use super::{check_infer, check_infer_with_mismatches, check_types};
 fn infer_await() {
     check_types(
         r#"
-//- /main.rs crate:main deps:core
+//- minicore: future
 struct IntFuture;
 
-impl Future for IntFuture {
+impl core::future::Future for IntFuture {
     type Output = u64;
 }
 
@@ -18,16 +18,6 @@ fn test() {
     let v = r.await;
     v;
 } //^ u64
-
-//- /core.rs crate:core
-pub mod prelude {
-    pub mod rust_2018 {
-        #[lang = "future_trait"]
-        pub trait Future {
-            type Output;
-        }
-    }
-}
 "#,
     );
 }
@@ -36,25 +26,14 @@ pub mod prelude {
 fn infer_async() {
     check_types(
         r#"
-//- /main.rs crate:main deps:core
-async fn foo() -> u64 {
-            128
-}
+//- minicore: future
+async fn foo() -> u64 { 128 }
 
 fn test() {
     let r = foo();
     let v = r.await;
     v;
 } //^ u64
-
-//- /core.rs crate:core
-#[prelude_import] use future::*;
-mod future {
-    #[lang = "future_trait"]
-    trait Future {
-        type Output;
-    }
-}
 "#,
     );
 }
@@ -63,24 +42,13 @@ mod future {
 fn infer_desugar_async() {
     check_types(
         r#"
-//- /main.rs crate:main deps:core
-async fn foo() -> u64 {
-            128
-}
+//- minicore: future
+async fn foo() -> u64 { 128 }
 
 fn test() {
     let r = foo();
     r;
 } //^ impl Future<Output = u64>
-
-//- /core.rs crate:core
-#[prelude_import] use future::*;
-mod future {
-    trait Future {
-        type Output;
-    }
-}
-
 "#,
     );
 }
@@ -89,7 +57,7 @@ mod future {
 fn infer_async_block() {
     check_types(
         r#"
-//- /main.rs crate:main deps:core
+//- minicore: future, option
 async fn test() {
     let a = async { 42 };
     a;
@@ -101,7 +69,7 @@ async fn test() {
     b;
 //  ^ ()
     let c = async {
-        let y = Option::None;
+        let y = None;
         y
     //  ^ Option<u64>
     };
@@ -109,18 +77,6 @@ async fn test() {
     c;
 //  ^ impl Future<Output = Option<u64>>
 }
-
-enum Option<T> { None, Some(T) }
-
-//- /core.rs crate:core
-#[prelude_import] use future::*;
-mod future {
-    #[lang = "future_trait"]
-    trait Future {
-        type Output;
-    }
-}
-
 "#,
     );
 }
@@ -704,14 +660,9 @@ mod ops {
 fn deref_trait() {
     check_types(
         r#"
-#[lang = "deref"]
-trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
-
+//- minicore: deref
 struct Arc<T>;
-impl<T> Deref for Arc<T> {
+impl<T> core::ops::Deref for Arc<T> {
     type Target = T;
 }
 
@@ -731,16 +682,10 @@ fn test(s: Arc<S>) {
 fn deref_trait_with_inference_var() {
     check_types(
         r#"
-//- /main.rs
-#[lang = "deref"]
-trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
-
+//- minicore: deref
 struct Arc<T>;
 fn new_arc<T>() -> Arc<T> {}
-impl<T> Deref for Arc<T> {
+impl<T> core::ops::Deref for Arc<T> {
     type Target = T;
 }
 
@@ -761,15 +706,10 @@ fn test() {
 fn deref_trait_infinite_recursion() {
     check_types(
         r#"
-#[lang = "deref"]
-trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
-
+//- minicore: deref
 struct S;
 
-impl Deref for S {
+impl core::ops::Deref for S {
     type Target = S;
 }
 
@@ -784,14 +724,9 @@ fn test(s: S) {
 fn deref_trait_with_question_mark_size() {
     check_types(
         r#"
-#[lang = "deref"]
-trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
-
+//- minicore: deref
 struct Arc<T>;
-impl<T> Deref for Arc<T> {
+impl<T: ?Sized> core::ops::Deref for Arc<T> {
     type Target = T;
 }
 
@@ -1475,7 +1410,6 @@ fn test(
 }
 
 #[test]
-#[ignore]
 fn error_bound_chalk() {
     check_types(
         r#"
@@ -2626,12 +2560,9 @@ fn test<T: Trait>() {
 fn dyn_trait_through_chalk() {
     check_types(
         r#"
+//- minicore: deref
 struct Box<T> {}
-#[lang = "deref"]
-trait Deref {
-    type Target;
-}
-impl<T> Deref for Box<T> {
+impl<T> core::ops::Deref for Box<T> {
     type Target = T;
 }
 trait Trait {
@@ -3696,16 +3627,7 @@ impl foo::Foo for u32 {
 fn infer_async_ret_type() {
     check_types(
         r#"
-//- /main.rs crate:main deps:core
-
-enum Result<T, E> {
-    Ok(T),
-    Err(E),
-}
-
-use Result::*;
-
-
+//- minicore: future, result
 struct Fooey;
 
 impl Fooey {
@@ -3728,15 +3650,6 @@ async fn get_accounts() -> Result<u32, ()> {
     //                      ^ u32
     Ok(ret)
 }
-
-//- /core.rs crate:core
-#[prelude_import] use future::*;
-mod future {
-    #[lang = "future_trait"]
-    trait Future {
-        type Output;
-    }
-}
 "#,
     );
 }
diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index f12928225..0e8447394 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -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" }
 
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
deleted file mode 100644
index 815a633e5..000000000
--- a/crates/ide/src/diagnostics.rs
+++ /dev/null
@@ -1,498 +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 break_outside_of_loop;
-mod inactive_code;
-mod incorrect_case;
-mod macro_error;
-mod mismatched_arg_count;
-mod missing_fields;
-mod missing_match_arms;
-mod missing_ok_or_some_in_tail_expr;
-mod missing_unsafe;
-mod no_such_field;
-mod remove_this_semicolon;
-mod replace_filter_map_next_with_find_map;
-mod unimplemented_builtin_macro;
-mod unlinked_file;
-mod unresolved_extern_crate;
-mod unresolved_import;
-mod unresolved_macro_call;
-mod unresolved_module;
-mod unresolved_proc_macro;
-
-mod field_shorthand;
-
-use hir::{diagnostics::AnyDiagnostic, 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, TextRange,
-};
-use text_edit::TextEdit;
-use unlinked_file::UnlinkedFile;
-
-use crate::{Assist, AssistId, AssistKind, FileId, Label, SourceChange};
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct DiagnosticCode(pub &'static str);
-
-impl DiagnosticCode {
-    pub fn as_str(&self) -> &str {
-        self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct Diagnostic {
-    pub code: DiagnosticCode,
-    pub message: String,
-    pub range: TextRange,
-    pub severity: Severity,
-    pub unused: bool,
-    pub experimental: bool,
-    pub fixes: Option<Vec<Assist>>,
-}
-
-impl Diagnostic {
-    fn new(code: &'static str, message: impl Into<String>, range: TextRange) -> Diagnostic {
-        let message = message.into();
-        Diagnostic {
-            code: DiagnosticCode(code),
-            message,
-            range,
-            severity: Severity::Error,
-            unused: false,
-            experimental: false,
-            fixes: None,
-        }
-    }
-
-    fn experimental(mut self) -> Diagnostic {
-        self.experimental = true;
-        self
-    }
-
-    fn severity(mut self, severity: Severity) -> Diagnostic {
-        self.severity = severity;
-        self
-    }
-
-    fn with_fixes(mut self, fixes: Option<Vec<Assist>>) -> Diagnostic {
-        self.fixes = fixes;
-        self
-    }
-
-    fn with_unused(mut self, unused: bool) -> Diagnostic {
-        self.unused = unused;
-        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>,
-}
-
-struct DiagnosticsContext<'a> {
-    config: &'a DiagnosticsConfig,
-    sema: Semantics<'a, RootDatabase>,
-    resolve: &'a AssistResolveStrategy,
-}
-
-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::new("syntax-error", format!("Syntax Error: {}", err), err.range())
-        }),
-    );
-
-    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 mut diags = Vec::new();
-    let module = sema.to_module_def(file_id);
-    if let Some(m) = module {
-        m.diagnostics(db, &mut diags)
-    }
-
-    let ctx = DiagnosticsContext { config, sema, resolve };
-    if module.is_none() {
-        let d = UnlinkedFile { file: file_id };
-        let d = unlinked_file::unlinked_file(&ctx, &d);
-        res.push(d)
-    }
-
-    for diag in diags {
-        #[rustfmt::skip]
-        let d = match diag {
-            AnyDiagnostic::BreakOutsideOfLoop(d) => break_outside_of_loop::break_outside_of_loop(&ctx, &d),
-            AnyDiagnostic::IncorrectCase(d) => incorrect_case::incorrect_case(&ctx, &d),
-            AnyDiagnostic::MacroError(d) => macro_error::macro_error(&ctx, &d),
-            AnyDiagnostic::MismatchedArgCount(d) => mismatched_arg_count::mismatched_arg_count(&ctx, &d),
-            AnyDiagnostic::MissingFields(d) => missing_fields::missing_fields(&ctx, &d),
-            AnyDiagnostic::MissingMatchArms(d) => missing_match_arms::missing_match_arms(&ctx, &d),
-            AnyDiagnostic::MissingOkOrSomeInTailExpr(d) => missing_ok_or_some_in_tail_expr::missing_ok_or_some_in_tail_expr(&ctx, &d),
-            AnyDiagnostic::MissingUnsafe(d) => missing_unsafe::missing_unsafe(&ctx, &d),
-            AnyDiagnostic::NoSuchField(d) => no_such_field::no_such_field(&ctx, &d),
-            AnyDiagnostic::RemoveThisSemicolon(d) => remove_this_semicolon::remove_this_semicolon(&ctx, &d),
-            AnyDiagnostic::ReplaceFilterMapNextWithFindMap(d) => replace_filter_map_next_with_find_map::replace_filter_map_next_with_find_map(&ctx, &d),
-            AnyDiagnostic::UnimplementedBuiltinMacro(d) => unimplemented_builtin_macro::unimplemented_builtin_macro(&ctx, &d),
-            AnyDiagnostic::UnresolvedExternCrate(d) => unresolved_extern_crate::unresolved_extern_crate(&ctx, &d),
-            AnyDiagnostic::UnresolvedImport(d) => unresolved_import::unresolved_import(&ctx, &d),
-            AnyDiagnostic::UnresolvedMacroCall(d) => unresolved_macro_call::unresolved_macro_call(&ctx, &d),
-            AnyDiagnostic::UnresolvedModule(d) => unresolved_module::unresolved_module(&ctx, &d),
-            AnyDiagnostic::UnresolvedProcMacro(d) => unresolved_proc_macro::unresolved_proc_macro(&ctx, &d),
-
-            AnyDiagnostic::InactiveCode(d) => match inactive_code::inactive_code(&ctx, &d) {
-                Some(it) => it,
-                None => continue,
-            }
-        };
-        res.push(d)
-    }
-
-    res.retain(|d| {
-        !ctx.config.disabled.contains(d.code.as_str())
-            && !(ctx.config.disable_experimental && d.experimental)
-    });
-
-    res
-}
-
-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::new(
-                "unnecessary-braces",
-                "Unnecessary braces in use statement".to_string(),
-                use_range,
-            )
-            .severity(Severity::WeakWarning)
-            .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()
-            .expect("no diagnostics");
-        let fix = &diagnostic.fixes.expect("diagnostic misses fixes")[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`.
-    pub(crate) 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);
-    }
-
-    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)
-    }
-
-    #[track_caller]
-    pub(crate) fn check_diagnostics(ra_fixture: &str) {
-        let mut config = DiagnosticsConfig::default();
-        config.disabled.insert("inactive-code".to_string());
-        check_diagnostics_with_config(config, ra_fixture)
-    }
-
-    #[track_caller]
-    pub(crate) fn check_diagnostics_with_config(config: DiagnosticsConfig, ra_fixture: &str) {
-        let (analysis, files) = fixture::files(ra_fixture);
-        for file_id in files {
-            let diagnostics =
-                analysis.diagnostics(&config, AssistResolveStrategy::All, file_id).unwrap();
-
-            let expected = extract_annotations(&*analysis.file_text(file_id).unwrap());
-            let mut actual =
-                diagnostics.into_iter().map(|d| (d.range, d.message)).collect::<Vec<_>>();
-            actual.sort_by_key(|(range, _)| range.start());
-            assert_eq!(expected, actual);
-        }
-    }
-
-    #[test]
-    fn test_check_unnecessary_braces_in_use_statement() {
-        check_diagnostics(
-            r#"
-use a;
-use a::{c, d::e};
-
-mod a {
-    mod c {}
-    mod d {
-        mod e {}
-    }
-}
-"#,
-        );
-        check_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 import_extern_crate_clash_with_inner_item() {
-        // This is more of a resolver test, but doesn't really work with the hir_def testsuite.
-
-        check_diagnostics(
-            r#"
-//- /lib.rs crate:lib deps:jwt
-mod permissions;
-
-use permissions::jwt;
-
-fn f() {
-    fn inner() {}
-    jwt::Claims {}; // should resolve to the local one with 0 fields, and not get a diagnostic
-}
-
-//- /permissions.rs
-pub mod jwt  {
-    pub struct Claims {}
-}
-
-//- /jwt/lib.rs crate:jwt
-pub struct Claims {
-    field: u8,
-}
-        "#,
-        );
-    }
-}
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()),
-            Either::Right(it) => it.syntax().text_range(),
+                .map_or_else(|| trait_.syntax().text_range(), |name| name.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 57ae9455b..7ac0118fe 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -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/fixture.rs b/crates/ide/src/fixture.rs
index 38e2e866b..cf679edd3 100644
--- a/crates/ide/src/fixture.rs
+++ b/crates/ide/src/fixture.rs
@@ -12,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();
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 8dd643a0f..d8e0dc4d5 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -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)>, {}
                        //^^
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 c08516805..14cf94d60 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -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,
-                                    focus_range: 140..146,
+                                    full_range: 244..426,
+                                    focus_range: 283..289,
                                     name: "Future",
                                     kind: Trait,
                                     description: "pub trait Future",
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 0511efae3..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};
@@ -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 a0fdead2c..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,
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/rename.rs
index 6b3d02bf4..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
-//! will be calculated.
-use std::fmt::{self, Display};
-
-use either::Either;
-use hir::{AsAssocItem, FieldSource, HasSource, InFile, ModuleSource, Semantics};
+//! This is mostly front-end for [`ide_db::rename`], but it also includes the
+//! tests. This module also implements a couple of magic tricks, like renaming
+//! `self` and to `self` (to switch between associated function and method).
+use hir::{AsAssocItem, InFile, Semantics};
 use ide_db::{
-    base_db::{AnchoredPathBuf, FileId, FileRange},
+    base_db::FileId,
     defs::{Definition, NameClass, NameRefClass},
-    search::FileReference,
+    rename::{bail, format_err, source_edit_from_references, IdentifierKind},
     RootDatabase,
 };
 use stdx::never;
-use syntax::{
-    ast::{self, NameOwner},
-    lex_single_syntax_kind, AstNode, SyntaxKind, SyntaxNode, T,
-};
+use syntax::{ast, AstNode, SyntaxNode};
 
 use text_edit::TextEdit;
 
-use crate::{FilePosition, FileSystemEdit, RangeInfo, SourceChange, TextRange};
-
-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)
-    }
-}
+use crate::{FilePosition, RangeInfo, SourceChange};
 
-macro_rules! format_err {
-    ($fmt:expr) => {RenameError(format!($fmt))};
-    ($fmt:expr, $($arg:tt)+) => {RenameError(format!($fmt, $($arg)+))}
-}
+pub use ide_db::rename::RenameError;
 
-macro_rules! bail {
-    ($($tokens:tt)*) => {return Err(format_err!($($tokens)*))}
-}
+type RenameResult<T> = Result<T, RenameError>;
 
 /// 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,7 +32,8 @@ pub(crate) fn prepare_rename(
     let syntax = source_file.syntax();
 
     let def = find_definition(&sema, syntax, position)?;
-    let frange = def_name_range(&&sema, def)
+    let frange = def
+        .range_for_rename(&sema)
         .ok_or_else(|| format_err!("No references found at position"))?;
     Ok(RangeInfo::new(frange.range, ()))
 }
@@ -98,14 +79,7 @@ pub(crate) fn rename_with_semantics(
         }
     }
 
-    match def {
-        Definition::ModuleDef(hir::ModuleDef::Module(module)) => rename_mod(sema, module, new_name),
-        Definition::SelfType(_) => bail!("Cannot rename `Self`"),
-        Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => {
-            bail!("Cannot rename builtin type")
-        }
-        def => rename_reference(sema, def, new_name),
-    }
+    def.rename(sema, new_name)
 }
 
 /// Called by the client when it is about to rename a file.
@@ -116,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,
-    Underscore,
-}
-
-impl IdentifierKind {
-    fn classify(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),
-                (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,
@@ -189,126 +137,6 @@ fn find_definition(
     .ok_or_else(|| format_err!("No references found at position"))
 }
 
-fn rename_mod(
-    sema: &Semantics<RootDatabase>,
-    module: hir::Module,
-    new_name: &str,
-) -> RenameResult<SourceChange> {
-    if IdentifierKind::classify(new_name)? != IdentifierKind::Ident {
-        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(hir::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 = IdentifierKind::classify(new_name)?;
-
-    if matches!(
-        def, // is target a lifetime?
-        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
-    ) {
-        match ident_kind {
-            IdentifierKind::Ident | 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::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), hir::ModuleDef::Function(func))
-                        if trait_func.name(sema.db) == func.name(sema.db) =>
-                    {
-                        Some(Definition::ModuleDef(hir::ModuleDef::Function(trait_func)))
-                    }
-                    (hir::AssocItem::Const(trait_konst), hir::ModuleDef::Const(konst))
-                        if trait_konst.name(sema.db) == konst.name(sema.db) =>
-                    {
-                        Some(Definition::ModuleDef(hir::ModuleDef::Const(trait_konst)))
-                    }
-                    (
-                        hir::AssocItem::TypeAlias(trait_type_alias),
-                        hir::ModuleDef::TypeAlias(type_alias),
-                    ) if trait_type_alias.name(sema.db) == type_alias.name(sema.db) => {
-                        Some(Definition::ModuleDef(hir::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");
@@ -426,243 +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 frange: FileRange = def_name_range(sema, def)
-        .ok_or_else(|| format_err!("No identifier available to rename"))?;
-
-    let mut replacement_text = String::new();
-    let mut repl_range = frange.range;
-    if let Definition::Local(local) = def {
-        if let Either::Left(pat) = local.source(sema.db).value {
-            if matches!(
-                pat.syntax().parent().and_then(ast::RecordPatField::cast),
-                Some(pat_field) if pat_field.name_ref().is_none()
-            ) {
-                replacement_text.push_str(": ");
-                replacement_text.push_str(new_name);
-                repl_range = TextRange::new(
-                    pat.syntax().text_range().end(),
-                    pat.syntax().text_range().end(),
-                );
-            }
-        }
-    }
-    if replacement_text.is_empty() {
-        replacement_text.push_str(new_name);
-    }
-    let edit = TextEdit::replace(repl_range, replacement_text);
-    Ok((frange.file_id, edit))
-}
-
-fn def_name_range(sema: &Semantics<RootDatabase>, def: Definition) -> Option<FileRange> {
-    // FIXME: the `original_file_range` calls here are wrong -- they never fail,
-    // and _fall back_ to the entirety of the macro call. Such fall back is
-    // incorrect for renames. The safe behavior would be to return an error for
-    // such cases. The correct behavior would be to return an auxiliary list of
-    // "can't rename these occurrences in macros" items, and then show some kind
-    // of a dialog to the user.
-
-    let res = match def {
-        Definition::Macro(mac) => {
-            let src = mac.source(sema.db)?;
-            let name = match &src.value {
-                Either::Left(it) => it.name()?,
-                Either::Right(it) => it.name()?,
-            };
-            src.with_value(name.syntax()).original_file_range(sema.db)
-        }
-        Definition::Field(field) => {
-            let src = field.source(sema.db)?;
-
-            match &src.value {
-                FieldSource::Named(record_field) => {
-                    let name = record_field.name()?;
-                    src.with_value(name.syntax()).original_file_range(sema.db)
-                }
-                FieldSource::Pos(_) => {
-                    return None;
-                }
-            }
-        }
-        Definition::ModuleDef(module_def) => match module_def {
-            hir::ModuleDef::Module(module) => {
-                let src = module.declaration_source(sema.db)?;
-                let name = src.value.name()?;
-                src.with_value(name.syntax()).original_file_range(sema.db)
-            }
-            hir::ModuleDef::Function(it) => name_range(it, sema)?,
-            hir::ModuleDef::Adt(adt) => match adt {
-                hir::Adt::Struct(it) => name_range(it, sema)?,
-                hir::Adt::Union(it) => name_range(it, sema)?,
-                hir::Adt::Enum(it) => name_range(it, sema)?,
-            },
-            hir::ModuleDef::Variant(it) => name_range(it, sema)?,
-            hir::ModuleDef::Const(it) => name_range(it, sema)?,
-            hir::ModuleDef::Static(it) => name_range(it, sema)?,
-            hir::ModuleDef::Trait(it) => name_range(it, sema)?,
-            hir::ModuleDef::TypeAlias(it) => name_range(it, sema)?,
-            hir::ModuleDef::BuiltinType(_) => return None,
-        },
-        Definition::SelfType(_) => return None,
-        Definition::Local(local) => {
-            let src = local.source(sema.db);
-            let name = match &src.value {
-                Either::Left(bind_pat) => bind_pat.name()?,
-                Either::Right(_) => return None,
-            };
-            src.with_value(name.syntax()).original_file_range(sema.db)
-        }
-        Definition::GenericParam(generic_param) => match generic_param {
-            hir::GenericParam::TypeParam(type_param) => {
-                let src = type_param.source(sema.db)?;
-                let name = match &src.value {
-                    Either::Left(_) => return None,
-                    Either::Right(type_param) => type_param.name()?,
-                };
-                src.with_value(name.syntax()).original_file_range(sema.db)
-            }
-            hir::GenericParam::LifetimeParam(lifetime_param) => {
-                let src = lifetime_param.source(sema.db)?;
-                let lifetime = src.value.lifetime()?;
-                src.with_value(lifetime.syntax()).original_file_range(sema.db)
-            }
-            hir::GenericParam::ConstParam(it) => name_range(it, sema)?,
-        },
-        Definition::Label(label) => {
-            let src = label.source(sema.db);
-            let lifetime = src.value.lifetime()?;
-            src.with_value(lifetime.syntax()).original_file_range(sema.db)
-        }
-    };
-    return Some(res);
-
-    fn name_range<D>(def: D, sema: &Semantics<RootDatabase>) -> Option<FileRange>
-    where
-        D: HasSource,
-        D::Ast: ast::NameOwner,
-    {
-        let src = def.source(sema.db)?;
-        let name = src.value.name()?;
-        let res = src.with_value(name.syntax()).original_file_range(sema.db);
-        Some(res)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
@@ -2178,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/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 7a53268e8..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 {
-                                if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
+                            match def {
+                                Definition::Local(local)
+                                    if is_consumed_lvalue(
+                                        name_ref.syntax().clone().into(),
+                                        &local,
+                                        db,
+                                    ) =>
+                                {
                                     h |= HlMod::Consuming;
                                 }
-                            }
-
-                            if let Some(parent) = name_ref.syntax().parent() {
-                                if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
-                                    if let Definition::Field(field) = def {
-                                        if let hir::VariantDef::Union(_) = field.parent_def(db) {
-                                            h |= HlMod::Unsafe;
+                                Definition::ModuleDef(hir::ModuleDef::Trait(trait_))
+                                    if trait_.is_unsafe(db) =>
+                                {
+                                    if ast::Impl::for_trait_name_ref(&name_ref).is_some() {
+                                        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
@@ -354,15 +374,7 @@ fn highlight_def(db: &RootDatabase, krate: Option<hir::Crate>, def: Definition)
 
                 h
             }
-            hir::ModuleDef::Trait(trait_) => {
-                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Trait));
-
-                if trait_.is_unsafe(db) {
-                    h |= HlMod::Unsafe;
-                }
-
-                h
-            }
+            hir::ModuleDef::Trait(_) => Highlight::new(HlTag::Symbol(SymbolKind::Trait)),
             hir::ModuleDef::TypeAlias(type_) => {
                 let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
 
diff --git a/crates/ide/src/syntax_highlighting/html.rs b/crates/ide/src/syntax_highlighting/html.rs
index 478facfee..21376a7ae 100644
--- a/crates/ide/src/syntax_highlighting/html.rs
+++ b/crates/ide/src/syntax_highlighting/html.rs
@@ -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/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 59f1e8e4c..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; }
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 f7d8334a0..4f0b1ce85 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -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_assists/src/handlers/fix_visibility.rs b/crates/ide_assists/src/handlers/fix_visibility.rs
index 9b432e92f..f834bf16a 100644
--- a/crates/ide_assists/src/handlers/fix_visibility.rs
+++ b/crates/ide_assists/src/handlers/fix_visibility.rs
@@ -361,8 +361,6 @@ pub struct Foo { pub bar: () }
     }
 
     #[test]
-    #[ignore]
-    // FIXME reenable this test when `Semantics::resolve_record_field` works with union fields
     fn fix_visibility_of_union_field() {
         check_assist(
             fix_visibility,
@@ -583,25 +581,25 @@ pub struct Foo { pub(crate) bar: () }
     }
 
     #[test]
-    #[ignore]
-    // FIXME handle reexports properly
     fn fix_visibility_of_reexport() {
+        // FIXME: broken test, this should fix visibility of the re-export
+        // rather than the struct.
         check_assist(
             fix_visibility,
-            r"
-            mod foo {
-                use bar::Baz;
-                mod bar { pub(super) struct Baz; }
-            }
-            foo::Baz$0
-            ",
-            r"
-            mod foo {
-                $0pub(crate) use bar::Baz;
-                mod bar { pub(super) struct Baz; }
-            }
-            foo::Baz
-            ",
+            r#"
+mod foo {
+    use bar::Baz;
+    mod bar { pub(super) struct Baz; }
+}
+foo::Baz$0
+"#,
+            r#"
+mod foo {
+    use bar::Baz;
+    mod bar { $0pub(crate) struct Baz; }
+}
+foo::Baz
+"#,
         )
     }
 }
diff --git a/crates/ide_assists/src/handlers/generate_function.rs b/crates/ide_assists/src/handlers/generate_function.rs
index 706c995ac..6a658d4cf 100644
--- a/crates/ide_assists/src/handlers/generate_function.rs
+++ b/crates/ide_assists/src/handlers/generate_function.rs
@@ -811,9 +811,8 @@ fn bar(baz: Baz::Bof) ${0:-> ()} {
     }
 
     #[test]
-    #[ignore]
-    // FIXME fix printing the generics of a `Ty` to make this test pass
     fn add_function_with_generic_arg() {
+        // FIXME: This is wrong, generated `bar` should include generic parameter.
         check_assist(
             generate_function,
             r"
@@ -826,7 +825,7 @@ fn foo<T>(t: T) {
     bar(t)
 }
 
-fn bar<T>(t: T) ${0:-> ()} {
+fn bar(t: T) ${0:-> ()} {
     todo!()
 }
 ",
@@ -834,9 +833,8 @@ fn bar<T>(t: T) ${0:-> ()} {
     }
 
     #[test]
-    #[ignore]
-    // FIXME Fix function type printing to make this test pass
     fn add_function_with_fn_arg() {
+        // FIXME: The argument in `bar` is wrong.
         check_assist(
             generate_function,
             r"
@@ -857,7 +855,7 @@ fn foo() {
     bar(Baz::new);
 }
 
-fn bar(arg: fn() -> Baz) ${0:-> ()} {
+fn bar(new: fn) ${0:-> ()} {
     todo!()
 }
 ",
@@ -865,9 +863,8 @@ fn bar(arg: fn() -> Baz) ${0:-> ()} {
     }
 
     #[test]
-    #[ignore]
-    // FIXME Fix closure type printing to make this test pass
     fn add_function_with_closure_arg() {
+        // FIXME: The argument in `bar` is wrong.
         check_assist(
             generate_function,
             r"
@@ -882,7 +879,7 @@ fn foo() {
     bar(closure)
 }
 
-fn bar(closure: impl Fn(i64) -> i64) ${0:-> ()} {
+fn bar(closure: ()) ${0:-> ()} {
     todo!()
 }
 ",
@@ -986,13 +983,10 @@ fn foo() {
     }
 
     #[test]
-    #[ignore]
-    // Ignored until local imports are supported.
-    // See https://github.com/rust-analyzer/rust-analyzer/issues/1165
     fn qualified_path_uses_correct_scope() {
         check_assist(
             generate_function,
-            "
+            r#"
 mod foo {
     pub struct Foo;
 }
@@ -1001,8 +995,8 @@ fn bar() {
     let foo = Foo;
     baz$0(foo)
 }
-",
-            "
+"#,
+            r#"
 mod foo {
     pub struct Foo;
 }
@@ -1015,7 +1009,7 @@ fn bar() {
 fn baz(foo: foo::Foo) ${0:-> ()} {
     todo!()
 }
-",
+"#,
         )
     }
 
@@ -1141,40 +1135,29 @@ fn bar() {}
             // The assist is only active if the cursor is on an unresolved path,
             // but the assist should only be offered if the path is a function call.
             generate_function,
-            r"
+            r#"
 fn foo() {
     bar(b$0az);
 }
 
 fn bar(baz: ()) {}
-",
+"#,
         )
     }
 
     #[test]
-    #[ignore]
     fn create_method_with_no_args() {
-        check_assist(
+        // FIXME: This is wrong, this should just work.
+        check_assist_not_applicable(
             generate_function,
-            r"
+            r#"
 struct Foo;
 impl Foo {
     fn foo(&self) {
         self.bar()$0;
     }
 }
-        ",
-            r"
-struct Foo;
-impl Foo {
-    fn foo(&self) {
-        self.bar();
-    }
-    fn bar(&self) {
-        todo!();
-    }
-}
-        ",
+        "#,
         )
     }
 }
diff --git a/crates/ide_assists/src/handlers/qualify_path.rs b/crates/ide_assists/src/handlers/qualify_path.rs
index f91770a76..1d7be183a 100644
--- a/crates/ide_assists/src/handlers/qualify_path.rs
+++ b/crates/ide_assists/src/handlers/qualify_path.rs
@@ -216,28 +216,28 @@ mod tests {
         cov_mark::check!(qualify_path_unqualified_name);
         check_assist(
             qualify_path,
-            r"
-            mod std {
-                pub mod fmt {
-                    pub struct Formatter;
-                }
-            }
+            r#"
+mod std {
+    pub mod fmt {
+        pub struct Formatter;
+    }
+}
 
-            use std::fmt;
+use std::fmt;
 
-            $0Formatter
-            ",
-            r"
-            mod std {
-                pub mod fmt {
-                    pub struct Formatter;
-                }
-            }
+$0Formatter
+"#,
+            r#"
+mod std {
+    pub mod fmt {
+        pub struct Formatter;
+    }
+}
 
-            use std::fmt;
+use std::fmt;
 
-            fmt::Formatter
-            ",
+fmt::Formatter
+"#,
         );
     }
 
@@ -245,20 +245,20 @@ mod tests {
     fn applicable_when_found_an_import() {
         check_assist(
             qualify_path,
-            r"
-            $0PubStruct
+            r#"
+$0PubStruct
 
-            pub mod PubMod {
-                pub struct PubStruct;
-            }
-            ",
-            r"
-            PubMod::PubStruct
+pub mod PubMod {
+    pub struct PubStruct;
+}
+"#,
+            r#"
+PubMod::PubStruct
 
-            pub mod PubMod {
-                pub struct PubStruct;
-            }
-            ",
+pub mod PubMod {
+    pub struct PubStruct;
+}
+"#,
         );
     }
 
@@ -266,26 +266,26 @@ mod tests {
     fn applicable_in_macros() {
         check_assist(
             qualify_path,
-            r"
-            macro_rules! foo {
-                ($i:ident) => { fn foo(a: $i) {} }
-            }
-            foo!(Pub$0Struct);
+            r#"
+macro_rules! foo {
+    ($i:ident) => { fn foo(a: $i) {} }
+}
+foo!(Pub$0Struct);
 
-            pub mod PubMod {
-                pub struct PubStruct;
-            }
-            ",
-            r"
-            macro_rules! foo {
-                ($i:ident) => { fn foo(a: $i) {} }
-            }
-            foo!(PubMod::PubStruct);
+pub mod PubMod {
+    pub struct PubStruct;
+}
+"#,
+            r#"
+macro_rules! foo {
+    ($i:ident) => { fn foo(a: $i) {} }
+}
+foo!(PubMod::PubStruct);
 
-            pub mod PubMod {
-                pub struct PubStruct;
-            }
-            ",
+pub mod PubMod {
+    pub struct PubStruct;
+}
+"#,
         );
     }
 
@@ -293,32 +293,32 @@ mod tests {
     fn applicable_when_found_multiple_imports() {
         check_assist(
             qualify_path,
-            r"
-            PubSt$0ruct
+            r#"
+PubSt$0ruct
 
-            pub mod PubMod1 {
-                pub struct PubStruct;
-            }
-            pub mod PubMod2 {
-                pub struct PubStruct;
-            }
-            pub mod PubMod3 {
-                pub struct PubStruct;
-            }
-            ",
-            r"
-            PubMod3::PubStruct
+pub mod PubMod1 {
+    pub struct PubStruct;
+}
+pub mod PubMod2 {
+    pub struct PubStruct;
+}
+pub mod PubMod3 {
+    pub struct PubStruct;
+}
+"#,
+            r#"
+PubMod3::PubStruct
 
-            pub mod PubMod1 {
-                pub struct PubStruct;
-            }
-            pub mod PubMod2 {
-                pub struct PubStruct;
-            }
-            pub mod PubMod3 {
-                pub struct PubStruct;
-            }
-            ",
+pub mod PubMod1 {
+    pub struct PubStruct;
+}
+pub mod PubMod2 {
+    pub struct PubStruct;
+}
+pub mod PubMod3 {
+    pub struct PubStruct;
+}
+"#,
         );
     }
 
@@ -326,15 +326,15 @@ mod tests {
     fn not_applicable_for_already_imported_types() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            use PubMod::PubStruct;
+            r#"
+use PubMod::PubStruct;
 
-            PubStruct$0
+PubStruct$0
 
-            pub mod PubMod {
-                pub struct PubStruct;
-            }
-            ",
+pub mod PubMod {
+    pub struct PubStruct;
+}
+"#,
         );
     }
 
@@ -342,35 +342,32 @@ mod tests {
     fn not_applicable_for_types_with_private_paths() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            PrivateStruct$0
+            r#"
+PrivateStruct$0
 
-            pub mod PubMod {
-                struct PrivateStruct;
-            }
-            ",
+pub mod PubMod {
+    struct PrivateStruct;
+}
+"#,
         );
     }
 
     #[test]
     fn not_applicable_when_no_imports_found() {
-        check_assist_not_applicable(
-            qualify_path,
-            "
-            PubStruct$0",
-        );
+        check_assist_not_applicable(qualify_path, r#"PubStruct$0"#);
     }
 
     #[test]
     fn not_applicable_in_import_statements() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            use PubStruct$0;
+            r#"
+use PubStruct$0;
 
-            pub mod PubMod {
-                pub struct PubStruct;
-            }",
+pub mod PubMod {
+    pub struct PubStruct;
+}
+"#,
         );
     }
 
@@ -378,20 +375,20 @@ mod tests {
     fn qualify_function() {
         check_assist(
             qualify_path,
-            r"
-            test_function$0
+            r#"
+test_function$0
 
-            pub mod PubMod {
-                pub fn test_function() {};
-            }
-            ",
-            r"
-            PubMod::test_function
+pub mod PubMod {
+    pub fn test_function() {};
+}
+"#,
+            r#"
+PubMod::test_function
 
-            pub mod PubMod {
-                pub fn test_function() {};
-            }
-            ",
+pub mod PubMod {
+    pub fn test_function() {};
+}
+"#,
         );
     }
 
@@ -399,7 +396,7 @@ mod tests {
     fn qualify_macro() {
         check_assist(
             qualify_path,
-            r"
+            r#"
 //- /lib.rs crate:crate_with_macro
 #[macro_export]
 macro_rules! foo {
@@ -410,12 +407,12 @@ macro_rules! foo {
 fn main() {
     foo$0
 }
-",
-            r"
+"#,
+            r#"
 fn main() {
     crate_with_macro::foo
 }
-",
+"#,
         );
     }
 
@@ -423,13 +420,13 @@ fn main() {
     fn qualify_path_target() {
         check_assist_target(
             qualify_path,
-            r"
-            struct AssistInfo {
-                group_label: Option<$0GroupLabel>,
-            }
+            r#"
+struct AssistInfo {
+    group_label: Option<$0GroupLabel>,
+}
 
-            mod m { pub struct GroupLabel; }
-            ",
+mod m { pub struct GroupLabel; }
+"#,
             "GroupLabel",
         )
     }
@@ -438,20 +435,20 @@ fn main() {
     fn not_applicable_when_path_start_is_imported() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            pub mod mod1 {
-                pub mod mod2 {
-                    pub mod mod3 {
-                        pub struct TestStruct;
-                    }
-                }
-            }
+            r#"
+pub mod mod1 {
+    pub mod mod2 {
+        pub mod mod3 {
+            pub struct TestStruct;
+        }
+    }
+}
 
-            use mod1::mod2;
-            fn main() {
-                mod2::mod3::TestStruct$0
-            }
-            ",
+use mod1::mod2;
+fn main() {
+    mod2::mod3::TestStruct$0
+}
+"#,
         );
     }
 
@@ -459,16 +456,16 @@ fn main() {
     fn not_applicable_for_imported_function() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            pub mod test_mod {
-                pub fn test_function() {}
-            }
+            r#"
+pub mod test_mod {
+    pub fn test_function() {}
+}
 
-            use test_mod::test_function;
-            fn main() {
-                test_function$0
-            }
-            ",
+use test_mod::test_function;
+fn main() {
+    test_function$0
+}
+"#,
         );
     }
 
@@ -476,30 +473,30 @@ fn main() {
     fn associated_struct_function() {
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub struct TestStruct {}
-                impl TestStruct {
-                    pub fn test_function() {}
-                }
-            }
+            r#"
+mod test_mod {
+    pub struct TestStruct {}
+    impl TestStruct {
+        pub fn test_function() {}
+    }
+}
 
-            fn main() {
-                TestStruct::test_function$0
-            }
-            ",
-            r"
-            mod test_mod {
-                pub struct TestStruct {}
-                impl TestStruct {
-                    pub fn test_function() {}
-                }
-            }
+fn main() {
+    TestStruct::test_function$0
+}
+"#,
+            r#"
+mod test_mod {
+    pub struct TestStruct {}
+    impl TestStruct {
+        pub fn test_function() {}
+    }
+}
 
-            fn main() {
-                test_mod::TestStruct::test_function
-            }
-            ",
+fn main() {
+    test_mod::TestStruct::test_function
+}
+"#,
         );
     }
 
@@ -508,62 +505,50 @@ fn main() {
         cov_mark::check!(qualify_path_qualifier_start);
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub struct TestStruct {}
-                impl TestStruct {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+            r#"
+mod test_mod {
+    pub struct TestStruct {}
+    impl TestStruct {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            fn main() {
-                TestStruct::TEST_CONST$0
-            }
-            ",
-            r"
-            mod test_mod {
-                pub struct TestStruct {}
-                impl TestStruct {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+fn main() {
+    TestStruct::TEST_CONST$0
+}
+"#,
+            r#"
+mod test_mod {
+    pub struct TestStruct {}
+    impl TestStruct {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            fn main() {
-                test_mod::TestStruct::TEST_CONST
-            }
-            ",
+fn main() {
+    test_mod::TestStruct::TEST_CONST
+}
+"#,
         );
     }
 
     #[test]
-    #[ignore = "FIXME: non-trait assoc items completion is unsupported yet, see FIXME in the import_assets.rs for more details"]
     fn associated_struct_const_unqualified() {
-        check_assist(
+        // FIXME: non-trait assoc items completion is unsupported yet, see FIXME in the import_assets.rs for more details
+        check_assist_not_applicable(
             qualify_path,
-            r"
-            mod test_mod {
-                pub struct TestStruct {}
-                impl TestStruct {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
-
-            fn main() {
-                TEST_CONST$0
-            }
-            ",
-            r"
-            mod test_mod {
-                pub struct TestStruct {}
-                impl TestStruct {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+            r#"
+mod test_mod {
+    pub struct TestStruct {}
+    impl TestStruct {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            fn main() {
-                test_mod::TestStruct::TEST_CONST
-            }
-            ",
+fn main() {
+    TEST_CONST$0
+}
+"#,
         );
     }
 
@@ -571,36 +556,36 @@ fn main() {
     fn associated_trait_function() {
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_function();
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_function() {}
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_function();
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_function() {}
+    }
+}
 
-            fn main() {
-                test_mod::TestStruct::test_function$0
-            }
-            ",
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_function();
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_function() {}
-                }
-            }
+fn main() {
+    test_mod::TestStruct::test_function$0
+}
+"#,
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_function();
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_function() {}
+    }
+}
 
-            fn main() {
-                <test_mod::TestStruct as test_mod::TestTrait>::test_function
-            }
-            ",
+fn main() {
+    <test_mod::TestStruct as test_mod::TestTrait>::test_function
+}
+"#,
         );
     }
 
@@ -608,31 +593,31 @@ fn main() {
     fn not_applicable_for_imported_trait_for_function() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_function();
-                }
-                pub trait TestTrait2 {
-                    fn test_function();
-                }
-                pub enum TestEnum {
-                    One,
-                    Two,
-                }
-                impl TestTrait2 for TestEnum {
-                    fn test_function() {}
-                }
-                impl TestTrait for TestEnum {
-                    fn test_function() {}
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_function();
+    }
+    pub trait TestTrait2 {
+        fn test_function();
+    }
+    pub enum TestEnum {
+        One,
+        Two,
+    }
+    impl TestTrait2 for TestEnum {
+        fn test_function() {}
+    }
+    impl TestTrait for TestEnum {
+        fn test_function() {}
+    }
+}
 
-            use test_mod::TestTrait2;
-            fn main() {
-                test_mod::TestEnum::test_function$0;
-            }
-            ",
+use test_mod::TestTrait2;
+fn main() {
+    test_mod::TestEnum::test_function$0;
+}
+"#,
         )
     }
 
@@ -641,36 +626,36 @@ fn main() {
         cov_mark::check!(qualify_path_trait_assoc_item);
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    const TEST_CONST: u8;
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        const TEST_CONST: u8;
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            fn main() {
-                test_mod::TestStruct::TEST_CONST$0
-            }
-            ",
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    const TEST_CONST: u8;
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+fn main() {
+    test_mod::TestStruct::TEST_CONST$0
+}
+"#,
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        const TEST_CONST: u8;
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            fn main() {
-                <test_mod::TestStruct as test_mod::TestTrait>::TEST_CONST
-            }
-            ",
+fn main() {
+    <test_mod::TestStruct as test_mod::TestTrait>::TEST_CONST
+}
+"#,
         );
     }
 
@@ -678,31 +663,31 @@ fn main() {
     fn not_applicable_for_imported_trait_for_const() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    const TEST_CONST: u8;
-                }
-                pub trait TestTrait2 {
-                    const TEST_CONST: f64;
-                }
-                pub enum TestEnum {
-                    One,
-                    Two,
-                }
-                impl TestTrait2 for TestEnum {
-                    const TEST_CONST: f64 = 42.0;
-                }
-                impl TestTrait for TestEnum {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        const TEST_CONST: u8;
+    }
+    pub trait TestTrait2 {
+        const TEST_CONST: f64;
+    }
+    pub enum TestEnum {
+        One,
+        Two,
+    }
+    impl TestTrait2 for TestEnum {
+        const TEST_CONST: f64 = 42.0;
+    }
+    impl TestTrait for TestEnum {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            use test_mod::TestTrait2;
-            fn main() {
-                test_mod::TestEnum::TEST_CONST$0;
-            }
-            ",
+use test_mod::TestTrait2;
+fn main() {
+    test_mod::TestEnum::TEST_CONST$0;
+}
+"#,
         )
     }
 
@@ -711,38 +696,38 @@ fn main() {
         cov_mark::check!(qualify_path_trait_method);
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_method(&self);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method(&self) {}
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method(&self) {}
+    }
+}
 
-            fn main() {
-                let test_struct = test_mod::TestStruct {};
-                test_struct.test_meth$0od()
-            }
-            ",
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_method(&self);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method(&self) {}
-                }
-            }
+fn main() {
+    let test_struct = test_mod::TestStruct {};
+    test_struct.test_meth$0od()
+}
+"#,
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method(&self) {}
+    }
+}
 
-            fn main() {
-                let test_struct = test_mod::TestStruct {};
-                test_mod::TestTrait::test_method(&test_struct)
-            }
-            ",
+fn main() {
+    let test_struct = test_mod::TestStruct {};
+    test_mod::TestTrait::test_method(&test_struct)
+}
+"#,
         );
     }
 
@@ -750,38 +735,38 @@ fn main() {
     fn trait_method_multi_params() {
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_method(&self, test: i32);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method(&self, test: i32) {}
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_method(&self, test: i32);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method(&self, test: i32) {}
+    }
+}
 
-            fn main() {
-                let test_struct = test_mod::TestStruct {};
-                test_struct.test_meth$0od(42)
-            }
-            ",
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_method(&self, test: i32);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method(&self, test: i32) {}
-                }
-            }
+fn main() {
+    let test_struct = test_mod::TestStruct {};
+    test_struct.test_meth$0od(42)
+}
+"#,
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_method(&self, test: i32);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method(&self, test: i32) {}
+    }
+}
 
-            fn main() {
-                let test_struct = test_mod::TestStruct {};
-                test_mod::TestTrait::test_method(&test_struct, 42)
-            }
-            ",
+fn main() {
+    let test_struct = test_mod::TestStruct {};
+    test_mod::TestTrait::test_method(&test_struct, 42)
+}
+"#,
         );
     }
 
@@ -789,38 +774,38 @@ fn main() {
     fn trait_method_consume() {
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_method(self);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method(self) {}
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_method(self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method(self) {}
+    }
+}
 
-            fn main() {
-                let test_struct = test_mod::TestStruct {};
-                test_struct.test_meth$0od()
-            }
-            ",
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_method(self);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method(self) {}
-                }
-            }
+fn main() {
+    let test_struct = test_mod::TestStruct {};
+    test_struct.test_meth$0od()
+}
+"#,
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_method(self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method(self) {}
+    }
+}
 
-            fn main() {
-                let test_struct = test_mod::TestStruct {};
-                test_mod::TestTrait::test_method(test_struct)
-            }
-            ",
+fn main() {
+    let test_struct = test_mod::TestStruct {};
+    test_mod::TestTrait::test_method(test_struct)
+}
+"#,
         );
     }
 
@@ -828,29 +813,29 @@ fn main() {
     fn trait_method_cross_crate() {
         check_assist(
             qualify_path,
-            r"
-            //- /main.rs crate:main deps:dep
-            fn main() {
-                let test_struct = dep::test_mod::TestStruct {};
-                test_struct.test_meth$0od()
-            }
-            //- /dep.rs crate:dep
-            pub mod test_mod {
-                pub trait TestTrait {
-                    fn test_method(&self);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method(&self) {}
-                }
-            }
-            ",
-            r"
-            fn main() {
-                let test_struct = dep::test_mod::TestStruct {};
-                dep::test_mod::TestTrait::test_method(&test_struct)
-            }
-            ",
+            r#"
+//- /main.rs crate:main deps:dep
+fn main() {
+    let test_struct = dep::test_mod::TestStruct {};
+    test_struct.test_meth$0od()
+}
+//- /dep.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        fn test_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method(&self) {}
+    }
+}
+"#,
+            r#"
+fn main() {
+    let test_struct = dep::test_mod::TestStruct {};
+    dep::test_mod::TestTrait::test_method(&test_struct)
+}
+"#,
         );
     }
 
@@ -858,27 +843,27 @@ fn main() {
     fn assoc_fn_cross_crate() {
         check_assist(
             qualify_path,
-            r"
-            //- /main.rs crate:main deps:dep
-            fn main() {
-                dep::test_mod::TestStruct::test_func$0tion
-            }
-            //- /dep.rs crate:dep
-            pub mod test_mod {
-                pub trait TestTrait {
-                    fn test_function();
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_function() {}
-                }
-            }
-            ",
-            r"
-            fn main() {
-                <dep::test_mod::TestStruct as dep::test_mod::TestTrait>::test_function
-            }
-            ",
+            r#"
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::test_func$0tion
+}
+//- /dep.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        fn test_function();
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_function() {}
+    }
+}
+"#,
+            r#"
+fn main() {
+    <dep::test_mod::TestStruct as dep::test_mod::TestTrait>::test_function
+}
+"#,
         );
     }
 
@@ -886,27 +871,27 @@ fn main() {
     fn assoc_const_cross_crate() {
         check_assist(
             qualify_path,
-            r"
-            //- /main.rs crate:main deps:dep
-            fn main() {
-                dep::test_mod::TestStruct::CONST$0
-            }
-            //- /dep.rs crate:dep
-            pub mod test_mod {
-                pub trait TestTrait {
-                    const CONST: bool;
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    const CONST: bool = true;
-                }
-            }
-            ",
-            r"
-            fn main() {
-                <dep::test_mod::TestStruct as dep::test_mod::TestTrait>::CONST
-            }
-            ",
+            r#"
+//- /main.rs crate:main deps:dep
+fn main() {
+    dep::test_mod::TestStruct::CONST$0
+}
+//- /dep.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        const CONST: bool;
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const CONST: bool = true;
+    }
+}
+"#,
+            r#"
+fn main() {
+    <dep::test_mod::TestStruct as dep::test_mod::TestTrait>::CONST
+}
+"#,
         );
     }
 
@@ -914,23 +899,23 @@ fn main() {
     fn assoc_fn_as_method_cross_crate() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            //- /main.rs crate:main deps:dep
-            fn main() {
-                let test_struct = dep::test_mod::TestStruct {};
-                test_struct.test_func$0tion()
-            }
-            //- /dep.rs crate:dep
-            pub mod test_mod {
-                pub trait TestTrait {
-                    fn test_function();
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_function() {}
-                }
-            }
-            ",
+            r#"
+//- /main.rs crate:main deps:dep
+fn main() {
+    let test_struct = dep::test_mod::TestStruct {};
+    test_struct.test_func$0tion()
+}
+//- /dep.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        fn test_function();
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_function() {}
+    }
+}
+"#,
         );
     }
 
@@ -938,23 +923,23 @@ fn main() {
     fn private_trait_cross_crate() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            //- /main.rs crate:main deps:dep
-            fn main() {
-                let test_struct = dep::test_mod::TestStruct {};
-                test_struct.test_meth$0od()
-            }
-            //- /dep.rs crate:dep
-            pub mod test_mod {
-                trait TestTrait {
-                    fn test_method(&self);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method(&self) {}
-                }
-            }
-            ",
+            r#"
+//- /main.rs crate:main deps:dep
+fn main() {
+    let test_struct = dep::test_mod::TestStruct {};
+    test_struct.test_meth$0od()
+}
+//- /dep.rs crate:dep
+pub mod test_mod {
+    trait TestTrait {
+        fn test_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method(&self) {}
+    }
+}
+"#,
         );
     }
 
@@ -962,32 +947,32 @@ fn main() {
     fn not_applicable_for_imported_trait_for_method() {
         check_assist_not_applicable(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_method(&self);
-                }
-                pub trait TestTrait2 {
-                    fn test_method(&self);
-                }
-                pub enum TestEnum {
-                    One,
-                    Two,
-                }
-                impl TestTrait2 for TestEnum {
-                    fn test_method(&self) {}
-                }
-                impl TestTrait for TestEnum {
-                    fn test_method(&self) {}
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_method(&self);
+    }
+    pub trait TestTrait2 {
+        fn test_method(&self);
+    }
+    pub enum TestEnum {
+        One,
+        Two,
+    }
+    impl TestTrait2 for TestEnum {
+        fn test_method(&self) {}
+    }
+    impl TestTrait for TestEnum {
+        fn test_method(&self) {}
+    }
+}
 
-            use test_mod::TestTrait2;
-            fn main() {
-                let one = test_mod::TestEnum::One;
-                one.test$0_method();
-            }
-            ",
+use test_mod::TestTrait2;
+fn main() {
+    let one = test_mod::TestEnum::One;
+    one.test$0_method();
+}
+"#,
         )
     }
 
@@ -1114,7 +1099,7 @@ fn main() {}
     fn keep_generic_annotations_leading_colon() {
         check_assist(
             qualify_path,
-            r"
+            r#"
 //- /lib.rs crate:dep
 pub mod generic { pub struct Thing<'a, T>(&'a T); }
 
@@ -1122,7 +1107,7 @@ pub mod generic { pub struct Thing<'a, T>(&'a T); }
 fn foo() -> Thin$0g::<'static, ()> {}
 
 fn main() {}
-",
+"#,
             r"
 fn foo() -> dep::generic::Thing::<'static, ()> {}
 
@@ -1135,30 +1120,30 @@ fn main() {}
     fn associated_struct_const_generic() {
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub struct TestStruct<T> {}
-                impl<T> TestStruct<T> {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+            r#"
+mod test_mod {
+    pub struct TestStruct<T> {}
+    impl<T> TestStruct<T> {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            fn main() {
-                TestStruct::<()>::TEST_CONST$0
-            }
-            ",
-            r"
-            mod test_mod {
-                pub struct TestStruct<T> {}
-                impl<T> TestStruct<T> {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+fn main() {
+    TestStruct::<()>::TEST_CONST$0
+}
+"#,
+            r#"
+mod test_mod {
+    pub struct TestStruct<T> {}
+    impl<T> TestStruct<T> {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            fn main() {
-                test_mod::TestStruct::<()>::TEST_CONST
-            }
-            ",
+fn main() {
+    test_mod::TestStruct::<()>::TEST_CONST
+}
+"#,
         );
     }
 
@@ -1166,36 +1151,36 @@ fn main() {}
     fn associated_trait_const_generic() {
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    const TEST_CONST: u8;
-                }
-                pub struct TestStruct<T> {}
-                impl<T> TestTrait for TestStruct<T> {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        const TEST_CONST: u8;
+    }
+    pub struct TestStruct<T> {}
+    impl<T> TestTrait for TestStruct<T> {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            fn main() {
-                test_mod::TestStruct::<()>::TEST_CONST$0
-            }
-            ",
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    const TEST_CONST: u8;
-                }
-                pub struct TestStruct<T> {}
-                impl<T> TestTrait for TestStruct<T> {
-                    const TEST_CONST: u8 = 42;
-                }
-            }
+fn main() {
+    test_mod::TestStruct::<()>::TEST_CONST$0
+}
+"#,
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        const TEST_CONST: u8;
+    }
+    pub struct TestStruct<T> {}
+    impl<T> TestTrait for TestStruct<T> {
+        const TEST_CONST: u8 = 42;
+    }
+}
 
-            fn main() {
-                <test_mod::TestStruct::<()> as test_mod::TestTrait>::TEST_CONST
-            }
-            ",
+fn main() {
+    <test_mod::TestStruct::<()> as test_mod::TestTrait>::TEST_CONST
+}
+"#,
         );
     }
 
@@ -1203,38 +1188,38 @@ fn main() {}
     fn trait_method_generic() {
         check_assist(
             qualify_path,
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_method<T>(&self);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method<T>(&self) {}
-                }
-            }
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_method<T>(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method<T>(&self) {}
+    }
+}
 
-            fn main() {
-                let test_struct = test_mod::TestStruct {};
-                test_struct.test_meth$0od::<()>()
-            }
-            ",
-            r"
-            mod test_mod {
-                pub trait TestTrait {
-                    fn test_method<T>(&self);
-                }
-                pub struct TestStruct {}
-                impl TestTrait for TestStruct {
-                    fn test_method<T>(&self) {}
-                }
-            }
+fn main() {
+    let test_struct = test_mod::TestStruct {};
+    test_struct.test_meth$0od::<()>()
+}
+"#,
+            r#"
+mod test_mod {
+    pub trait TestTrait {
+        fn test_method<T>(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        fn test_method<T>(&self) {}
+    }
+}
 
-            fn main() {
-                let test_struct = test_mod::TestStruct {};
-                test_mod::TestTrait::test_method::<()>(&test_struct)
-            }
-            ",
+fn main() {
+    let test_struct = test_mod::TestStruct {};
+    test_mod::TestTrait::test_method::<()>(&test_struct)
+}
+"#,
         );
     }
 }
diff --git a/crates/ide_assists/src/handlers/replace_impl_trait_with_generic.rs b/crates/ide_assists/src/handlers/replace_impl_trait_with_generic.rs
index 540a905cc..a2af2035f 100644
--- a/crates/ide_assists/src/handlers/replace_impl_trait_with_generic.rs
+++ b/crates/ide_assists/src/handlers/replace_impl_trait_with_generic.rs
@@ -105,12 +105,13 @@ fn foo<B: Bar
     }
 
     #[test]
-    #[ignore = "This case is very rare but there is no simple solutions to fix it."]
     fn replace_impl_trait_with_exist_generic_letter() {
+        // FIXME: This is wrong, we should pick a different name if the one we
+        // want is already bound.
         check_assist(
             replace_impl_trait_with_generic,
             r#"fn foo<B>(bar: $0impl Bar) {}"#,
-            r#"fn foo<B, C: Bar>(bar: C) {}"#,
+            r#"fn foo<B, B: Bar>(bar: B) {}"#,
         );
     }
 
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 331a6df2b..fa378a622 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -17,156 +17,31 @@ mod tests;
 pub mod utils;
 pub mod path_transform;
 
-use std::str::FromStr;
-
 use hir::Semantics;
-use ide_db::{base_db::FileRange, label::Label, source_change::SourceChange, RootDatabase};
+use ide_db::{base_db::FileRange, RootDatabase};
 use syntax::TextRange;
 
 pub(crate) use crate::assist_context::{AssistContext, Assists};
 
 pub use assist_config::AssistConfig;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AssistKind {
-    // FIXME: does the None variant make sense? Probably not.
-    None,
-
-    QuickFix,
-    Generate,
-    Refactor,
-    RefactorExtract,
-    RefactorInline,
-    RefactorRewrite,
-}
-
-impl AssistKind {
-    pub fn contains(self, other: AssistKind) -> bool {
-        if self == other {
-            return true;
-        }
-
-        match self {
-            AssistKind::None | AssistKind::Generate => true,
-            AssistKind::Refactor => match other {
-                AssistKind::RefactorExtract
-                | AssistKind::RefactorInline
-                | AssistKind::RefactorRewrite => true,
-                _ => false,
-            },
-            _ => false,
-        }
-    }
-
-    pub fn name(&self) -> &str {
-        match self {
-            AssistKind::None => "None",
-            AssistKind::QuickFix => "QuickFix",
-            AssistKind::Generate => "Generate",
-            AssistKind::Refactor => "Refactor",
-            AssistKind::RefactorExtract => "RefactorExtract",
-            AssistKind::RefactorInline => "RefactorInline",
-            AssistKind::RefactorRewrite => "RefactorRewrite",
-        }
-    }
-}
-
-impl FromStr for AssistKind {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "None" => Ok(AssistKind::None),
-            "QuickFix" => Ok(AssistKind::QuickFix),
-            "Generate" => Ok(AssistKind::Generate),
-            "Refactor" => Ok(AssistKind::Refactor),
-            "RefactorExtract" => Ok(AssistKind::RefactorExtract),
-            "RefactorInline" => Ok(AssistKind::RefactorInline),
-            "RefactorRewrite" => Ok(AssistKind::RefactorRewrite),
-            unknown => Err(format!("Unknown AssistKind: '{}'", unknown)),
-        }
-    }
-}
-
-/// Unique identifier of the assist, should not be shown to the user
-/// directly.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct AssistId(pub &'static str, pub AssistKind);
-
-/// A way to control how many asssist to resolve during the assist resolution.
-/// When an assist is resolved, its edits are calculated that might be costly to always do by default.
-#[derive(Debug)]
-pub enum AssistResolveStrategy {
-    /// No assists should be resolved.
-    None,
-    /// All assists should be resolved.
-    All,
-    /// Only a certain assist should be resolved.
-    Single(SingleResolve),
-}
-
-/// Hold the [`AssistId`] data of a certain assist to resolve.
-/// The original id object cannot be used due to a `'static` lifetime
-/// and the requirement to construct this struct dynamically during the resolve handling.
-#[derive(Debug)]
-pub struct SingleResolve {
-    /// The id of the assist.
-    pub assist_id: String,
-    // The kind of the assist.
-    pub assist_kind: AssistKind,
-}
-
-impl AssistResolveStrategy {
-    pub fn should_resolve(&self, id: &AssistId) -> bool {
-        match self {
-            AssistResolveStrategy::None => false,
-            AssistResolveStrategy::All => true,
-            AssistResolveStrategy::Single(single_resolve) => {
-                single_resolve.assist_id == id.0 && single_resolve.assist_kind == id.1
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct GroupLabel(pub String);
-
-#[derive(Debug, Clone)]
-pub struct Assist {
-    pub id: AssistId,
-    /// Short description of the assist, as shown in the UI.
-    pub label: Label,
-    pub group: Option<GroupLabel>,
-    /// Target ranges are used to sort assists: the smaller the target range,
-    /// the more specific assist is, and so it should be sorted first.
-    pub target: TextRange,
-    /// Computing source change sometimes is much more costly then computing the
-    /// other fields. Additionally, the actual change is not required to show
-    /// the lightbulb UI, it only is needed when the user tries to apply an
-    /// assist. So, we compute it lazily: the API allow requesting assists with
-    /// or without source change. We could (and in fact, used to) distinguish
-    /// between resolved and unresolved assists at the type level, but this is
-    /// cumbersome, especially if you want to embed an assist into another data
-    /// structure, such as a diagnostic.
-    pub source_change: Option<SourceChange>,
-}
-
-impl Assist {
-    /// Return all the assists applicable at the given position.
-    pub fn get(
-        db: &RootDatabase,
-        config: &AssistConfig,
-        resolve: AssistResolveStrategy,
-        range: FileRange,
-    ) -> Vec<Assist> {
-        let sema = Semantics::new(db);
-        let ctx = AssistContext::new(sema, config, range);
-        let mut acc = Assists::new(&ctx, resolve);
-        handlers::all().iter().for_each(|handler| {
-            handler(&mut acc, &ctx);
-        });
-        acc.finish()
-    }
+pub use ide_db::assists::{
+    Assist, AssistId, AssistKind, AssistResolveStrategy, GroupLabel, SingleResolve,
+};
+
+/// Return all the assists applicable at the given position.
+pub fn assists(
+    db: &RootDatabase,
+    config: &AssistConfig,
+    resolve: AssistResolveStrategy,
+    range: FileRange,
+) -> Vec<Assist> {
+    let sema = Semantics::new(db);
+    let ctx = AssistContext::new(sema, config, range);
+    let mut acc = Assists::new(&ctx, resolve);
+    handlers::all().iter().for_each(|handler| {
+        handler(&mut acc, &ctx);
+    });
+    acc.finish()
 }
 
 mod handlers {
diff --git a/crates/ide_assists/src/tests.rs b/crates/ide_assists/src/tests.rs
index bdf9cb71c..60cecd94c 100644
--- a/crates/ide_assists/src/tests.rs
+++ b/crates/ide_assists/src/tests.rs
@@ -16,8 +16,8 @@ use syntax::TextRange;
 use test_utils::{assert_eq_text, extract_offset};
 
 use crate::{
-    handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind, AssistResolveStrategy,
-    Assists, SingleResolve,
+    assists, handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind,
+    AssistResolveStrategy, Assists, SingleResolve,
 };
 
 pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
@@ -78,14 +78,14 @@ fn check_doc_test(assist_id: &str, before: &str, after: &str) {
     let before = db.file_text(file_id).to_string();
     let frange = FileRange { file_id, range: selection.into() };
 
-    let assist = Assist::get(&db, &TEST_CONFIG, AssistResolveStrategy::All, frange)
+    let assist = assists(&db, &TEST_CONFIG, AssistResolveStrategy::All, frange)
         .into_iter()
         .find(|assist| assist.id.0 == assist_id)
         .unwrap_or_else(|| {
             panic!(
                 "\n\nAssist is not applicable: {}\nAvailable assists: {}",
                 assist_id,
-                Assist::get(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange)
+                assists(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange)
                     .into_iter()
                     .map(|assist| assist.id.0)
                     .collect::<Vec<_>>()
@@ -210,7 +210,7 @@ fn assist_order_field_struct() {
     let (before_cursor_pos, before) = extract_offset(before);
     let (db, file_id) = with_single_file(&before);
     let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
-    let assists = Assist::get(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
+    let assists = assists(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
     let mut assists = assists.iter();
 
     assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
@@ -235,7 +235,7 @@ pub fn test_some_range(a: int) -> bool {
 "#,
     );
 
-    let assists = Assist::get(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
+    let assists = assists(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
     let expected = labels(&assists);
 
     expect![[r#"
@@ -264,7 +264,7 @@ pub fn test_some_range(a: int) -> bool {
         let mut cfg = TEST_CONFIG;
         cfg.allowed = Some(vec![AssistKind::Refactor]);
 
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::None, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
         let expected = labels(&assists);
 
         expect![[r#"
@@ -279,7 +279,7 @@ pub fn test_some_range(a: int) -> bool {
     {
         let mut cfg = TEST_CONFIG;
         cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::None, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
         let expected = labels(&assists);
 
         expect![[r#"
@@ -292,7 +292,7 @@ pub fn test_some_range(a: int) -> bool {
     {
         let mut cfg = TEST_CONFIG;
         cfg.allowed = Some(vec![AssistKind::QuickFix]);
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::None, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
         let expected = labels(&assists);
 
         expect![[r#""#]].assert_eq(&expected);
@@ -317,7 +317,7 @@ pub fn test_some_range(a: int) -> bool {
     cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
 
     {
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::None, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
         assert_eq!(2, assists.len());
         let mut assists = assists.into_iter();
 
@@ -353,7 +353,7 @@ pub fn test_some_range(a: int) -> bool {
     }
 
     {
-        let assists = Assist::get(
+        let assists = assists(
             &db,
             &cfg,
             AssistResolveStrategy::Single(SingleResolve {
@@ -397,7 +397,7 @@ pub fn test_some_range(a: int) -> bool {
     }
 
     {
-        let assists = Assist::get(
+        let assists = assists(
             &db,
             &cfg,
             AssistResolveStrategy::Single(SingleResolve {
@@ -462,7 +462,7 @@ pub fn test_some_range(a: int) -> bool {
     }
 
     {
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::All, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::All, frange);
         assert_eq!(2, assists.len());
         let mut assists = assists.into_iter();
 
diff --git a/crates/ide_completion/src/completions/attribute/derive.rs b/crates/ide_completion/src/completions/attribute/derive.rs
index d526824fb..7b3133e53 100644
--- a/crates/ide_completion/src/completions/attribute/derive.rs
+++ b/crates/ide_completion/src/completions/attribute/derive.rs
@@ -93,57 +93,20 @@ mod tests {
     }
 
     #[test]
-    #[ignore] // FIXME: Fixtures cant test proc-macros/derives yet as we cant specify them in fixtures
     fn empty_derive() {
-        check(
-            r#"#[derive($0)] struct Test;"#,
-            expect![[r#"
-                at Clone
-                at Clone, Copy
-                at Debug
-                at Default
-                at Hash
-                at PartialEq
-                at PartialEq, Eq
-                at PartialEq, PartialOrd
-                at PartialEq, Eq, PartialOrd, Ord
-            "#]],
-        );
+        // FIXME: Add build-in derives to fixture.
+        check(r#"#[derive($0)] struct Test;"#, expect![[r#""#]]);
     }
 
     #[test]
-    #[ignore] // FIXME: Fixtures cant test proc-macros/derives yet as we cant specify them in fixtures
     fn derive_with_input() {
-        check(
-            r#"#[derive(serde::Serialize, PartialEq, $0)] struct Test;"#,
-            expect![[r#"
-                at Clone
-                at Clone, Copy
-                at Debug
-                at Default
-                at Hash
-                at Eq
-                at PartialOrd
-                at Eq, PartialOrd, Ord
-            "#]],
-        )
+        // FIXME: Add build-in derives to fixture.
+        check(r#"#[derive(serde::Serialize, PartialEq, $0)] struct Test;"#, expect![[r#""#]])
     }
 
     #[test]
-    #[ignore] // FIXME: Fixtures cant test proc-macros/derives yet as we cant specify them in fixtures
     fn derive_with_input2() {
-        check(
-            r#"#[derive($0 serde::Serialize, PartialEq)] struct Test;"#,
-            expect![[r#"
-                at Clone
-                at Clone, Copy
-                at Debug
-                at Default
-                at Hash
-                at Eq
-                at PartialOrd
-                at Eq, PartialOrd, Ord
-            "#]],
-        )
+        // FIXME: Add build-in derives to fixture.
+        check(r#"#[derive($0 serde::Serialize, PartialEq)] struct Test;"#, expect![[r#""#]])
     }
 }
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index ba13d3707..0fccbeccf 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -536,17 +536,11 @@ Some multi-line comment$0
     fn test_completion_await_impls_future() {
         check(
             r#"
-//- /main.rs crate:main deps:std
-use std::future::*;
+//- minicore: future
+use core::future::*;
 struct A {}
 impl Future for A {}
 fn foo(a: A) { a.$0 }
-
-//- /std/lib.rs crate:std
-pub mod future {
-    #[lang = "future_trait"]
-    pub trait Future {}
-}
 "#,
             expect![[r#"
                 kw await expr.await
@@ -555,20 +549,12 @@ pub mod future {
 
         check(
             r#"
-//- /main.rs crate:main deps:std
+//- minicore: future
 use std::future::*;
 fn foo() {
     let a = async {};
     a.$0
 }
-
-//- /std/lib.rs crate:std
-pub mod future {
-    #[lang = "future_trait"]
-    pub trait Future {
-        type Output;
-    }
-}
 "#,
             expect![[r#"
                 kw await expr.await
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index 952f052a1..f86b2d3f3 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -809,4 +809,22 @@ fn foo(_: impl Foo<B$0>) {}
             "#]],
         );
     }
+
+    #[test]
+    fn completes_assoc_types_in_trait_bound() {
+        check(
+            r#"
+trait Foo {
+    type Bar;
+}
+
+fn foo<T: Foo<B$0>>(_: T) {}
+"#,
+            expect![[r#"
+                ta Bar =  type Bar;
+                tp T
+                tt Foo
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index d8ca18c73..3eb51e80b 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -1152,16 +1152,11 @@ fn main() {
     fn suggest_deref() {
         check_relevance(
             r#"
-#[lang = "deref"]
-trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
-
+//- minicore: deref
 struct S;
 struct T(S);
 
-impl Deref for T {
+impl core::ops::Deref for T {
     type Target = S;
 
     fn deref(&self) -> &Self::Target {
@@ -1185,8 +1180,9 @@ fn main() {
                 st T []
                 st S []
                 fn main() []
-                tt Deref []
                 fn foo(…) []
+                md core []
+                tt Sized []
             "#]],
         )
     }
diff --git a/crates/ide_db/src/assists.rs b/crates/ide_db/src/assists.rs
new file mode 100644
index 000000000..7881d8369
--- /dev/null
+++ b/crates/ide_db/src/assists.rs
@@ -0,0 +1,136 @@
+//! This module defines the `Assist` data structure. The actual assist live in
+//! the `ide_assists` downstream crate. We want to define the data structures in
+//! this low-level crate though, because `ide_diagnostics` also need them
+//! (fixits for diagnostics and assists are the same thing under the hood). We
+//! want to compile `ide_assists` and `ide_diagnostics` in parallel though, so
+//! we pull the common definitions upstream, to this crate.
+
+use std::str::FromStr;
+
+use syntax::TextRange;
+
+use crate::{label::Label, source_change::SourceChange};
+
+#[derive(Debug, Clone)]
+pub struct Assist {
+    pub id: AssistId,
+    /// Short description of the assist, as shown in the UI.
+    pub label: Label,
+    pub group: Option<GroupLabel>,
+    /// Target ranges are used to sort assists: the smaller the target range,
+    /// the more specific assist is, and so it should be sorted first.
+    pub target: TextRange,
+    /// Computing source change sometimes is much more costly then computing the
+    /// other fields. Additionally, the actual change is not required to show
+    /// the lightbulb UI, it only is needed when the user tries to apply an
+    /// assist. So, we compute it lazily: the API allow requesting assists with
+    /// or without source change. We could (and in fact, used to) distinguish
+    /// between resolved and unresolved assists at the type level, but this is
+    /// cumbersome, especially if you want to embed an assist into another data
+    /// structure, such as a diagnostic.
+    pub source_change: Option<SourceChange>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AssistKind {
+    // FIXME: does the None variant make sense? Probably not.
+    None,
+
+    QuickFix,
+    Generate,
+    Refactor,
+    RefactorExtract,
+    RefactorInline,
+    RefactorRewrite,
+}
+
+impl AssistKind {
+    pub fn contains(self, other: AssistKind) -> bool {
+        if self == other {
+            return true;
+        }
+
+        match self {
+            AssistKind::None | AssistKind::Generate => true,
+            AssistKind::Refactor => match other {
+                AssistKind::RefactorExtract
+                | AssistKind::RefactorInline
+                | AssistKind::RefactorRewrite => true,
+                _ => false,
+            },
+            _ => false,
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        match self {
+            AssistKind::None => "None",
+            AssistKind::QuickFix => "QuickFix",
+            AssistKind::Generate => "Generate",
+            AssistKind::Refactor => "Refactor",
+            AssistKind::RefactorExtract => "RefactorExtract",
+            AssistKind::RefactorInline => "RefactorInline",
+            AssistKind::RefactorRewrite => "RefactorRewrite",
+        }
+    }
+}
+
+impl FromStr for AssistKind {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "None" => Ok(AssistKind::None),
+            "QuickFix" => Ok(AssistKind::QuickFix),
+            "Generate" => Ok(AssistKind::Generate),
+            "Refactor" => Ok(AssistKind::Refactor),
+            "RefactorExtract" => Ok(AssistKind::RefactorExtract),
+            "RefactorInline" => Ok(AssistKind::RefactorInline),
+            "RefactorRewrite" => Ok(AssistKind::RefactorRewrite),
+            unknown => Err(format!("Unknown AssistKind: '{}'", unknown)),
+        }
+    }
+}
+
+/// Unique identifier of the assist, should not be shown to the user
+/// directly.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AssistId(pub &'static str, pub AssistKind);
+
+/// A way to control how many asssist to resolve during the assist resolution.
+/// When an assist is resolved, its edits are calculated that might be costly to always do by default.
+#[derive(Debug)]
+pub enum AssistResolveStrategy {
+    /// No assists should be resolved.
+    None,
+    /// All assists should be resolved.
+    All,
+    /// Only a certain assist should be resolved.
+    Single(SingleResolve),
+}
+
+/// Hold the [`AssistId`] data of a certain assist to resolve.
+/// The original id object cannot be used due to a `'static` lifetime
+/// and the requirement to construct this struct dynamically during the resolve handling.
+#[derive(Debug)]
+pub struct SingleResolve {
+    /// The id of the assist.
+    pub assist_id: String,
+    // The kind of the assist.
+    pub assist_kind: AssistKind,
+}
+
+impl AssistResolveStrategy {
+    pub fn should_resolve(&self, id: &AssistId) -> bool {
+        match self {
+            AssistResolveStrategy::None => false,
+            AssistResolveStrategy::All => true,
+            AssistResolveStrategy::Single(single_resolve) => {
+                single_resolve.assist_id == id.0 && single_resolve.assist_kind == id.1
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct GroupLabel(pub String);
diff --git a/crates/ide_db/src/helpers/insert_use/tests.rs b/crates/ide_db/src/helpers/insert_use/tests.rs
index 70b11bf81..5a88ec742 100644
--- a/crates/ide_db/src/helpers/insert_use/tests.rs
+++ b/crates/ide_db/src/helpers/insert_use/tests.rs
@@ -511,13 +511,14 @@ use std::io;
 }
 
 #[test]
-#[ignore] // FIXME: Support this
 fn split_out_merge() {
+    // FIXME: This is suboptimal, we want to get `use std::fmt::{self, Result}`
+    // instead.
     check_module(
         "std::fmt::Result",
         r"use std::{fmt, io};",
-        r"use std::fmt::{self, Result};
-use std::io;",
+        r"use std::fmt::Result;
+use std::{fmt, io};",
     )
 }
 
diff --git a/crates/ide_db/src/lib.rs b/crates/ide_db/src/lib.rs
index 105607dca..7bbd08d6f 100644
--- a/crates/ide_db/src/lib.rs
+++ b/crates/ide_db/src/lib.rs
@@ -3,11 +3,11 @@
 //! It is mainly a `HirDatabase` for semantic analysis, plus a `SymbolsDatabase`, for fuzzy search.
 
 mod apply_change;
+pub mod assists;
 pub mod label;
 pub mod line_index;
 pub mod symbol_index;
 pub mod defs;
-pub mod search;
 pub mod items_locator;
 pub mod source_change;
 pub mod ty_filter;
@@ -15,6 +15,9 @@ pub mod traits;
 pub mod call_info;
 pub mod helpers;
 
+pub mod search;
+pub mod rename;
+
 use std::{fmt, sync::Arc};
 
 use base_db::{
diff --git a/crates/ide_db/src/rename.rs b/crates/ide_db/src/rename.rs
new file mode 100644
index 000000000..643e67781
--- /dev/null
+++ b/crates/ide_db/src/rename.rs
@@ -0,0 +1,468 @@
+//! Rename infrastructure for rust-analyzer. It is used primarily for the
+//! literal "rename" in the ide (look for tests there), but it is also available
+//! as a general-purpose service. For example, it is used by the fix for the
+//! "incorrect case" diagnostic.
+//!
+//! It leverages the [`crate::search`] functionality to find what needs to be
+//! renamed. The actual renames are tricky -- field shorthands need special
+//! attention, and, when renaming modules, you also want to rename files on the
+//! file system.
+//!
+//! Another can of worms are macros:
+//!
+//! ```
+//! macro_rules! m { () => { fn f() {} } }
+//! m!();
+//! fn main() {
+//!     f() // <- rename me
+//! }
+//! ```
+//!
+//! The correct behavior in such cases is probably to show a dialog to the user.
+//! Our current behavior is ¯\_(ツ)_/¯.
+use std::fmt;
+
+use base_db::{AnchoredPathBuf, FileId, FileRange};
+use either::Either;
+use hir::{AsAssocItem, FieldSource, HasSource, InFile, ModuleSource, Semantics};
+use stdx::never;
+use syntax::{
+    ast::{self, NameOwner},
+    lex_single_syntax_kind, AstNode, SyntaxKind, TextRange, T,
+};
+use text_edit::TextEdit;
+
+use crate::{
+    defs::Definition,
+    search::FileReference,
+    source_change::{FileSystemEdit, SourceChange},
+    RootDatabase,
+};
+
+pub type Result<T, E = RenameError> = std::result::Result<T, E>;
+
+#[derive(Debug)]
+pub struct RenameError(pub String);
+
+impl fmt::Display for RenameError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
+#[macro_export]
+macro_rules! _format_err {
+    ($fmt:expr) => { RenameError(format!($fmt)) };
+    ($fmt:expr, $($arg:tt)+) => { RenameError(format!($fmt, $($arg)+)) }
+}
+pub use _format_err as format_err;
+
+#[macro_export]
+macro_rules! _bail {
+    ($($tokens:tt)*) => { return Err(format_err!($($tokens)*)) }
+}
+pub use _bail as bail;
+
+impl Definition {
+    pub fn rename(&self, sema: &Semantics<RootDatabase>, new_name: &str) -> Result<SourceChange> {
+        match *self {
+            Definition::ModuleDef(hir::ModuleDef::Module(module)) => {
+                rename_mod(sema, module, new_name)
+            }
+            Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => {
+                bail!("Cannot rename builtin type")
+            }
+            Definition::SelfType(_) => bail!("Cannot rename `Self`"),
+            def => rename_reference(sema, def, new_name),
+        }
+    }
+
+    /// Textual range of the identifier which will change when renaming this
+    /// `Definition`. Note that some definitions, like buitin types, can't be
+    /// renamed.
+    pub fn range_for_rename(self, sema: &Semantics<RootDatabase>) -> Option<FileRange> {
+        // FIXME: the `original_file_range` calls here are wrong -- they never fail,
+        // and _fall back_ to the entirety of the macro call. Such fall back is
+        // incorrect for renames. The safe behavior would be to return an error for
+        // such cases. The correct behavior would be to return an auxiliary list of
+        // "can't rename these occurrences in macros" items, and then show some kind
+        // of a dialog to the user. See:
+        cov_mark::hit!(macros_are_broken_lol);
+
+        let res = match self {
+            Definition::Macro(mac) => {
+                let src = mac.source(sema.db)?;
+                let name = match &src.value {
+                    Either::Left(it) => it.name()?,
+                    Either::Right(it) => it.name()?,
+                };
+                src.with_value(name.syntax()).original_file_range(sema.db)
+            }
+            Definition::Field(field) => {
+                let src = field.source(sema.db)?;
+
+                match &src.value {
+                    FieldSource::Named(record_field) => {
+                        let name = record_field.name()?;
+                        src.with_value(name.syntax()).original_file_range(sema.db)
+                    }
+                    FieldSource::Pos(_) => {
+                        return None;
+                    }
+                }
+            }
+            Definition::ModuleDef(module_def) => match module_def {
+                hir::ModuleDef::Module(module) => {
+                    let src = module.declaration_source(sema.db)?;
+                    let name = src.value.name()?;
+                    src.with_value(name.syntax()).original_file_range(sema.db)
+                }
+                hir::ModuleDef::Function(it) => name_range(it, sema)?,
+                hir::ModuleDef::Adt(adt) => match adt {
+                    hir::Adt::Struct(it) => name_range(it, sema)?,
+                    hir::Adt::Union(it) => name_range(it, sema)?,
+                    hir::Adt::Enum(it) => name_range(it, sema)?,
+                },
+                hir::ModuleDef::Variant(it) => name_range(it, sema)?,
+                hir::ModuleDef::Const(it) => name_range(it, sema)?,
+                hir::ModuleDef::Static(it) => name_range(it, sema)?,
+                hir::ModuleDef::Trait(it) => name_range(it, sema)?,
+                hir::ModuleDef::TypeAlias(it) => name_range(it, sema)?,
+                hir::ModuleDef::BuiltinType(_) => return None,
+            },
+            Definition::SelfType(_) => return None,
+            Definition::Local(local) => {
+                let src = local.source(sema.db);
+                let name = match &src.value {
+                    Either::Left(bind_pat) => bind_pat.name()?,
+                    Either::Right(_) => return None,
+                };
+                src.with_value(name.syntax()).original_file_range(sema.db)
+            }
+            Definition::GenericParam(generic_param) => match generic_param {
+                hir::GenericParam::TypeParam(type_param) => {
+                    let src = type_param.source(sema.db)?;
+                    let name = match &src.value {
+                        Either::Left(type_param) => type_param.name()?,
+                        Either::Right(_trait) => return None,
+                    };
+                    src.with_value(name.syntax()).original_file_range(sema.db)
+                }
+                hir::GenericParam::LifetimeParam(lifetime_param) => {
+                    let src = lifetime_param.source(sema.db)?;
+                    let lifetime = src.value.lifetime()?;
+                    src.with_value(lifetime.syntax()).original_file_range(sema.db)
+                }
+                hir::GenericParam::ConstParam(it) => name_range(it, sema)?,
+            },
+            Definition::Label(label) => {
+                let src = label.source(sema.db);
+                let lifetime = src.value.lifetime()?;
+                src.with_value(lifetime.syntax()).original_file_range(sema.db)
+            }
+        };
+        return Some(res);
+
+        fn name_range<D>(def: D, sema: &Semantics<RootDatabase>) -> Option<FileRange>
+        where
+            D: HasSource,
+            D::Ast: ast::NameOwner,
+        {
+            let src = def.source(sema.db)?;
+            let name = src.value.name()?;
+            let res = src.with_value(name.syntax()).original_file_range(sema.db);
+            Some(res)
+        }
+    }
+}
+
+fn rename_mod(
+    sema: &Semantics<RootDatabase>,
+    module: hir::Module,
+    new_name: &str,
+) -> Result<SourceChange> {
+    if IdentifierKind::classify(new_name)? != IdentifierKind::Ident {
+        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(hir::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,
+) -> Result<SourceChange> {
+    let ident_kind = IdentifierKind::classify(new_name)?;
+
+    if matches!(
+        def, // is target a lifetime?
+        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
+    ) {
+        match ident_kind {
+            IdentifierKind::Ident | 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::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), hir::ModuleDef::Function(func))
+                        if trait_func.name(sema.db) == func.name(sema.db) =>
+                    {
+                        Some(Definition::ModuleDef(hir::ModuleDef::Function(trait_func)))
+                    }
+                    (hir::AssocItem::Const(trait_konst), hir::ModuleDef::Const(konst))
+                        if trait_konst.name(sema.db) == konst.name(sema.db) =>
+                    {
+                        Some(Definition::ModuleDef(hir::ModuleDef::Const(trait_konst)))
+                    }
+                    (
+                        hir::AssocItem::TypeAlias(trait_type_alias),
+                        hir::ModuleDef::TypeAlias(type_alias),
+                    ) if trait_type_alias.name(sema.db) == type_alias.name(sema.db) => {
+                        Some(Definition::ModuleDef(hir::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)
+}
+
+pub 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,
+) -> Result<(FileId, TextEdit)> {
+    let frange = def
+        .range_for_rename(sema)
+        .ok_or_else(|| format_err!("No identifier available to rename"))?;
+
+    let mut replacement_text = String::new();
+    let mut repl_range = frange.range;
+    if let Definition::Local(local) = def {
+        if let Either::Left(pat) = local.source(sema.db).value {
+            if matches!(
+                pat.syntax().parent().and_then(ast::RecordPatField::cast),
+                Some(pat_field) if pat_field.name_ref().is_none()
+            ) {
+                replacement_text.push_str(": ");
+                replacement_text.push_str(new_name);
+                repl_range = TextRange::new(
+                    pat.syntax().text_range().end(),
+                    pat.syntax().text_range().end(),
+                );
+            }
+        }
+    }
+    if replacement_text.is_empty() {
+        replacement_text.push_str(new_name);
+    }
+    let edit = TextEdit::replace(repl_range, replacement_text);
+    Ok((frange.file_id, edit))
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum IdentifierKind {
+    Ident,
+    Lifetime,
+    Underscore,
+}
+
+impl IdentifierKind {
+    pub fn classify(new_name: &str) -> Result<IdentifierKind> {
+        match lex_single_syntax_kind(new_name) {
+            Some(res) => match res {
+                (SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident),
+                (T![_], _) => Ok(IdentifierKind::Underscore),
+                (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),
+        }
+    }
+}
diff --git a/crates/ide_diagnostics/Cargo.toml b/crates/ide_diagnostics/Cargo.toml
new file mode 100644
index 000000000..fa2adf212
--- /dev/null
+++ b/crates/ide_diagnostics/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "ide_diagnostics"
+version = "0.0.0"
+description = "TBD"
+license = "MIT OR Apache-2.0"
+authors = ["rust-analyzer developers"]
+edition = "2018"
+
+[lib]
+doctest = false
+
+[dependencies]
+cov-mark = "2.0.0-pre.1"
+itertools = "0.10.0"
+rustc-hash = "1.1.0"
+either = "1.5.3"
+
+profile = { path = "../profile", version = "0.0.0" }
+stdx = { path = "../stdx", version = "0.0.0" }
+syntax = { path = "../syntax", version = "0.0.0" }
+text_edit = { path = "../text_edit", version = "0.0.0" }
+cfg = { path = "../cfg", version = "0.0.0" }
+hir = { path = "../hir", version = "0.0.0" }
+ide_db = { path = "../ide_db", version = "0.0.0" }
+
+[dev-dependencies]
+expect-test = "1.1"
+
+test_utils = { path = "../test_utils" }
diff --git a/crates/ide/src/diagnostics/break_outside_of_loop.rs b/crates/ide_diagnostics/src/handlers/break_outside_of_loop.rs
index 80e68f3cc..d12594a4c 100644
--- a/crates/ide/src/diagnostics/break_outside_of_loop.rs
+++ b/crates/ide_diagnostics/src/handlers/break_outside_of_loop.rs
@@ -1,9 +1,9 @@
-use crate::diagnostics::{Diagnostic, DiagnosticsContext};
+use crate::{Diagnostic, DiagnosticsContext};
 
 // Diagnostic: break-outside-of-loop
 //
 // This diagnostic is triggered if the `break` keyword is used outside of a loop.
-pub(super) fn break_outside_of_loop(
+pub(crate) fn break_outside_of_loop(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::BreakOutsideOfLoop,
 ) -> Diagnostic {
@@ -16,14 +16,14 @@ pub(super) fn break_outside_of_loop(
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::check_diagnostics;
+    use crate::tests::check_diagnostics;
 
     #[test]
     fn break_outside_of_loop() {
         check_diagnostics(
             r#"
 fn foo() { break; }
-         //^^^^^ break outside of loop
+         //^^^^^ error: break outside of loop
 "#,
         );
     }
diff --git a/crates/ide/src/diagnostics/field_shorthand.rs b/crates/ide_diagnostics/src/handlers/field_shorthand.rs
index c7f4dab8e..33152e284 100644
--- a/crates/ide/src/diagnostics/field_shorthand.rs
+++ b/crates/ide_diagnostics/src/handlers/field_shorthand.rs
@@ -5,9 +5,9 @@ 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, Severity};
+use crate::{fix, Diagnostic, Severity};
 
-pub(super) fn check(acc: &mut Vec<Diagnostic>, file_id: FileId, node: &SyntaxNode) {
+pub(crate) fn field_shorthand(acc: &mut Vec<Diagnostic>, file_id: FileId, node: &SyntaxNode) {
     match_ast! {
         match node {
             ast::RecordExpr(it) => check_expr_field_shorthand(acc, file_id, it),
@@ -101,7 +101,7 @@ fn check_pat_field_shorthand(
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::{check_diagnostics, check_fix};
+    use crate::tests::{check_diagnostics, check_fix};
 
     #[test]
     fn test_check_expr_field_shorthand() {
diff --git a/crates/ide/src/diagnostics/inactive_code.rs b/crates/ide_diagnostics/src/handlers/inactive_code.rs
index d9d3e88c1..dfd0e3351 100644
--- a/crates/ide/src/diagnostics/inactive_code.rs
+++ b/crates/ide_diagnostics/src/handlers/inactive_code.rs
@@ -1,15 +1,12 @@
 use cfg::DnfExpr;
 use stdx::format_to;
 
-use crate::{
-    diagnostics::{Diagnostic, DiagnosticsContext},
-    Severity,
-};
+use crate::{Diagnostic, DiagnosticsContext, Severity};
 
 // Diagnostic: inactive-code
 //
 // This diagnostic is shown for code with inactive `#[cfg]` attributes.
-pub(super) fn inactive_code(
+pub(crate) fn inactive_code(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::InactiveCode,
 ) -> Option<Diagnostic> {
@@ -37,7 +34,7 @@ pub(super) fn inactive_code(
 
 #[cfg(test)]
 mod tests {
-    use crate::{diagnostics::tests::check_diagnostics_with_config, DiagnosticsConfig};
+    use crate::{tests::check_diagnostics_with_config, DiagnosticsConfig};
 
     pub(crate) fn check(ra_fixture: &str) {
         let config = DiagnosticsConfig::default();
@@ -52,26 +49,26 @@ fn f() {
     // The three g̶e̶n̶d̶e̶r̶s̶ statements:
 
     #[cfg(a)] fn f() {}  // Item statement
-  //^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+  //^^^^^^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: a is disabled
     #[cfg(a)] {}         // Expression statement
-  //^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+  //^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: a is disabled
     #[cfg(a)] let x = 0; // let statement
-  //^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+  //^^^^^^^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: a is disabled
 
     abc(#[cfg(a)] 0);
-      //^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+      //^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: a is disabled
     let x = Struct {
         #[cfg(a)] f: 0,
-      //^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+      //^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: a is disabled
     };
     match () {
         () => (),
         #[cfg(a)] () => (),
-      //^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+      //^^^^^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: a is disabled
     }
 
     #[cfg(a)] 0          // Trailing expression of block
-  //^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+  //^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: a is disabled
 }
         "#,
         );
@@ -84,16 +81,16 @@ fn f() {
         check(
             r#"
     #[cfg(no)] pub fn f() {}
-  //^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no is disabled
+  //^^^^^^^^^^^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: no is disabled
 
     #[cfg(no)] #[cfg(no2)] mod m;
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no and no2 are disabled
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: no and no2 are disabled
 
     #[cfg(all(not(a), b))] enum E {}
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: b is disabled
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: b is disabled
 
     #[cfg(feature = "std")] use std;
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: feature = "std" is disabled
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: feature = "std" is disabled
 "#,
         );
     }
@@ -105,14 +102,14 @@ fn f() {
         check(
             r#"
     #[cfg_attr(not(never), cfg(no))] fn f() {}
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no is disabled
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: no is disabled
 
     #[cfg_attr(not(never), cfg(not(no)))] fn f() {}
 
     #[cfg_attr(never, cfg(no))] fn g() {}
 
     #[cfg_attr(not(never), inline, cfg(no))] fn h() {}
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no is disabled
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: no is disabled
 "#,
         );
     }
diff --git a/crates/ide/src/diagnostics/incorrect_case.rs b/crates/ide_diagnostics/src/handlers/incorrect_case.rs
index 832394400..68f25f284 100644
--- a/crates/ide/src/diagnostics/incorrect_case.rs
+++ b/crates/ide_diagnostics/src/handlers/incorrect_case.rs
@@ -1,18 +1,19 @@
 use hir::{db::AstDatabase, InFile};
-use ide_assists::Assist;
-use ide_db::base_db::FilePosition;
+use ide_db::{assists::Assist, defs::NameClass};
 use syntax::AstNode;
 
 use crate::{
-    diagnostics::{unresolved_fix, Diagnostic, DiagnosticsContext},
-    references::rename::rename_with_semantics,
+    // references::rename::rename_with_semantics,
+    unresolved_fix,
+    Diagnostic,
+    DiagnosticsContext,
     Severity,
 };
 
 // Diagnostic: incorrect-ident-case
 //
 // This diagnostic is triggered if an item name doesn't follow https://doc.rust-lang.org/1.0.0/style/style/naming/README.html[Rust naming convention].
-pub(super) fn incorrect_case(ctx: &DiagnosticsContext<'_>, d: &hir::IncorrectCase) -> Diagnostic {
+pub(crate) fn incorrect_case(ctx: &DiagnosticsContext<'_>, d: &hir::IncorrectCase) -> Diagnostic {
     Diagnostic::new(
         "incorrect-ident-case",
         format!(
@@ -28,15 +29,15 @@ pub(super) fn incorrect_case(ctx: &DiagnosticsContext<'_>, d: &hir::IncorrectCas
 fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::IncorrectCase) -> Option<Vec<Assist>> {
     let root = ctx.sema.db.parse_or_expand(d.file)?;
     let name_node = d.ident.to_node(&root);
+    let def = NameClass::classify(&ctx.sema, &name_node)?.defined(ctx.sema.db)?;
 
     let name_node = InFile::new(d.file, name_node.syntax());
     let frange = name_node.original_file_range(ctx.sema.db);
-    let file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
 
     let label = format!("Rename to {}", d.suggested_text);
     let mut res = unresolved_fix("change_case", &label, frange.range);
     if ctx.resolve.should_resolve(&res.id) {
-        let source_change = rename_with_semantics(&ctx.sema, file_position, &d.suggested_text);
+        let source_change = def.rename(&ctx.sema, &d.suggested_text);
         res.source_change = Some(source_change.ok().unwrap_or_default());
     }
 
@@ -45,10 +46,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::IncorrectCase) -> Option<Vec<Ass
 
 #[cfg(test)]
 mod change_case {
-    use crate::{
-        diagnostics::tests::{check_diagnostics, check_fix},
-        fixture, AssistResolveStrategy, DiagnosticsConfig,
-    };
+    use crate::tests::{check_diagnostics, check_fix};
 
     #[test]
     fn test_rename_incorrect_case() {
@@ -116,7 +114,7 @@ fn some_fn() {
         check_diagnostics(
             r#"
 fn foo() {
-    const ANOTHER_ITEM$0: &str = "some_item";
+    const ANOTHER_ITEM: &str = "some_item";
 }
 "#,
         );
@@ -148,20 +146,13 @@ impl 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);
+        check_diagnostics(
+            r#"
+fn FOO() {}
+// ^^^ 💡 weak: Function `FOO` should have snake_case name, e.g. `foo`
+"#,
+        );
+        check_fix(r#"fn FOO$0() {}"#, r#"fn foo() {}"#);
     }
 
     #[test]
@@ -169,7 +160,7 @@ impl TestStruct {
         check_diagnostics(
             r#"
 fn NonSnakeCaseName() {}
-// ^^^^^^^^^^^^^^^^ Function `NonSnakeCaseName` should have snake_case name, e.g. `non_snake_case_name`
+// ^^^^^^^^^^^^^^^^ 💡 weak: Function `NonSnakeCaseName` should have snake_case name, e.g. `non_snake_case_name`
 "#,
         );
     }
@@ -179,10 +170,10 @@ fn NonSnakeCaseName() {}
         check_diagnostics(
             r#"
 fn foo(SomeParam: u8) {}
-    // ^^^^^^^^^ Parameter `SomeParam` should have snake_case name, e.g. `some_param`
+    // ^^^^^^^^^ 💡 weak: Parameter `SomeParam` should have snake_case name, e.g. `some_param`
 
 fn foo2(ok_param: &str, CAPS_PARAM: u8) {}
-                     // ^^^^^^^^^^ Parameter `CAPS_PARAM` should have snake_case name, e.g. `caps_param`
+                     // ^^^^^^^^^^ 💡 weak: Parameter `CAPS_PARAM` should have snake_case name, e.g. `caps_param`
 "#,
         );
     }
@@ -193,9 +184,9 @@ fn foo2(ok_param: &str, CAPS_PARAM: u8) {}
             r#"
 fn foo() {
     let SOME_VALUE = 10;
-     // ^^^^^^^^^^ Variable `SOME_VALUE` should have snake_case name, e.g. `some_value`
+     // ^^^^^^^^^^ 💡 weak: Variable `SOME_VALUE` should have snake_case name, e.g. `some_value`
     let AnotherValue = 20;
-     // ^^^^^^^^^^^^ Variable `AnotherValue` should have snake_case name, e.g. `another_value`
+     // ^^^^^^^^^^^^ 💡 weak: Variable `AnotherValue` should have snake_case name, e.g. `another_value`
 }
 "#,
         );
@@ -206,10 +197,10 @@ fn foo() {
         check_diagnostics(
             r#"
 struct non_camel_case_name {}
-    // ^^^^^^^^^^^^^^^^^^^ Structure `non_camel_case_name` should have CamelCase name, e.g. `NonCamelCaseName`
+    // ^^^^^^^^^^^^^^^^^^^ 💡 weak: Structure `non_camel_case_name` should have CamelCase name, e.g. `NonCamelCaseName`
 
 struct SCREAMING_CASE {}
-    // ^^^^^^^^^^^^^^ Structure `SCREAMING_CASE` should have CamelCase name, e.g. `ScreamingCase`
+    // ^^^^^^^^^^^^^^ 💡 weak: Structure `SCREAMING_CASE` should have CamelCase name, e.g. `ScreamingCase`
 "#,
         );
     }
@@ -228,7 +219,7 @@ struct AABB {}
         check_diagnostics(
             r#"
 struct SomeStruct { SomeField: u8 }
-                 // ^^^^^^^^^ Field `SomeField` should have snake_case name, e.g. `some_field`
+                 // ^^^^^^^^^ 💡 weak: Field `SomeField` should have snake_case name, e.g. `some_field`
 "#,
         );
     }
@@ -238,10 +229,10 @@ struct SomeStruct { SomeField: u8 }
         check_diagnostics(
             r#"
 enum some_enum { Val(u8) }
-  // ^^^^^^^^^ Enum `some_enum` should have CamelCase name, e.g. `SomeEnum`
+  // ^^^^^^^^^ 💡 weak: Enum `some_enum` should have CamelCase name, e.g. `SomeEnum`
 
 enum SOME_ENUM {}
-  // ^^^^^^^^^ Enum `SOME_ENUM` should have CamelCase name, e.g. `SomeEnum`
+  // ^^^^^^^^^ 💡 weak: Enum `SOME_ENUM` should have CamelCase name, e.g. `SomeEnum`
 "#,
         );
     }
@@ -260,7 +251,7 @@ enum AABB {}
         check_diagnostics(
             r#"
 enum SomeEnum { SOME_VARIANT(u8) }
-             // ^^^^^^^^^^^^ Variant `SOME_VARIANT` should have CamelCase name, e.g. `SomeVariant`
+             // ^^^^^^^^^^^^ 💡 weak: Variant `SOME_VARIANT` should have CamelCase name, e.g. `SomeVariant`
 "#,
         );
     }
@@ -270,7 +261,7 @@ enum SomeEnum { SOME_VARIANT(u8) }
         check_diagnostics(
             r#"
 const some_weird_const: u8 = 10;
-   // ^^^^^^^^^^^^^^^^ Constant `some_weird_const` should have UPPER_SNAKE_CASE name, e.g. `SOME_WEIRD_CONST`
+   // ^^^^^^^^^^^^^^^^ 💡 weak: Constant `some_weird_const` should have UPPER_SNAKE_CASE name, e.g. `SOME_WEIRD_CONST`
 "#,
         );
     }
@@ -280,7 +271,7 @@ const some_weird_const: u8 = 10;
         check_diagnostics(
             r#"
 static some_weird_const: u8 = 10;
-    // ^^^^^^^^^^^^^^^^ Static variable `some_weird_const` should have UPPER_SNAKE_CASE name, e.g. `SOME_WEIRD_CONST`
+    // ^^^^^^^^^^^^^^^^ 💡 weak: Static variable `some_weird_const` should have UPPER_SNAKE_CASE name, e.g. `SOME_WEIRD_CONST`
 "#,
         );
     }
@@ -290,13 +281,13 @@ static some_weird_const: u8 = 10;
         check_diagnostics(
             r#"
 struct someStruct;
-    // ^^^^^^^^^^ Structure `someStruct` should have CamelCase name, e.g. `SomeStruct`
+    // ^^^^^^^^^^ 💡 weak: Structure `someStruct` should have CamelCase name, e.g. `SomeStruct`
 
 impl someStruct {
     fn SomeFunc(&self) {
-    // ^^^^^^^^ Function `SomeFunc` should have snake_case name, e.g. `some_func`
+    // ^^^^^^^^ 💡 weak: Function `SomeFunc` should have snake_case name, e.g. `some_func`
         let WHY_VAR_IS_CAPS = 10;
-         // ^^^^^^^^^^^^^^^ Variable `WHY_VAR_IS_CAPS` should have snake_case name, e.g. `why_var_is_caps`
+         // ^^^^^^^^^^^^^^^ 💡 weak: Variable `WHY_VAR_IS_CAPS` should have snake_case name, e.g. `why_var_is_caps`
     }
 }
 "#,
@@ -328,7 +319,7 @@ enum Option { Some, None }
 fn main() {
     match Option::None {
         SOME_VAR @ None => (),
-     // ^^^^^^^^ Variable `SOME_VAR` should have snake_case name, e.g. `some_var`
+     // ^^^^^^^^ 💡 weak: Variable `SOME_VAR` should have snake_case name, e.g. `some_var`
         Some => (),
     }
 }
@@ -350,43 +341,27 @@ mod F {
     }
 
     #[test]
-    #[ignore]
-    fn bug_trait_inside_fn() {
-        // FIXME:
-        // This is broken, and in fact, should not even be looked at by this
-        // lint in the first place. There's weird stuff going on in the
-        // collection phase.
-        // It's currently being brought in by:
-        // * validate_func on `a` recursing into modules
-        // * then it finds the trait and then the function while iterating
-        //   through modules
-        // * then validate_func is called on Dirty
-        // * ... which then proceeds to look at some unknown module taking no
-        //   attrs from either the impl or the fn a, and then finally to the root
-        //   module
-        //
-        // It should find the attribute on the trait, but it *doesn't even see
-        // the trait* as far as I can tell.
-
+    fn complex_ignore() {
+        // FIXME: this should trigger errors for the second case.
         check_diagnostics(
             r#"
 trait T { fn a(); }
 struct U {}
 impl T for U {
     fn a() {
-        // this comes out of bitflags, mostly
         #[allow(non_snake_case)]
-        trait __BitFlags {
+        trait __BitFlagsOk {
             const HiImAlsoBad: u8 = 2;
-            #[inline]
-            fn Dirty(&self) -> bool {
-                false
-            }
+            fn Dirty(&self) -> bool { false }
         }
 
+        trait __BitFlagsBad {
+            const HiImAlsoBad: u8 = 2;
+            fn Dirty(&self) -> bool { false }
+        }
     }
 }
-    "#,
+"#,
         );
     }
 
@@ -423,18 +398,14 @@ extern {
     }
 
     #[test]
-    #[ignore]
     fn bug_traits_arent_checked() {
         // FIXME: Traits and functions in traits aren't currently checked by
         // r-a, even though rustc will complain about them.
         check_diagnostics(
             r#"
 trait BAD_TRAIT {
-    // ^^^^^^^^^ Trait `BAD_TRAIT` should have CamelCase name, e.g. `BadTrait`
     fn BAD_FUNCTION();
-    // ^^^^^^^^^^^^ Function `BAD_FUNCTION` should have snake_case name, e.g. `bad_function`
     fn BadFunction();
-    // ^^^^^^^^^^^^ Function `BadFunction` should have snake_case name, e.g. `bad_function`
 }
     "#,
         );
diff --git a/crates/ide/src/diagnostics/macro_error.rs b/crates/ide_diagnostics/src/handlers/macro_error.rs
index 5f97f190d..356f089b2 100644
--- a/crates/ide/src/diagnostics/macro_error.rs
+++ b/crates/ide_diagnostics/src/handlers/macro_error.rs
@@ -1,9 +1,9 @@
-use crate::diagnostics::{Diagnostic, DiagnosticsContext};
+use crate::{Diagnostic, DiagnosticsContext};
 
 // Diagnostic: macro-error
 //
 // This diagnostic is shown for macro expansion errors.
-pub(super) fn macro_error(ctx: &DiagnosticsContext<'_>, d: &hir::MacroError) -> Diagnostic {
+pub(crate) fn macro_error(ctx: &DiagnosticsContext<'_>, d: &hir::MacroError) -> Diagnostic {
     Diagnostic::new(
         "macro-error",
         d.message.clone(),
@@ -15,7 +15,7 @@ pub(super) fn macro_error(ctx: &DiagnosticsContext<'_>, d: &hir::MacroError) ->
 #[cfg(test)]
 mod tests {
     use crate::{
-        diagnostics::tests::{check_diagnostics, check_diagnostics_with_config},
+        tests::{check_diagnostics, check_diagnostics_with_config},
         DiagnosticsConfig,
     };
 
@@ -27,7 +27,7 @@ mod tests {
 macro_rules! include { () => {} }
 
   include!("doesntexist");
-//^^^^^^^^^^^^^^^^^^^^^^^^ failed to load file `doesntexist`
+//^^^^^^^^^^^^^^^^^^^^^^^^ error: failed to load file `doesntexist`
             "#,
         );
     }
@@ -66,7 +66,7 @@ macro_rules! env { () => {} }
 macro_rules! concat { () => {} }
 
   include!(concat!(env!("OUT_DIR"), "/out.rs"));
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "run build scripts" to fix
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: `OUT_DIR` not set, enable "run build scripts" to fix
 "#,
         );
     }
@@ -108,23 +108,23 @@ fn main() {
     // Test a handful of built-in (eager) macros:
 
     include!(invalid);
-  //^^^^^^^^^^^^^^^^^ could not convert tokens
+  //^^^^^^^^^^^^^^^^^ error: could not convert tokens
     include!("does not exist");
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^ failed to load file `does not exist`
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^ error: failed to load file `does not exist`
 
     env!(invalid);
-  //^^^^^^^^^^^^^ could not convert tokens
+  //^^^^^^^^^^^^^ error: could not convert tokens
 
     env!("OUT_DIR");
-  //^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "run build scripts" to fix
+  //^^^^^^^^^^^^^^^ error: `OUT_DIR` not set, enable "run build scripts" to fix
 
     compile_error!("compile_error works");
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ compile_error works
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: compile_error works
 
     // Lazy:
 
     format_args!();
-  //^^^^^^^^^^^^^^ no rule matches input tokens
+  //^^^^^^^^^^^^^^ error: no rule matches input tokens
 }
 "#,
         );
@@ -141,7 +141,7 @@ fn f() {
     m!();
 
     m!(hi);
-  //^^^^^^ leftover tokens
+  //^^^^^^ error: leftover tokens
 }
       "#,
         );
@@ -166,7 +166,7 @@ macro_rules! outer {
 
 fn f() {
     outer!();
-} //^^^^^^^^ leftover tokens
+} //^^^^^^^^ error: leftover tokens
 "#,
         )
     }
diff --git a/crates/ide/src/diagnostics/mismatched_arg_count.rs b/crates/ide_diagnostics/src/handlers/mismatched_arg_count.rs
index 08e1cfa5f..a9b6d3870 100644
--- a/crates/ide/src/diagnostics/mismatched_arg_count.rs
+++ b/crates/ide_diagnostics/src/handlers/mismatched_arg_count.rs
@@ -1,9 +1,9 @@
-use crate::diagnostics::{Diagnostic, DiagnosticsContext};
+use crate::{Diagnostic, DiagnosticsContext};
 
 // Diagnostic: mismatched-arg-count
 //
 // This diagnostic is triggered if a function is invoked with an incorrect amount of arguments.
-pub(super) fn mismatched_arg_count(
+pub(crate) fn mismatched_arg_count(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::MismatchedArgCount,
 ) -> Diagnostic {
@@ -18,7 +18,7 @@ pub(super) fn mismatched_arg_count(
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::check_diagnostics;
+    use crate::tests::check_diagnostics;
 
     #[test]
     fn simple_free_fn_zero() {
@@ -26,7 +26,7 @@ mod tests {
             r#"
 fn zero() {}
 fn f() { zero(1); }
-       //^^^^^^^ expected 0 arguments, found 1
+       //^^^^^^^ error: expected 0 arguments, found 1
 "#,
         );
 
@@ -44,7 +44,7 @@ fn f() { zero(); }
             r#"
 fn one(arg: u8) {}
 fn f() { one(); }
-       //^^^^^ expected 1 argument, found 0
+       //^^^^^ error: expected 1 argument, found 0
 "#,
         );
 
@@ -65,7 +65,7 @@ impl S { fn method(&self) {} }
 
 fn f() {
     S::method();
-} //^^^^^^^^^^^ expected 1 argument, found 0
+} //^^^^^^^^^^^ error: expected 1 argument, found 0
 "#,
         );
 
@@ -91,7 +91,7 @@ impl S { fn method(&self, arg: u8) {} }
 
             fn f() {
                 S.method();
-            } //^^^^^^^^^^ expected 1 argument, found 0
+            } //^^^^^^^^^^ error: expected 1 argument, found 0
             "#,
         );
 
@@ -131,7 +131,7 @@ fn f() {
 struct Tup(u8, u16);
 fn f() {
     Tup(0);
-} //^^^^^^ expected 2 arguments, found 1
+} //^^^^^^ error: expected 2 arguments, found 1
 "#,
         )
     }
@@ -143,7 +143,7 @@ fn f() {
 enum En { Variant(u8, u16), }
 fn f() {
     En::Variant(0);
-} //^^^^^^^^^^^^^^ expected 2 arguments, found 1
+} //^^^^^^^^^^^^^^ error: expected 2 arguments, found 1
 "#,
         )
     }
@@ -162,9 +162,9 @@ impl Foo {
     fn new() {
         Foo::Bar(0);
         Foo::Bar(0, 1);
-      //^^^^^^^^^^^^^^ expected 1 argument, found 2
+      //^^^^^^^^^^^^^^ error: expected 1 argument, found 2
         Foo::Bar();
-      //^^^^^^^^^^ expected 1 argument, found 0
+      //^^^^^^^^^^ error: expected 1 argument, found 0
     }
 }
         "#,
@@ -185,7 +185,7 @@ fn f() {
     unsafe {
         fixed(0);
         fixed(0, 1);
-      //^^^^^^^^^^^ expected 1 argument, found 2
+      //^^^^^^^^^^^ error: expected 1 argument, found 2
         varargs(0);
         varargs(0, 1);
         varargs2();
@@ -204,10 +204,10 @@ fn f() {
 fn main() {
     let f = |()| ();
     f();
-  //^^^ expected 1 argument, found 0
+  //^^^ error: expected 1 argument, found 0
     f(());
     f((), ());
-  //^^^^^^^^^ expected 1 argument, found 2
+  //^^^^^^^^^ error: expected 1 argument, found 2
 }
 "#,
         )
diff --git a/crates/ide/src/diagnostics/missing_fields.rs b/crates/ide_diagnostics/src/handlers/missing_fields.rs
index d01f05041..bc56e0342 100644
--- a/crates/ide/src/diagnostics/missing_fields.rs
+++ b/crates/ide_diagnostics/src/handlers/missing_fields.rs
@@ -1,12 +1,11 @@
 use either::Either;
 use hir::{db::AstDatabase, InFile};
-use ide_assists::Assist;
-use ide_db::source_change::SourceChange;
+use ide_db::{assists::Assist, source_change::SourceChange};
 use stdx::format_to;
 use syntax::{algo, ast::make, AstNode, SyntaxNodePtr};
 use text_edit::TextEdit;
 
-use crate::diagnostics::{fix, Diagnostic, DiagnosticsContext};
+use crate::{fix, Diagnostic, DiagnosticsContext};
 
 // Diagnostic: missing-fields
 //
@@ -19,8 +18,8 @@ use crate::diagnostics::{fix, Diagnostic, DiagnosticsContext};
 //
 // let a = A { a: 10 };
 // ```
-pub(super) fn missing_fields(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Diagnostic {
-    let mut message = String::from("Missing structure fields:\n");
+pub(crate) fn missing_fields(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Diagnostic {
+    let mut message = String::from("missing structure fields:\n");
     for field in &d.missed_fields {
         format_to!(message, "- {}\n", field);
     }
@@ -77,7 +76,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Option<Vec<Ass
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::{check_diagnostics, check_fix};
+    use crate::tests::{check_diagnostics, check_fix};
 
     #[test]
     fn missing_record_pat_field_diagnostic() {
@@ -86,7 +85,7 @@ mod tests {
 struct S { foo: i32, bar: () }
 fn baz(s: S) {
     let S { foo: _ } = s;
-      //^ Missing structure fields:
+      //^ error: missing structure fields:
       //| - bar
 }
 "#,
@@ -324,4 +323,33 @@ fn f() {
 "#,
         );
     }
+
+    #[test]
+    fn import_extern_crate_clash_with_inner_item() {
+        // This is more of a resolver test, but doesn't really work with the hir_def testsuite.
+
+        check_diagnostics(
+            r#"
+//- /lib.rs crate:lib deps:jwt
+mod permissions;
+
+use permissions::jwt;
+
+fn f() {
+    fn inner() {}
+    jwt::Claims {}; // should resolve to the local one with 0 fields, and not get a diagnostic
+}
+
+//- /permissions.rs
+pub mod jwt  {
+    pub struct Claims {}
+}
+
+//- /jwt/lib.rs crate:jwt
+pub struct Claims {
+    field: u8,
+}
+        "#,
+        );
+    }
 }
diff --git a/crates/ide/src/diagnostics/missing_match_arms.rs b/crates/ide_diagnostics/src/handlers/missing_match_arms.rs
index b636489b3..947b0f2e2 100644
--- a/crates/ide/src/diagnostics/missing_match_arms.rs
+++ b/crates/ide_diagnostics/src/handlers/missing_match_arms.rs
@@ -1,11 +1,11 @@
 use hir::InFile;
 
-use crate::diagnostics::{Diagnostic, DiagnosticsContext};
+use crate::{Diagnostic, DiagnosticsContext};
 
 // Diagnostic: missing-match-arm
 //
 // This diagnostic is triggered if `match` block is missing one or more match arms.
-pub(super) fn missing_match_arms(
+pub(crate) fn missing_match_arms(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::MissingMatchArms,
 ) -> Diagnostic {
@@ -17,12 +17,12 @@ pub(super) fn missing_match_arms(
 }
 
 #[cfg(test)]
-pub(super) mod tests {
-    use crate::diagnostics::tests::check_diagnostics;
+mod tests {
+    use crate::tests::check_diagnostics;
 
     fn check_diagnostics_no_bails(ra_fixture: &str) {
         cov_mark::check_count!(validate_match_bailed_out, 0);
-        crate::diagnostics::tests::check_diagnostics(ra_fixture)
+        crate::tests::check_diagnostics(ra_fixture)
     }
 
     #[test]
@@ -31,9 +31,9 @@ pub(super) mod tests {
             r#"
 fn main() {
     match () { }
-        //^^ missing match arm
+        //^^ error: missing match arm
     match (()) { }
-        //^^^^ missing match arm
+        //^^^^ error: missing match arm
 
     match () { _ => (), }
     match () { () => (), }
@@ -49,7 +49,7 @@ fn main() {
             r#"
 fn main() {
     match ((), ()) { }
-        //^^^^^^^^ missing match arm
+        //^^^^^^^^ error: missing match arm
 
     match ((), ()) { ((), ()) => (), }
 }
@@ -63,21 +63,21 @@ fn main() {
             r#"
 fn test_main() {
     match false { }
-        //^^^^^ missing match arm
+        //^^^^^ error: missing match arm
     match false { true => (), }
-        //^^^^^ missing match arm
+        //^^^^^ error: missing match arm
     match (false, true) {}
-        //^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^ error: missing match arm
     match (false, true) { (true, true) => (), }
-        //^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^ error: missing match arm
     match (false, true) {
-        //^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^ error: missing match arm
         (false, true) => (),
         (false, false) => (),
         (true, false) => (),
     }
     match (false, true) { (true, _x) => (), }
-        //^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^ error: missing match arm
 
     match false { true => (), false => (), }
     match (false, true) {
@@ -116,11 +116,11 @@ fn test_main() {
             r#"
 fn main() {
     match (false, ((), false)) {}
-        //^^^^^^^^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^^^^^^^^ error: missing match arm
     match (false, ((), false)) { (true, ((), true)) => (), }
-        //^^^^^^^^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^^^^^^^^ error: missing match arm
     match (false, ((), false)) { (true, _) => (), }
-        //^^^^^^^^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^^^^^^^^ error: missing match arm
 
     match (false, ((), false)) {
         (true, ((), true)) => (),
@@ -146,12 +146,12 @@ enum Either { A, B, }
 
 fn main() {
     match Either::A { }
-        //^^^^^^^^^ missing match arm
+        //^^^^^^^^^ error: missing match arm
     match Either::B { Either::A => (), }
-        //^^^^^^^^^ missing match arm
+        //^^^^^^^^^ error: missing match arm
 
     match &Either::B {
-        //^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^ error: missing match arm
         Either::A => (),
     }
 
@@ -174,9 +174,9 @@ enum Either { A(bool), B }
 
 fn main() {
     match Either::B { }
-        //^^^^^^^^^ missing match arm
+        //^^^^^^^^^ error: missing match arm
     match Either::B {
-        //^^^^^^^^^ missing match arm
+        //^^^^^^^^^ error: missing match arm
         Either::A(true) => (), Either::B => ()
     }
 
@@ -207,7 +207,7 @@ enum Either { A(bool), B(bool, bool) }
 
 fn main() {
     match Either::A(false) {
-        //^^^^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^^^^ error: missing match arm
         Either::A(_) => (),
         Either::B(false, _) => (),
     }
@@ -352,7 +352,7 @@ fn main() {
         Either::A => (),
     }
     match loop { break Foo::A } {
-        //^^^^^^^^^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^^^^^^^^^ error: missing match arm
         Either::A => (),
     }
     match loop { break Foo::A } {
@@ -390,19 +390,19 @@ enum Either { A { foo: bool }, B }
 fn main() {
     let a = Either::A { foo: true };
     match a { }
-        //^ missing match arm
+        //^ error: missing match arm
     match a { Either::A { foo: true } => () }
-        //^ missing match arm
+        //^ error: missing match arm
     match a {
         Either::A { } => (),
-      //^^^^^^^^^ Missing structure fields:
+      //^^^^^^^^^ error: missing structure fields:
       //        | - foo
         Either::B => (),
     }
     match a {
-        //^ missing match arm
+        //^ error: missing match arm
         Either::A { } => (),
-    } //^^^^^^^^^ Missing structure fields:
+    } //^^^^^^^^^ error: missing structure fields:
       //        | - foo
 
     match a {
@@ -431,7 +431,7 @@ enum Either {
 fn main() {
     let a = Either::A { foo: true, bar: () };
     match a {
-        //^ missing match arm
+        //^ error: missing match arm
         Either::A { bar: (), foo: false } => (),
         Either::A { foo: true, bar: () } => (),
     }
@@ -458,12 +458,12 @@ enum Either {
 fn main() {
     let a = Either::B;
     match a {
-        //^ missing match arm
+        //^ error: missing match arm
         Either::A { foo: true, .. } => (),
         Either::B => (),
     }
     match a {
-        //^ missing match arm
+        //^ error: missing match arm
         Either::A { .. } => (),
     }
 
@@ -493,14 +493,14 @@ enum Either {
 
 fn main() {
     match Either::B {
-        //^^^^^^^^^ missing match arm
+        //^^^^^^^^^ error: missing match arm
         Either::A(true, .., true) => (),
         Either::A(true, .., false) => (),
         Either::A(false, .., false) => (),
         Either::B => (),
     }
     match Either::B {
-        //^^^^^^^^^ missing match arm
+        //^^^^^^^^^ error: missing match arm
         Either::A(true, .., true) => (),
         Either::A(true, .., false) => (),
         Either::A(.., true) => (),
@@ -537,7 +537,7 @@ fn enum_(never: Never) {
 }
 fn enum_ref(never: &Never) {
     match never {}
-        //^^^^^ missing match arm
+        //^^^^^ error: missing match arm
 }
 fn bang(never: !) {
     match never {}
@@ -561,7 +561,7 @@ fn main() {
         Some(never) => match never {},
     }
     match Option::<Never>::None {
-        //^^^^^^^^^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^^^^^^^^^ error: missing match arm
         Option::Some(_never) => {},
     }
 }
@@ -575,7 +575,7 @@ fn main() {
             r#"
 fn main() {
     match (false, true, false) {
-        //^^^^^^^^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^^^^^^^^ error: missing match arm
         (false, ..) => (),
     }
 }"#,
@@ -588,7 +588,7 @@ fn main() {
             r#"
 fn main() {
     match (false, true, false) {
-        //^^^^^^^^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^^^^^^^^ error: missing match arm
         (.., false) => (),
     }
 }"#,
@@ -601,7 +601,7 @@ fn main() {
             r#"
 fn main() {
     match (false, true, false) {
-        //^^^^^^^^^^^^^^^^^^^^ missing match arm
+        //^^^^^^^^^^^^^^^^^^^^ error: missing match arm
         (true, .., false) => (),
     }
 }"#,
@@ -614,11 +614,11 @@ fn main() {
             r#"struct Foo { a: bool }
 fn main(f: Foo) {
     match f {}
-        //^ missing match arm
+        //^ error: missing match arm
     match f { Foo { a: true } => () }
-        //^ missing match arm
+        //^ error: missing match arm
     match &f { Foo { a: true } => () }
-        //^^ missing match arm
+        //^^ error: missing match arm
     match f { Foo { a: _ } => () }
     match f {
         Foo { a: true } => (),
@@ -639,9 +639,9 @@ fn main(f: Foo) {
             r#"struct Foo(bool);
 fn main(f: Foo) {
     match f {}
-        //^ missing match arm
+        //^ error: missing match arm
     match f { Foo(true) => () }
-        //^ missing match arm
+        //^ error: missing match arm
     match f {
         Foo(true) => (),
         Foo(false) => (),
@@ -657,7 +657,7 @@ fn main(f: Foo) {
             r#"struct Foo;
 fn main(f: Foo) {
     match f {}
-        //^ missing match arm
+        //^ error: missing match arm
     match f { Foo => () }
 }
 "#,
@@ -670,9 +670,9 @@ fn main(f: Foo) {
             r#"struct Foo { foo: bool, bar: bool }
 fn main(f: Foo) {
     match f { Foo { foo: true, .. } => () }
-        //^ missing match arm
+        //^ error: missing match arm
     match f {
-        //^ missing match arm
+        //^ error: missing match arm
         Foo { foo: true, .. } => (),
         Foo { bar: false, .. } => ()
     }
@@ -693,7 +693,7 @@ fn main(f: Foo) {
 fn main() {
     enum Either { A(bool), B }
     match Either::B {
-        //^^^^^^^^^ missing match arm
+        //^^^^^^^^^ error: missing match arm
         Either::A(true | false) => (),
     }
 }
@@ -715,7 +715,7 @@ fn main(v: S) {
     match v { S{..}       => {} }
     match v { _           => {} }
     match v { }
-        //^ missing match arm
+        //^ error: missing match arm
 }
 "#,
         );
@@ -731,7 +731,7 @@ fn main() {
         false     => {}
     }
     match true { _x @ true => {} }
-        //^^^^ missing match arm
+        //^^^^ error: missing match arm
 }
 "#,
         );
@@ -786,12 +786,12 @@ use lib::E;
 fn main() {
     match E::A { _ => {} }
     match E::A {
-        //^^^^ missing match arm
+        //^^^^ error: missing match arm
         E::A => {}
         E::B => {}
     }
     match E::A {
-        //^^^^ missing match arm
+        //^^^^ error: missing match arm
         E::A | E::B => {}
     }
 }
@@ -810,7 +810,7 @@ fn main() {
         false         => {}
     }
     match true {
-        //^^^^ missing match arm
+        //^^^^ error: missing match arm
         true if false => {}
         false         => {}
     }
diff --git a/crates/ide/src/diagnostics/missing_ok_or_some_in_tail_expr.rs b/crates/ide_diagnostics/src/handlers/missing_ok_or_some_in_tail_expr.rs
index 06005d156..63de54570 100644
--- a/crates/ide/src/diagnostics/missing_ok_or_some_in_tail_expr.rs
+++ b/crates/ide_diagnostics/src/handlers/missing_ok_or_some_in_tail_expr.rs
@@ -1,10 +1,9 @@
 use hir::db::AstDatabase;
-use ide_assists::Assist;
-use ide_db::source_change::SourceChange;
+use ide_db::{assists::Assist, source_change::SourceChange};
 use syntax::AstNode;
 use text_edit::TextEdit;
 
-use crate::diagnostics::{fix, Diagnostic, DiagnosticsContext};
+use crate::{fix, Diagnostic, DiagnosticsContext};
 
 // Diagnostic: missing-ok-or-some-in-tail-expr
 //
@@ -18,7 +17,7 @@ use crate::diagnostics::{fix, Diagnostic, DiagnosticsContext};
 //     10
 // }
 // ```
-pub(super) fn missing_ok_or_some_in_tail_expr(
+pub(crate) fn missing_ok_or_some_in_tail_expr(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::MissingOkOrSomeInTailExpr,
 ) -> Diagnostic {
@@ -44,7 +43,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::MissingOkOrSomeInTailExpr) -> Op
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::{check_diagnostics, check_fix};
+    use crate::tests::{check_diagnostics, check_fix};
 
     #[test]
     fn test_wrap_return_type_option() {
diff --git a/crates/ide/src/diagnostics/missing_unsafe.rs b/crates/ide_diagnostics/src/handlers/missing_unsafe.rs
index 5c47e8d0a..7acd9228a 100644
--- a/crates/ide/src/diagnostics/missing_unsafe.rs
+++ b/crates/ide_diagnostics/src/handlers/missing_unsafe.rs
@@ -1,9 +1,9 @@
-use crate::diagnostics::{Diagnostic, DiagnosticsContext};
+use crate::{Diagnostic, DiagnosticsContext};
 
 // Diagnostic: missing-unsafe
 //
 // This diagnostic is triggered if an operation marked as `unsafe` is used outside of an `unsafe` function or block.
-pub(super) fn missing_unsafe(ctx: &DiagnosticsContext<'_>, d: &hir::MissingUnsafe) -> Diagnostic {
+pub(crate) fn missing_unsafe(ctx: &DiagnosticsContext<'_>, d: &hir::MissingUnsafe) -> Diagnostic {
     Diagnostic::new(
         "missing-unsafe",
         "this operation is unsafe and requires an unsafe function or block",
@@ -13,7 +13,7 @@ pub(super) fn missing_unsafe(ctx: &DiagnosticsContext<'_>, d: &hir::MissingUnsaf
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::check_diagnostics;
+    use crate::tests::check_diagnostics;
 
     #[test]
     fn missing_unsafe_diagnostic_with_raw_ptr() {
@@ -23,7 +23,7 @@ fn main() {
     let x = &5 as *const usize;
     unsafe { let y = *x; }
     let z = *x;
-}         //^^ this operation is unsafe and requires an unsafe function or block
+}         //^^ error: this operation is unsafe and requires an unsafe function or block
 "#,
         )
     }
@@ -48,9 +48,9 @@ unsafe fn unsafe_fn() {
 
 fn main() {
     unsafe_fn();
-  //^^^^^^^^^^^ this operation is unsafe and requires an unsafe function or block
+  //^^^^^^^^^^^ error: this operation is unsafe and requires an unsafe function or block
     HasUnsafe.unsafe_fn();
-  //^^^^^^^^^^^^^^^^^^^^^ this operation is unsafe and requires an unsafe function or block
+  //^^^^^^^^^^^^^^^^^^^^^ error: this operation is unsafe and requires an unsafe function or block
     unsafe {
         unsafe_fn();
         HasUnsafe.unsafe_fn();
@@ -72,7 +72,7 @@ static mut STATIC_MUT: Ty = Ty { a: 0 };
 
 fn main() {
     let x = STATIC_MUT.a;
-          //^^^^^^^^^^ this operation is unsafe and requires an unsafe function or block
+          //^^^^^^^^^^ error: this operation is unsafe and requires an unsafe function or block
     unsafe {
         let x = STATIC_MUT.a;
     }
@@ -93,7 +93,7 @@ extern "rust-intrinsic" {
 fn main() {
     let _ = bitreverse(12);
     let _ = floorf32(12.0);
-          //^^^^^^^^^^^^^^ this operation is unsafe and requires an unsafe function or block
+          //^^^^^^^^^^^^^^ error: this operation is unsafe and requires an unsafe function or block
 }
 "#,
         );
diff --git a/crates/ide/src/diagnostics/no_such_field.rs b/crates/ide_diagnostics/src/handlers/no_such_field.rs
index edc63c246..92e8867f4 100644
--- a/crates/ide/src/diagnostics/no_such_field.rs
+++ b/crates/ide_diagnostics/src/handlers/no_such_field.rs
@@ -6,15 +6,12 @@ use syntax::{
 };
 use text_edit::TextEdit;
 
-use crate::{
-    diagnostics::{fix, Diagnostic, DiagnosticsContext},
-    Assist,
-};
+use crate::{fix, Assist, Diagnostic, DiagnosticsContext};
 
 // Diagnostic: no-such-field
 //
 // This diagnostic is triggered if created structure does not have field provided in record.
-pub(super) fn no_such_field(ctx: &DiagnosticsContext<'_>, d: &hir::NoSuchField) -> Diagnostic {
+pub(crate) fn no_such_field(ctx: &DiagnosticsContext<'_>, d: &hir::NoSuchField) -> Diagnostic {
     Diagnostic::new(
         "no-such-field",
         "no such field",
@@ -112,7 +109,7 @@ fn missing_record_expr_field_fixes(
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::{check_diagnostics, check_fix};
+    use crate::tests::{check_diagnostics, check_fix};
 
     #[test]
     fn no_such_field_diagnostics() {
@@ -122,11 +119,11 @@ struct S { foo: i32, bar: () }
 impl S {
     fn new() -> S {
         S {
-      //^ Missing structure fields:
+      //^ 💡 error: missing structure fields:
       //|    - bar
             foo: 92,
             baz: 62,
-          //^^^^^^^ no such field
+          //^^^^^^^ 💡 error: no such field
         }
     }
 }
diff --git a/crates/ide/src/diagnostics/remove_this_semicolon.rs b/crates/ide_diagnostics/src/handlers/remove_this_semicolon.rs
index 814cb0f8c..4e639f214 100644
--- a/crates/ide/src/diagnostics/remove_this_semicolon.rs
+++ b/crates/ide_diagnostics/src/handlers/remove_this_semicolon.rs
@@ -3,15 +3,12 @@ use ide_db::source_change::SourceChange;
 use syntax::{ast, AstNode};
 use text_edit::TextEdit;
 
-use crate::{
-    diagnostics::{fix, Diagnostic, DiagnosticsContext},
-    Assist,
-};
+use crate::{fix, Assist, Diagnostic, DiagnosticsContext};
 
 // Diagnostic: remove-this-semicolon
 //
 // This diagnostic is triggered when there's an erroneous `;` at the end of the block.
-pub(super) fn remove_this_semicolon(
+pub(crate) fn remove_this_semicolon(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::RemoveThisSemicolon,
 ) -> Diagnostic {
@@ -45,14 +42,14 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::RemoveThisSemicolon) -> Option<V
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::{check_diagnostics, check_fix};
+    use crate::tests::{check_diagnostics, check_fix};
 
     #[test]
     fn missing_semicolon() {
         check_diagnostics(
             r#"
 fn test() -> i32 { 123; }
-                 //^^^ remove this semicolon
+                 //^^^ 💡 error: remove this semicolon
 "#,
         );
     }
diff --git a/crates/ide/src/diagnostics/replace_filter_map_next_with_find_map.rs b/crates/ide_diagnostics/src/handlers/replace_filter_map_next_with_find_map.rs
index f3b011495..cd87a10bb 100644
--- a/crates/ide/src/diagnostics/replace_filter_map_next_with_find_map.rs
+++ b/crates/ide_diagnostics/src/handlers/replace_filter_map_next_with_find_map.rs
@@ -6,15 +6,12 @@ use syntax::{
 };
 use text_edit::TextEdit;
 
-use crate::{
-    diagnostics::{fix, Diagnostic, DiagnosticsContext},
-    Assist, Severity,
-};
+use crate::{fix, Assist, Diagnostic, DiagnosticsContext, Severity};
 
 // Diagnostic: replace-filter-map-next-with-find-map
 //
 // This diagnostic is triggered when `.filter_map(..).next()` is used, rather than the more concise `.find_map(..)`.
-pub(super) fn replace_filter_map_next_with_find_map(
+pub(crate) fn replace_filter_map_next_with_find_map(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::ReplaceFilterMapNextWithFindMap,
 ) -> Diagnostic {
@@ -58,7 +55,7 @@ fn fixes(
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::check_fix;
+    use crate::tests::check_fix;
 
     // Register the required standard library types to make the tests work
     #[track_caller]
@@ -86,7 +83,7 @@ pub mod iter {
     }
 }
 "#;
-        crate::diagnostics::tests::check_diagnostics(&format!("{}{}{}", prefix, ra_fixture, suffix))
+        crate::tests::check_diagnostics(&format!("{}{}{}", prefix, ra_fixture, suffix))
     }
 
     #[test]
@@ -94,8 +91,8 @@ pub mod iter {
         check_diagnostics(
             r#"
     fn foo() {
-        let m = [1, 2, 3].iter().filter_map(|x| if *x == 2 { Some (4) } else { None }).next();
-    }         //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ replace filter_map(..).next() with find_map(..)
+        let m = [1, 2, 3].iter().filter_map(|x| Some(92)).next();
+    }         //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 💡 weak: replace filter_map(..).next() with find_map(..)
 "#,
         );
     }
@@ -107,7 +104,7 @@ pub mod iter {
 fn foo() {
     let m = [1, 2, 3]
         .iter()
-        .filter_map(|x| if *x == 2 { Some (4) } else { None })
+        .filter_map(|x| Some(92))
         .len();
 }
 "#,
@@ -121,7 +118,7 @@ fn foo() {
 fn foo() {
     let m = [1, 2, 3]
         .iter()
-        .filter_map(|x| if *x == 2 { Some (4) } else { None })
+        .filter_map(|x| Some(92))
         .map(|x| x + 2)
         .len();
 }
@@ -136,7 +133,7 @@ fn foo() {
 fn foo() {
     let m = [1, 2, 3]
         .iter()
-        .filter_map(|x| if *x == 2 { Some (4) } else { None });
+        .filter_map(|x| Some(92));
     let n = m.next();
 }
 "#,
@@ -151,7 +148,7 @@ fn foo() {
 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();
+    let m = [1, 2, 3].iter().$0filter_map(|x| Some(92)).next();
 }
 //- /core/lib.rs crate:core
 pub mod option {
@@ -174,7 +171,7 @@ pub mod iter {
 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 });
+    let m = [1, 2, 3].iter().find_map(|x| Some(92));
 }
 "#,
         )
diff --git a/crates/ide/src/diagnostics/unimplemented_builtin_macro.rs b/crates/ide_diagnostics/src/handlers/unimplemented_builtin_macro.rs
index 09faa3bbc..e879de75c 100644
--- a/crates/ide/src/diagnostics/unimplemented_builtin_macro.rs
+++ b/crates/ide_diagnostics/src/handlers/unimplemented_builtin_macro.rs
@@ -1,12 +1,9 @@
-use crate::{
-    diagnostics::{Diagnostic, DiagnosticsContext},
-    Severity,
-};
+use crate::{Diagnostic, DiagnosticsContext, Severity};
 
 // Diagnostic: unimplemented-builtin-macro
 //
 // This diagnostic is shown for builtin macros which are not yet implemented by rust-analyzer
-pub(super) fn unimplemented_builtin_macro(
+pub(crate) fn unimplemented_builtin_macro(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::UnimplementedBuiltinMacro,
 ) -> Diagnostic {
diff --git a/crates/ide/src/diagnostics/unlinked_file.rs b/crates/ide_diagnostics/src/handlers/unlinked_file.rs
index a5b2e3399..8e601fa48 100644
--- a/crates/ide/src/diagnostics/unlinked_file.rs
+++ b/crates/ide_diagnostics/src/handlers/unlinked_file.rs
@@ -12,37 +12,31 @@ use syntax::{
 };
 use text_edit::TextEdit;
 
-use crate::{
-    diagnostics::{fix, DiagnosticsContext},
-    Assist, Diagnostic,
-};
-
-#[derive(Debug)]
-pub(crate) struct UnlinkedFile {
-    pub(crate) file: FileId,
-}
+use crate::{fix, Assist, Diagnostic, DiagnosticsContext};
 
 // 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.
-pub(super) fn unlinked_file(ctx: &DiagnosticsContext, d: &UnlinkedFile) -> Diagnostic {
+pub(crate) fn unlinked_file(ctx: &DiagnosticsContext, acc: &mut Vec<Diagnostic>, file_id: FileId) {
     // 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 = ctx.sema.db.parse(d.file).syntax_node().text_range();
+    let range = ctx.sema.db.parse(file_id).syntax_node().text_range();
     // FIXME: This is wrong if one of the first three characters is not ascii: `//Ы`.
     let range = range.intersect(TextRange::up_to(TextSize::of("..."))).unwrap_or(range);
 
-    Diagnostic::new("unlinked-file", "file not included in module tree", range)
-        .with_fixes(fixes(ctx, d))
+    acc.push(
+        Diagnostic::new("unlinked-file", "file not included in module tree", range)
+            .with_fixes(fixes(ctx, file_id)),
+    );
 }
 
-fn fixes(ctx: &DiagnosticsContext, d: &UnlinkedFile) -> Option<Vec<Assist>> {
+fn fixes(ctx: &DiagnosticsContext, file_id: FileId) -> 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 = ctx.sema.db.source_root(ctx.sema.db.file_source_root(d.file));
-    let our_path = source_root.path_for_file(&d.file)?;
+    let source_root = ctx.sema.db.source_root(ctx.sema.db.file_source_root(file_id));
+    let our_path = source_root.path_for_file(&file_id)?;
     let module_name = our_path.name_and_extension()?.0;
 
     // Candidates to look for:
@@ -71,7 +65,7 @@ fn fixes(ctx: &DiagnosticsContext, d: &UnlinkedFile) -> Option<Vec<Assist>> {
                     }
 
                     if module.origin.file_id() == Some(*parent_id) {
-                        return make_fixes(ctx.sema.db, *parent_id, module_name, d.file);
+                        return make_fixes(ctx.sema.db, *parent_id, module_name, file_id);
                     }
                 }
             }
@@ -164,7 +158,7 @@ fn make_fixes(
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::{check_diagnostics, check_fix, check_fixes, check_no_fix};
+    use crate::tests::{check_diagnostics, check_fix, check_fixes, check_no_fix};
 
     #[test]
     fn unlinked_file_prepend_first_item() {
diff --git a/crates/ide/src/diagnostics/unresolved_extern_crate.rs b/crates/ide_diagnostics/src/handlers/unresolved_extern_crate.rs
index 2ea79c2ee..74e4a69c6 100644
--- a/crates/ide/src/diagnostics/unresolved_extern_crate.rs
+++ b/crates/ide_diagnostics/src/handlers/unresolved_extern_crate.rs
@@ -1,9 +1,9 @@
-use crate::diagnostics::{Diagnostic, DiagnosticsContext};
+use crate::{Diagnostic, DiagnosticsContext};
 
 // Diagnostic: unresolved-extern-crate
 //
 // This diagnostic is triggered if rust-analyzer is unable to discover referred extern crate.
-pub(super) fn unresolved_extern_crate(
+pub(crate) fn unresolved_extern_crate(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::UnresolvedExternCrate,
 ) -> Diagnostic {
@@ -16,7 +16,7 @@ pub(super) fn unresolved_extern_crate(
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::check_diagnostics;
+    use crate::tests::check_diagnostics;
 
     #[test]
     fn unresolved_extern_crate() {
@@ -25,7 +25,7 @@ mod tests {
 //- /main.rs crate:main deps:core
 extern crate core;
   extern crate doesnotexist;
-//^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+//^^^^^^^^^^^^^^^^^^^^^^^^^^ error: unresolved extern crate
 //- /lib.rs crate:core
 "#,
         );
@@ -38,7 +38,7 @@ extern crate core;
             r#"
 //- /lib.rs
   extern crate doesnotexist;
-//^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+//^^^^^^^^^^^^^^^^^^^^^^^^^^ error: unresolved extern crate
 // Should not error.
 extern crate self as foo;
 struct Foo;
diff --git a/crates/ide/src/diagnostics/unresolved_import.rs b/crates/ide_diagnostics/src/handlers/unresolved_import.rs
index 1cbf96ba1..e52a88459 100644
--- a/crates/ide/src/diagnostics/unresolved_import.rs
+++ b/crates/ide_diagnostics/src/handlers/unresolved_import.rs
@@ -1,10 +1,10 @@
-use crate::diagnostics::{Diagnostic, DiagnosticsContext};
+use crate::{Diagnostic, DiagnosticsContext};
 
 // Diagnostic: unresolved-import
 //
 // This diagnostic is triggered if rust-analyzer is unable to resolve a path in
 // a `use` declaration.
-pub(super) fn unresolved_import(
+pub(crate) fn unresolved_import(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::UnresolvedImport,
 ) -> Diagnostic {
@@ -22,7 +22,7 @@ pub(super) fn unresolved_import(
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::check_diagnostics;
+    use crate::tests::check_diagnostics;
 
     #[test]
     fn unresolved_import() {
@@ -30,7 +30,7 @@ mod tests {
             r#"
 use does_exist;
 use does_not_exist;
-  //^^^^^^^^^^^^^^ unresolved import
+  //^^^^^^^^^^^^^^ error: unresolved import
 
 mod does_exist {}
 "#,
@@ -43,18 +43,18 @@ mod does_exist {}
         check_diagnostics(
             r#"
 use does_exist::{Exists, DoesntExist};
-                       //^^^^^^^^^^^ unresolved import
+                       //^^^^^^^^^^^ error: unresolved import
 
 use {does_not_exist::*, does_exist};
-   //^^^^^^^^^^^^^^^^^ unresolved import
+   //^^^^^^^^^^^^^^^^^ error: unresolved import
 
 use does_not_exist::{
     a,
-  //^ unresolved import
+  //^ error: unresolved import
     b,
-  //^ unresolved import
+  //^ error: unresolved import
     c,
-  //^ unresolved import
+  //^ error: unresolved import
 };
 
 mod does_exist {
@@ -71,18 +71,18 @@ mod does_exist {
 //- /main.rs crate:main
 mod a {
     extern crate doesnotexist;
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^ error: unresolved extern crate
 
     // Should not error, since we already errored for the missing crate.
     use doesnotexist::{self, bla, *};
 
     use crate::doesnotexist;
-      //^^^^^^^^^^^^^^^^^^^ unresolved import
+      //^^^^^^^^^^^^^^^^^^^ error: unresolved import
 }
 
 mod m {
     use super::doesnotexist;
-      //^^^^^^^^^^^^^^^^^^^ unresolved import
+      //^^^^^^^^^^^^^^^^^^^ error: unresolved import
 }
 "#,
         );
diff --git a/crates/ide/src/diagnostics/unresolved_macro_call.rs b/crates/ide_diagnostics/src/handlers/unresolved_macro_call.rs
index 15b6a2730..f0f7725db 100644
--- a/crates/ide/src/diagnostics/unresolved_macro_call.rs
+++ b/crates/ide_diagnostics/src/handlers/unresolved_macro_call.rs
@@ -1,13 +1,13 @@
 use hir::{db::AstDatabase, InFile};
 use syntax::{AstNode, SyntaxNodePtr};
 
-use crate::diagnostics::{Diagnostic, DiagnosticsContext};
+use crate::{Diagnostic, DiagnosticsContext};
 
 // Diagnostic: unresolved-macro-call
 //
 // This diagnostic is triggered if rust-analyzer is unable to resolve the path
 // to a macro in a macro invocation.
-pub(super) fn unresolved_macro_call(
+pub(crate) fn unresolved_macro_call(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::UnresolvedMacroCall,
 ) -> Diagnostic {
@@ -32,7 +32,7 @@ pub(super) fn unresolved_macro_call(
 
 #[cfg(test)]
 mod tests {
-    use crate::diagnostics::tests::check_diagnostics;
+    use crate::tests::check_diagnostics;
 
     #[test]
     fn unresolved_macro_diag() {
@@ -40,7 +40,7 @@ mod tests {
             r#"
 fn f() {
     m!();
-} //^ unresolved macro `m!`
+} //^ error: unresolved macro `m!`
 
 "#,
         );
@@ -51,7 +51,7 @@ fn f() {
         check_diagnostics(
             r#"
 foo::bar!(92);
-   //^^^ unresolved macro `foo::bar!`
+   //^^^ error: unresolved macro `foo::bar!`
 "#,
         );
     }
@@ -63,7 +63,7 @@ foo::bar!(92);
 macro_rules! m { () => {} }
 
 m!(); m2!();
-    //^^ unresolved macro `self::m2!`
+    //^^ error: unresolved macro `self::m2!`
 "#,
         );
     }
@@ -77,7 +77,7 @@ mod mac {
 macro_rules! m { () => {} } }
 
 self::m!(); self::m2!();
-                //^^ unresolved macro `self::m2!`
+                //^^ error: unresolved macro `self::m2!`
 "#,
         );
     }
diff --git a/crates/ide/src/diagnostics/unresolved_module.rs b/crates/ide_diagnostics/src/handlers/unresolved_module.rs
index 977b46414..61fc43604 100644
--- a/crates/ide/src/diagnostics/unresolved_module.rs
+++ b/crates/ide_diagnostics/src/handlers/unresolved_module.rs
@@ -1,14 +1,13 @@
 use hir::db::AstDatabase;
-use ide_assists::Assist;
-use ide_db::{base_db::AnchoredPathBuf, source_change::FileSystemEdit};
+use ide_db::{assists::Assist, base_db::AnchoredPathBuf, source_change::FileSystemEdit};
 use syntax::AstNode;
 
-use crate::diagnostics::{fix, Diagnostic, DiagnosticsContext};
+use crate::{fix, Diagnostic, DiagnosticsContext};
 
 // Diagnostic: unresolved-module
 //
 // This diagnostic is triggered if rust-analyzer is unable to discover referred module.
-pub(super) fn unresolved_module(
+pub(crate) fn unresolved_module(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::UnresolvedModule,
 ) -> Diagnostic {
@@ -42,7 +41,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::UnresolvedModule) -> Option<Vec<
 mod tests {
     use expect_test::expect;
 
-    use crate::diagnostics::tests::{check_diagnostics, check_expect};
+    use crate::tests::{check_diagnostics, check_expect};
 
     #[test]
     fn unresolved_module() {
@@ -51,7 +50,7 @@ mod tests {
 //- /lib.rs
 mod foo;
   mod bar;
-//^^^^^^^^ unresolved module
+//^^^^^^^^ 💡 error: unresolved module
 mod baz {}
 //- /foo.rs
 "#,
diff --git a/crates/ide/src/diagnostics/unresolved_proc_macro.rs b/crates/ide_diagnostics/src/handlers/unresolved_proc_macro.rs
index 3dc6ab451..fde1d1323 100644
--- a/crates/ide/src/diagnostics/unresolved_proc_macro.rs
+++ b/crates/ide_diagnostics/src/handlers/unresolved_proc_macro.rs
@@ -1,7 +1,4 @@
-use crate::{
-    diagnostics::{Diagnostic, DiagnosticsContext},
-    Severity,
-};
+use crate::{Diagnostic, DiagnosticsContext, Severity};
 
 // Diagnostic: unresolved-proc-macro
 //
@@ -12,7 +9,7 @@ use crate::{
 // If you are seeing a lot of "proc macro not expanded" warnings, you can add this option to the
 // `rust-analyzer.diagnostics.disabled` list to prevent them from showing. Alternatively you can
 // enable support for procedural macros (see `rust-analyzer.procMacro.enable`).
-pub(super) fn unresolved_proc_macro(
+pub(crate) fn unresolved_proc_macro(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::UnresolvedProcMacro,
 ) -> Diagnostic {
diff --git a/crates/ide_diagnostics/src/handlers/useless_braces.rs b/crates/ide_diagnostics/src/handlers/useless_braces.rs
new file mode 100644
index 000000000..8b9330e04
--- /dev/null
+++ b/crates/ide_diagnostics/src/handlers/useless_braces.rs
@@ -0,0 +1,148 @@
+use ide_db::{base_db::FileId, source_change::SourceChange};
+use itertools::Itertools;
+use syntax::{ast, AstNode, SyntaxNode, TextRange};
+use text_edit::TextEdit;
+
+use crate::{fix, Diagnostic, Severity};
+
+// Diagnostic: unnecessary-braces
+//
+// Diagnostic for unnecessary braces in `use` items.
+pub(crate) fn useless_braces(
+    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 = remove_braces(&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::new(
+                "unnecessary-braces",
+                "Unnecessary braces in use statement".to_string(),
+                use_range,
+            )
+            .severity(Severity::WeakWarning)
+            .with_fixes(Some(vec![fix(
+                "remove_braces",
+                "Remove unnecessary braces",
+                SourceChange::from_text_edit(file_id, edit),
+                use_range,
+            )])),
+        );
+    }
+
+    Some(())
+}
+
+fn remove_braces(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
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_diagnostics, check_fix};
+
+    #[test]
+    fn test_check_unnecessary_braces_in_use_statement() {
+        check_diagnostics(
+            r#"
+use a;
+use a::{c, d::e};
+
+mod a {
+    mod c {}
+    mod d {
+        mod e {}
+    }
+}
+"#,
+        );
+        check_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};
+"#,
+        );
+    }
+}
diff --git a/crates/ide_diagnostics/src/lib.rs b/crates/ide_diagnostics/src/lib.rs
new file mode 100644
index 000000000..6ad1b4373
--- /dev/null
+++ b/crates/ide_diagnostics/src/lib.rs
@@ -0,0 +1,374 @@
+//! Diagnostics rendering and fixits.
+//!
+//! Most of the diagnostics originate from the dark depth of the compiler, and
+//! are originally expressed in term of IR. When we emit the diagnostic, we are
+//! usually not in the position to decide how to best "render" it in terms of
+//! user-authored source code. We are especially not in the position to offer
+//! fixits, as the compiler completely lacks the infrastructure to edit the
+//! source code.
+//!
+//! Instead, we "bubble up" raw, structured diagnostics until the `hir` crate,
+//! where we "cook" them so that each diagnostic is formulated in terms of `hir`
+//! types. Well, at least that's the aspiration, the "cooking" is somewhat
+//! ad-hoc at the moment. Anyways, we get a bunch of ide-friendly diagnostic
+//! structs from hir, and we want to render them to unified serializable
+//! representation (span, level, message) here. If we can, we also provide
+//! fixits. By the way, that's why we want to keep diagnostics structured
+//! internally -- so that we have all the info to make fixes.
+//!
+//! We have one "handler" module per diagnostic code. Such a module contains
+//! rendering, optional fixes and tests. It's OK if some low-level compiler
+//! functionality ends up being tested via a diagnostic.
+//!
+//! There are also a couple of ad-hoc diagnostics implemented directly here, we
+//! don't yet have a great pattern for how to do them properly.
+
+mod handlers {
+    pub(crate) mod break_outside_of_loop;
+    pub(crate) mod inactive_code;
+    pub(crate) mod incorrect_case;
+    pub(crate) mod macro_error;
+    pub(crate) mod mismatched_arg_count;
+    pub(crate) mod missing_fields;
+    pub(crate) mod missing_match_arms;
+    pub(crate) mod missing_ok_or_some_in_tail_expr;
+    pub(crate) mod missing_unsafe;
+    pub(crate) mod no_such_field;
+    pub(crate) mod remove_this_semicolon;
+    pub(crate) mod replace_filter_map_next_with_find_map;
+    pub(crate) mod unimplemented_builtin_macro;
+    pub(crate) mod unresolved_extern_crate;
+    pub(crate) mod unresolved_import;
+    pub(crate) mod unresolved_macro_call;
+    pub(crate) mod unresolved_module;
+    pub(crate) mod unresolved_proc_macro;
+
+    // The handlers bellow are unusual, the implement the diagnostics as well.
+    pub(crate) mod field_shorthand;
+    pub(crate) mod useless_braces;
+    pub(crate) mod unlinked_file;
+}
+
+use hir::{diagnostics::AnyDiagnostic, Semantics};
+use ide_db::{
+    assists::{Assist, AssistId, AssistKind, AssistResolveStrategy},
+    base_db::{FileId, SourceDatabase},
+    label::Label,
+    source_change::SourceChange,
+    RootDatabase,
+};
+use rustc_hash::FxHashSet;
+use syntax::{ast::AstNode, TextRange};
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct DiagnosticCode(pub &'static str);
+
+impl DiagnosticCode {
+    pub fn as_str(&self) -> &str {
+        self.0
+    }
+}
+
+#[derive(Debug)]
+pub struct Diagnostic {
+    pub code: DiagnosticCode,
+    pub message: String,
+    pub range: TextRange,
+    pub severity: Severity,
+    pub unused: bool,
+    pub experimental: bool,
+    pub fixes: Option<Vec<Assist>>,
+}
+
+impl Diagnostic {
+    fn new(code: &'static str, message: impl Into<String>, range: TextRange) -> Diagnostic {
+        let message = message.into();
+        Diagnostic {
+            code: DiagnosticCode(code),
+            message,
+            range,
+            severity: Severity::Error,
+            unused: false,
+            experimental: false,
+            fixes: None,
+        }
+    }
+
+    fn experimental(mut self) -> Diagnostic {
+        self.experimental = true;
+        self
+    }
+
+    fn severity(mut self, severity: Severity) -> Diagnostic {
+        self.severity = severity;
+        self
+    }
+
+    fn with_fixes(mut self, fixes: Option<Vec<Assist>>) -> Diagnostic {
+        self.fixes = fixes;
+        self
+    }
+
+    fn with_unused(mut self, unused: bool) -> Diagnostic {
+        self.unused = unused;
+        self
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum Severity {
+    Error,
+    // We don't actually emit this one yet, but we should at some point.
+    // Warning,
+    WeakWarning,
+}
+
+#[derive(Default, Debug, Clone)]
+pub struct DiagnosticsConfig {
+    pub disable_experimental: bool,
+    pub disabled: FxHashSet<String>,
+}
+
+struct DiagnosticsContext<'a> {
+    config: &'a DiagnosticsConfig,
+    sema: Semantics<'a, RootDatabase>,
+    resolve: &'a AssistResolveStrategy,
+}
+
+pub 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::new("syntax-error", format!("Syntax Error: {}", err), err.range())
+        }),
+    );
+
+    for node in parse.tree().syntax().descendants() {
+        handlers::useless_braces::useless_braces(&mut res, file_id, &node);
+        handlers::field_shorthand::field_shorthand(&mut res, file_id, &node);
+    }
+
+    let module = sema.to_module_def(file_id);
+
+    let ctx = DiagnosticsContext { config, sema, resolve };
+    if module.is_none() {
+        handlers::unlinked_file::unlinked_file(&ctx, &mut res, file_id);
+    }
+
+    let mut diags = Vec::new();
+    if let Some(m) = module {
+        m.diagnostics(db, &mut diags)
+    }
+
+    for diag in diags {
+        #[rustfmt::skip]
+        let d = match diag {
+            AnyDiagnostic::BreakOutsideOfLoop(d) => handlers::break_outside_of_loop::break_outside_of_loop(&ctx, &d),
+            AnyDiagnostic::IncorrectCase(d) => handlers::incorrect_case::incorrect_case(&ctx, &d),
+            AnyDiagnostic::MacroError(d) => handlers::macro_error::macro_error(&ctx, &d),
+            AnyDiagnostic::MismatchedArgCount(d) => handlers::mismatched_arg_count::mismatched_arg_count(&ctx, &d),
+            AnyDiagnostic::MissingFields(d) => handlers::missing_fields::missing_fields(&ctx, &d),
+            AnyDiagnostic::MissingMatchArms(d) => handlers::missing_match_arms::missing_match_arms(&ctx, &d),
+            AnyDiagnostic::MissingOkOrSomeInTailExpr(d) => handlers::missing_ok_or_some_in_tail_expr::missing_ok_or_some_in_tail_expr(&ctx, &d),
+            AnyDiagnostic::MissingUnsafe(d) => handlers::missing_unsafe::missing_unsafe(&ctx, &d),
+            AnyDiagnostic::NoSuchField(d) => handlers::no_such_field::no_such_field(&ctx, &d),
+            AnyDiagnostic::RemoveThisSemicolon(d) => handlers::remove_this_semicolon::remove_this_semicolon(&ctx, &d),
+            AnyDiagnostic::ReplaceFilterMapNextWithFindMap(d) => handlers::replace_filter_map_next_with_find_map::replace_filter_map_next_with_find_map(&ctx, &d),
+            AnyDiagnostic::UnimplementedBuiltinMacro(d) => handlers::unimplemented_builtin_macro::unimplemented_builtin_macro(&ctx, &d),
+            AnyDiagnostic::UnresolvedExternCrate(d) => handlers::unresolved_extern_crate::unresolved_extern_crate(&ctx, &d),
+            AnyDiagnostic::UnresolvedImport(d) => handlers::unresolved_import::unresolved_import(&ctx, &d),
+            AnyDiagnostic::UnresolvedMacroCall(d) => handlers::unresolved_macro_call::unresolved_macro_call(&ctx, &d),
+            AnyDiagnostic::UnresolvedModule(d) => handlers::unresolved_module::unresolved_module(&ctx, &d),
+            AnyDiagnostic::UnresolvedProcMacro(d) => handlers::unresolved_proc_macro::unresolved_proc_macro(&ctx, &d),
+
+            AnyDiagnostic::InactiveCode(d) => match handlers::inactive_code::inactive_code(&ctx, &d) {
+                Some(it) => it,
+                None => continue,
+            }
+        };
+        res.push(d)
+    }
+
+    res.retain(|d| {
+        !ctx.config.disabled.contains(d.code.as_str())
+            && !(ctx.config.disable_experimental && d.experimental)
+    });
+
+    res
+}
+
+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_db::{
+        assists::AssistResolveStrategy,
+        base_db::{fixture::WithFixture, SourceDatabaseExt},
+        RootDatabase,
+    };
+    use stdx::trim_indent;
+    use test_utils::{assert_eq_text, extract_annotations};
+
+    use crate::{DiagnosticsConfig, Severity};
+
+    /// 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 (db, file_position) = RootDatabase::with_position(ra_fixture_before);
+        let diagnostic = super::diagnostics(
+            &db,
+            &DiagnosticsConfig::default(),
+            &AssistResolveStrategy::All,
+            file_position.file_id,
+        )
+        .pop()
+        .expect("no diagnostics");
+        let fix = &diagnostic.fixes.expect("diagnostic misses fixes")[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 = db.file_text(file_id).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`.
+    pub(crate) fn check_no_fix(ra_fixture: &str) {
+        let (db, file_position) = RootDatabase::with_position(ra_fixture);
+        let diagnostic = super::diagnostics(
+            &db,
+            &DiagnosticsConfig::default(),
+            &AssistResolveStrategy::All,
+            file_position.file_id,
+        )
+        .pop()
+        .unwrap();
+        assert!(diagnostic.fixes.is_none(), "got a fix when none was expected: {:?}", diagnostic);
+    }
+
+    pub(crate) fn check_expect(ra_fixture: &str, expect: Expect) {
+        let (db, file_id) = RootDatabase::with_single_file(ra_fixture);
+        let diagnostics = super::diagnostics(
+            &db,
+            &DiagnosticsConfig::default(),
+            &AssistResolveStrategy::All,
+            file_id,
+        );
+        expect.assert_debug_eq(&diagnostics)
+    }
+
+    #[track_caller]
+    pub(crate) fn check_diagnostics(ra_fixture: &str) {
+        let mut config = DiagnosticsConfig::default();
+        config.disabled.insert("inactive-code".to_string());
+        check_diagnostics_with_config(config, ra_fixture)
+    }
+
+    #[track_caller]
+    pub(crate) fn check_diagnostics_with_config(config: DiagnosticsConfig, ra_fixture: &str) {
+        let (db, files) = RootDatabase::with_many_files(ra_fixture);
+        for file_id in files {
+            let diagnostics =
+                super::diagnostics(&db, &config, &AssistResolveStrategy::All, file_id);
+
+            let expected = extract_annotations(&*db.file_text(file_id));
+            let mut actual = diagnostics
+                .into_iter()
+                .map(|d| {
+                    let mut annotation = String::new();
+                    if let Some(fixes) = &d.fixes {
+                        assert!(!fixes.is_empty());
+                        annotation.push_str("💡 ")
+                    }
+                    annotation.push_str(match d.severity {
+                        Severity::Error => "error",
+                        Severity::WeakWarning => "weak",
+                    });
+                    annotation.push_str(": ");
+                    annotation.push_str(&d.message);
+                    (d.range, annotation)
+                })
+                .collect::<Vec<_>>();
+            actual.sort_by_key(|(range, _)| range.start());
+            assert_eq!(expected, actual);
+        }
+    }
+
+    #[test]
+    fn test_disabled_diagnostics() {
+        let mut config = DiagnosticsConfig::default();
+        config.disabled.insert("unresolved-module".into());
+
+        let (db, file_id) = RootDatabase::with_single_file(r#"mod foo;"#);
+
+        let diagnostics = super::diagnostics(&db, &config, &AssistResolveStrategy::All, file_id);
+        assert!(diagnostics.is_empty());
+
+        let diagnostics = super::diagnostics(
+            &db,
+            &DiagnosticsConfig::default(),
+            &AssistResolveStrategy::All,
+            file_id,
+        );
+        assert!(!diagnostics.is_empty());
+    }
+}
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 3b20d741a..5588c15da 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -1062,8 +1062,8 @@ mod tests {
         let package_json_path = project_root().join("editors/code/package.json");
         let mut package_json = fs::read_to_string(&package_json_path).unwrap();
 
-        let start_marker = "                \"$generated-start\": false,\n";
-        let end_marker = "                \"$generated-end\": false\n";
+        let start_marker = "                \"$generated-start\": {},\n";
+        let end_marker = "                \"$generated-end\": {}\n";
 
         let start = package_json.find(start_marker).unwrap() + start_marker.len();
         let end = package_json.find(end_marker).unwrap();
diff --git a/crates/rust-analyzer/tests/slow-tests/support.rs b/crates/rust-analyzer/tests/slow-tests/support.rs
index e22c295f9..260a504e7 100644
--- a/crates/rust-analyzer/tests/slow-tests/support.rs
+++ b/crates/rust-analyzer/tests/slow-tests/support.rs
@@ -75,7 +75,9 @@ impl<'a> Project<'a> {
             profile::init_from(crate::PROFILE);
         });
 
-        for entry in Fixture::parse(self.fixture) {
+        let (mini_core, fixtures) = Fixture::parse(self.fixture);
+        assert!(mini_core.is_none());
+        for entry in fixtures {
             let path = tmp_dir.path().join(&entry.path['/'.len_utf8()..]);
             fs::create_dir_all(path.parent().unwrap()).unwrap();
             fs::write(path.as_path(), entry.text.as_bytes()).unwrap();
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index 3d27d2c1a..2bd9ad867 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -325,6 +325,15 @@ impl ast::Impl {
         let second = types.next();
         (first, second)
     }
+
+    pub fn for_trait_name_ref(name_ref: &ast::NameRef) -> Option<ast::Impl> {
+        let this = name_ref.syntax().ancestors().find_map(ast::Impl::cast)?;
+        if this.trait_()?.syntax().text_range().start() == name_ref.syntax().text_range().start() {
+            Some(this)
+        } else {
+            None
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/crates/syntax/test_data/parser/ok/0011_outer_attribute.rast b/crates/syntax/test_data/parser/ok/0011_outer_attribute.rast
index ff5877a7b..31f76589d 100644
--- a/crates/syntax/test_data/parser/ok/0011_outer_attribute.rast
+++ b/crates/syntax/test_data/parser/ok/0011_outer_attribute.rast
@@ -21,7 +21,7 @@ [email protected]
         [email protected]
           [email protected]
             [email protected]
-              [email protected] "ignore"
+              [email protected] "Ignore"
       [email protected] "]"
     [email protected] "\n"
     [email protected] "fn"
diff --git a/crates/syntax/test_data/parser/ok/0011_outer_attribute.rs b/crates/syntax/test_data/parser/ok/0011_outer_attribute.rs
index 3d2e01d5c..6f04cb171 100644
--- a/crates/syntax/test_data/parser/ok/0011_outer_attribute.rs
+++ b/crates/syntax/test_data/parser/ok/0011_outer_attribute.rs
@@ -1,5 +1,5 @@
 #[cfg(test)]
-#[ignore]
+#[Ignore]
 fn foo() {}
 
 #[path = "a.rs"]
diff --git a/crates/test_utils/src/fixture.rs b/crates/test_utils/src/fixture.rs
index d0bddf7d8..6ba112de8 100644
--- a/crates/test_utils/src/fixture.rs
+++ b/crates/test_utils/src/fixture.rs
@@ -77,6 +77,11 @@ pub struct Fixture {
     pub introduce_new_source_root: bool,
 }
 
+pub struct MiniCore {
+    activated_flags: Vec<String>,
+    valid_flags: Vec<String>,
+}
+
 impl Fixture {
     /// Parses text which looks like this:
     ///
@@ -86,12 +91,28 @@ impl Fixture {
     ///  line 2
     ///  //- other meta
     ///  ```
-    pub fn parse(ra_fixture: &str) -> Vec<Fixture> {
+    ///
+    /// Fixture can also start with a minicore declaration:
+    ///
+    /// ```
+    /// //- minicore: sized
+    /// ```
+    ///
+    /// That will include a subset of `libcore` into the fixture, see
+    /// `minicore.rs` for what's available.
+    pub fn parse(ra_fixture: &str) -> (Option<MiniCore>, Vec<Fixture>) {
         let fixture = trim_indent(ra_fixture);
-
+        let mut fixture = fixture.as_str();
+        let mut mini_core = None;
         let mut res: Vec<Fixture> = Vec::new();
 
-        let default = if ra_fixture.contains("//-") { None } else { Some("//- /main.rs") };
+        if fixture.starts_with("//- minicore:") {
+            let first_line = fixture.split_inclusive('\n').next().unwrap();
+            mini_core = Some(MiniCore::parse(first_line));
+            fixture = &fixture[first_line.len()..];
+        }
+
+        let default = if fixture.contains("//-") { None } else { Some("//- /main.rs") };
 
         for (ix, line) in default.into_iter().chain(fixture.split_inclusive('\n')).enumerate() {
             if line.contains("//-") {
@@ -113,7 +134,7 @@ impl Fixture {
             }
         }
 
-        res
+        (mini_core, res)
     }
 
     //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
@@ -172,6 +193,133 @@ impl Fixture {
     }
 }
 
+impl MiniCore {
+    fn has_flag(&self, flag: &str) -> bool {
+        self.activated_flags.iter().any(|it| it == flag)
+    }
+
+    #[track_caller]
+    fn assert_valid_flag(&self, flag: &str) {
+        if !self.valid_flags.iter().any(|it| it == flag) {
+            panic!("invalid flag: {:?}, valid flags: {:?}", flag, self.valid_flags);
+        }
+    }
+
+    fn parse(line: &str) -> MiniCore {
+        let mut res = MiniCore { activated_flags: Vec::new(), valid_flags: Vec::new() };
+
+        let line = line.strip_prefix("//- minicore:").unwrap().trim();
+        for entry in line.split(", ") {
+            if res.has_flag(entry) {
+                panic!("duplicate minicore flag: {:?}", entry)
+            }
+            res.activated_flags.push(entry.to_string())
+        }
+
+        res
+    }
+
+    /// Strips parts of minicore.rs which are flagged by inactive flags.
+    ///
+    /// This is probably over-engineered to support flags dependencies.
+    pub fn source_code(mut self) -> String {
+        let mut buf = String::new();
+        let raw_mini_core = include_str!("./minicore.rs");
+        let mut lines = raw_mini_core.split_inclusive('\n');
+
+        let mut parsing_flags = false;
+        let mut implications = Vec::new();
+
+        // Parse `//!` preamble and extract flags and dependencies.
+        for line in lines.by_ref() {
+            let line = match line.strip_prefix("//!") {
+                Some(it) => it,
+                None => {
+                    assert!(line.trim().is_empty());
+                    break;
+                }
+            };
+
+            if parsing_flags {
+                let (flag, deps) = line.split_once(':').unwrap();
+                let flag = flag.trim();
+                self.valid_flags.push(flag.to_string());
+                for dep in deps.split(", ") {
+                    let dep = dep.trim();
+                    if !dep.is_empty() {
+                        self.assert_valid_flag(dep);
+                        implications.push((flag, dep));
+                    }
+                }
+            }
+
+            if line.contains("Available flags:") {
+                parsing_flags = true;
+            }
+        }
+
+        for flag in &self.activated_flags {
+            self.assert_valid_flag(flag);
+        }
+
+        // Fixed point loop to compute transitive closure of flags.
+        loop {
+            let mut changed = false;
+            for &(u, v) in implications.iter() {
+                if self.has_flag(u) && !self.has_flag(v) {
+                    self.activated_flags.push(v.to_string());
+                    changed = true;
+                }
+            }
+            if !changed {
+                break;
+            }
+        }
+
+        let mut curr_region = "";
+        let mut seen_regions = Vec::new();
+        for line in lines {
+            let trimmed = line.trim();
+            if let Some(region) = trimmed.strip_prefix("// region:") {
+                assert_eq!(curr_region, "");
+                curr_region = region;
+                continue;
+            }
+            if let Some(region) = trimmed.strip_prefix("// endregion:") {
+                assert_eq!(curr_region, region);
+                curr_region = "";
+                continue;
+            }
+            seen_regions.push(curr_region);
+
+            let mut flag = curr_region;
+            if let Some(idx) = trimmed.find("// :") {
+                flag = &trimmed[idx + "// :".len()..];
+            }
+
+            let skip = if flag == "" {
+                false
+            } else {
+                assert!(!flag.starts_with(' '), "region marker starts with a space: {:?}", flag);
+                self.assert_valid_flag(flag);
+                !self.has_flag(flag)
+            };
+
+            if !skip {
+                buf.push_str(line)
+            }
+        }
+
+        for flag in &self.valid_flags {
+            if !seen_regions.iter().any(|it| it == flag) {
+                panic!("unused minicore flag: {:?}", flag);
+            }
+        }
+
+        buf
+    }
+}
+
 #[test]
 #[should_panic]
 fn parse_fixture_checks_further_indented_metadata() {
@@ -189,12 +337,14 @@ fn parse_fixture_checks_further_indented_metadata() {
 
 #[test]
 fn parse_fixture_gets_full_meta() {
-    let parsed = Fixture::parse(
-        r"
-    //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
-    mod m;
-    ",
+    let (mini_core, parsed) = Fixture::parse(
+        r#"
+//- minicore: coerce_unsized
+//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
+mod m;
+"#,
     );
+    assert_eq!(mini_core.unwrap().activated_flags, vec!["coerce_unsized".to_string()]);
     assert_eq!(1, parsed.len());
 
     let meta = &parsed[0];
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index b2fe25f82..d55bae62a 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -23,7 +23,10 @@ use text_size::{TextRange, TextSize};
 pub use dissimilar::diff as __diff;
 pub use rustc_hash::FxHashMap;
 
-pub use crate::{assert_linear::AssertLinear, fixture::Fixture};
+pub use crate::{
+    assert_linear::AssertLinear,
+    fixture::{Fixture, MiniCore},
+};
 
 pub const CURSOR_MARKER: &str = "$0";
 pub const ESCAPED_CURSOR_MARKER: &str = "\\$0";
diff --git a/crates/test_utils/src/minicore.rs b/crates/test_utils/src/minicore.rs
new file mode 100644
index 000000000..5ff60178c
--- /dev/null
+++ b/crates/test_utils/src/minicore.rs
@@ -0,0 +1,204 @@
+//! This is a fixture we use for tests that need lang items.
+//!
+//! We want to include the minimal subset of core for each test, so this file
+//! supports "conditional compilation". Tests use the following syntax to include minicore:
+//!
+//!  //- minicore: flag1, flag2
+//!
+//! We then strip all the code marked with other flags.
+//!
+//! Available flags:
+//!     sized:
+//!     slice:
+//!     range:
+//!     unsize: sized
+//!     deref: sized
+//!     coerce_unsized: unsize
+//!     pin:
+//!     future: pin
+//!     option:
+//!     result:
+
+pub mod marker {
+    // region:sized
+    #[lang = "sized"]
+    #[fundamental]
+    #[rustc_specialization_trait]
+    pub trait Sized {}
+    // endregion:sized
+
+    // region:unsize
+    #[lang = "unsize"]
+    pub trait Unsize<T: ?Sized> {}
+    // endregion:unsize
+}
+
+pub mod ops {
+    // region:coerce_unsized
+    mod unsize {
+        use crate::marker::Unsize;
+
+        #[lang = "coerce_unsized"]
+        pub trait CoerceUnsized<T: ?Sized> {}
+
+        impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a mut U> for &'a mut T {}
+        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b mut T {}
+        impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for &'a mut T {}
+        impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for &'a mut T {}
+
+        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
+        impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for &'a T {}
+
+        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
+        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *mut T {}
+        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *const T {}
+    }
+    pub use self::unsize::CoerceUnsized;
+    // endregion:coerce_unsized
+
+    // region:deref
+    mod deref {
+        #[lang = "deref"]
+        pub trait Deref {
+            #[lang = "deref_target"]
+            type Target: ?Sized;
+            fn deref(&self) -> &Self::Target;
+        }
+    }
+    pub use self::deref::Deref;
+    // endregion:deref
+
+    // region:range
+    mod range {
+        #[lang = "RangeFull"]
+        pub struct RangeFull;
+
+        #[lang = "Range"]
+        pub struct Range<Idx> {
+            pub start: Idx,
+            pub end: Idx,
+        }
+
+        #[lang = "RangeFrom"]
+        pub struct RangeFrom<Idx> {
+            pub start: Idx,
+        }
+
+        #[lang = "RangeTo"]
+        pub struct RangeTo<Idx> {
+            pub end: Idx,
+        }
+
+        #[lang = "RangeInclusive"]
+        pub struct RangeInclusive<Idx> {
+            pub(crate) start: Idx,
+            pub(crate) end: Idx,
+            pub(crate) exhausted: bool,
+        }
+
+        #[lang = "RangeToInclusive"]
+        pub struct RangeToInclusive<Idx> {
+            pub end: Idx,
+        }
+    }
+    pub use self::range::{Range, RangeFrom, RangeFull, RangeTo};
+    pub use self::range::{RangeInclusive, RangeToInclusive};
+    // endregion:range
+}
+
+// region:slice
+pub mod slice {
+    #[lang = "slice"]
+    impl<T> [T] {
+        pub fn len(&self) -> usize {
+            loop {}
+        }
+    }
+}
+// endregion:slice
+
+// region:option
+pub mod option {
+    pub enum Option<T> {
+        #[lang = "None"]
+        None,
+        #[lang = "Some"]
+        Some(T),
+    }
+}
+// endregion:option
+
+// region:result
+pub mod result {
+    pub enum Result<T, E> {
+        #[lang = "Ok"]
+        Ok(T),
+        #[lang = "Err"]
+        Err(E),
+    }
+}
+// endregion:result
+
+// region:pin
+pub mod pin {
+    #[lang = "pin"]
+    #[fundamental]
+    pub struct Pin<P> {
+        pointer: P,
+    }
+}
+// endregion:pin
+
+// region:future
+pub mod future {
+    use crate::{
+        pin::Pin,
+        task::{Context, Poll},
+    };
+
+    #[lang = "future_trait"]
+    pub trait Future {
+        type Output;
+        #[lang = "poll"]
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
+    }
+}
+pub mod task {
+    pub enum Poll<T> {
+        #[lang = "Ready"]
+        Ready(T),
+        #[lang = "Pending"]
+        Pending,
+    }
+
+    pub struct Context<'a> {
+        waker: &'a (),
+    }
+}
+// endregion:future
+
+pub mod prelude {
+    pub mod v1 {
+        pub use crate::{
+            marker::Sized,                      // :sized
+            option::Option::{self, None, Some}, // :option
+            result::Result::{self, Err, Ok},    // :result
+        };
+    }
+
+    pub mod rust_2015 {
+        pub use super::v1::*;
+    }
+
+    pub mod rust_2018 {
+        pub use super::v1::*;
+    }
+
+    pub mod rust_2021 {
+        pub use super::v1::*;
+    }
+}
+
+#[prelude_import]
+#[allow(unused)]
+use prelude::v1::*;