86 files changed, 2169 insertions, 1062 deletions
diff --git a/Cargo.lock b/Cargo.lock
index d7e6d3ac8..1bb66c66e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -259,9 +259,9 @@ dependencies = [
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dca26ee1f8d361640700bde38b2c37d8c22b3ce2d360e1fc1c74ea4b0aa7d775"
+checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
 dependencies = [
 "cfg-if",
 "crossbeam-utils",
@@ -971,9 +971,9 @@ dependencies = [
 [[package]]
 name = "notify"
-version = "5.0.0-pre.6"
+version = "5.0.0-pre.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5fd82b93434edb9c00ae65ee741e0e081cdc8c63346ab9f687935a629aaf4c3"
+checksum = "1ebe7699a0f8c5759450716ee03d231685c22b4fe8f406c42c22e0ad94d40ce7"
 dependencies = [
 "anymap",
 "bitflags",
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 04e2be390..0132565e4 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -35,7 +35,7 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
    fn with_position(ra_fixture: &str) -> (Self, FilePosition) {
        let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
        let offset = match range_or_offset {
-            RangeOrOffset::Range(_) => panic!(),
+            RangeOrOffset::Range(_) => panic!("Expected a cursor position, got a range instead"),
            RangeOrOffset::Offset(it) => it,
        };
        (db, FilePosition { file_id, offset })
@@ -45,7 +45,7 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
        let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
        let range = match range_or_offset {
            RangeOrOffset::Range(it) => it,
-            RangeOrOffset::Offset(_) => panic!(),
+            RangeOrOffset::Offset(_) => panic!("Expected a cursor range, got a position instead"),
        };
        (db, FileRange { file_id, range })
    }
@@ -54,7 +54,9 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
        let fixture = ChangeFixture::parse(ra_fixture);
        let mut db = Self::default();
        fixture.change.apply(&mut db);
-        let (file_id, range_or_offset) = fixture.file_position.unwrap();
+        let (file_id, range_or_offset) = fixture
+            .file_position
+            .expect("Could not find file position in fixture. Did you forget to add an `$0`?");
        (db, file_id, range_or_offset)
    }
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index eba46a056..0acfa582a 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -2066,6 +2066,18 @@ impl Type {
        self.ty.dyn_trait().map(Into::into)
    }
+    /// If a type can be represented as `dyn Trait`, returns all traits accessible via this type,
+    /// or an empty iterator otherwise.
+    pub fn applicable_inherent_traits<'a>(
+        &'a self,
+        db: &'a dyn HirDatabase,
+    ) -> impl Iterator<Item = Trait> + 'a {
+        self.autoderef(db)
+            .filter_map(|derefed_type| derefed_type.ty.dyn_trait())
+            .flat_map(move |dyn_trait_id| hir_ty::all_super_traits(db.upcast(), dyn_trait_id))
+            .map(Trait::from)
+    }
    pub fn as_impl_traits(&self, db: &dyn HirDatabase) -> Option<Vec<Trait>> {
        self.ty.impl_trait_bounds(db).map(|it| {
            it.into_iter()
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index ed07d6928..c0b0b7841 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -568,9 +568,13 @@ impl ExprCollector<'_> {
        let res = match res {
            Ok(res) => res,
-            Err(UnresolvedMacro) => {
+            Err(UnresolvedMacro { path }) => {
                self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedMacroCall(
-                    UnresolvedMacroCall { file: outer_file, node: syntax_ptr.cast().unwrap() },
+                    UnresolvedMacroCall {
+                        file: outer_file,
+                        node: syntax_ptr.cast().unwrap(),
+                        path,
+                    },
                ));
                collector(self, None);
                return;
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index c1d3e998f..63f5fe88d 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -180,7 +180,7 @@ fn unresolved_macro_diag() {
        r#"
 fn f() {
    m!();
-  //^^^^ unresolved macro call
+  //^^^^ unresolved macro `m!`
 }
      "#,
    );
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index 97abf8653..a71ae2668 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -8,7 +8,7 @@ use hir_expand::diagnostics::{Diagnostic, DiagnosticCode, DiagnosticSink};
 use hir_expand::{HirFileId, InFile};
 use syntax::{ast, AstPtr, SyntaxNodePtr, TextRange};
-use crate::{db::DefDatabase, DefWithBodyId};
+use crate::{db::DefDatabase, path::ModPath, DefWithBodyId};
 pub fn validate_body(db: &dyn DefDatabase, owner: DefWithBodyId, sink: &mut DiagnosticSink<'_>) {
    let source_map = db.body_with_source_map(owner).1;
@@ -103,6 +103,7 @@ impl Diagnostic for UnresolvedImport {
 pub struct UnresolvedMacroCall {
    pub file: HirFileId,
    pub node: AstPtr<ast::MacroCall>,
+    pub path: ModPath,
 }
 impl Diagnostic for UnresolvedMacroCall {
@@ -110,7 +111,7 @@ impl Diagnostic for UnresolvedMacroCall {
        DiagnosticCode("unresolved-macro-call")
    }
    fn message(&self) -> String {
-        "unresolved macro call".to_string()
+        format!("unresolved macro `{}!`", self.path)
    }
    fn display_source(&self) -> InFile<SyntaxNodePtr> {
        InFile::new(self.file, self.node.clone().into())
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index 109d3552f..2c4bbe585 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -425,106 +425,142 @@ mod tests {
    #[test]
    fn same_module() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            struct S;
+struct S;
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "S", "S", "crate::S", "self::S");
+            "S",
+            "S",
+            "crate::S",
+            "self::S",
+        );
    }
    #[test]
    fn enum_variant() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            enum E { A }
+enum E { A }
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "E::A", "E::A", "E::A", "E::A");
+            "E::A",
+            "E::A",
+            "E::A",
+            "E::A",
+        );
    }
    #[test]
    fn sub_module() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo {
+mod foo {
-                pub struct S;
+    pub struct S;
-            }
+}
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "foo::S", "foo::S", "crate::foo::S", "self::foo::S");
+            "foo::S",
+            "foo::S",
+            "crate::foo::S",
+            "self::foo::S",
+        );
    }
    #[test]
    fn super_module() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            //- /foo.rs
+mod foo;
-            mod bar;
+//- /foo.rs
-            struct S;
+mod bar;
-            //- /foo/bar.rs
+struct S;
-            $0
+//- /foo/bar.rs
-        "#;
+$0
-        check_found_path(code, "super::S", "super::S", "crate::foo::S", "super::S");
+        "#,
+            "super::S",
+            "super::S",
+            "crate::foo::S",
+            "super::S",
+        );
    }
    #[test]
    fn self_module() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            //- /foo.rs
+mod foo;
-            $0
+//- /foo.rs
-        "#;
+$0
-        check_found_path(code, "self", "self", "crate::foo", "self");
+        "#,
+            "self",
+            "self",
+            "crate::foo",
+            "self",
+        );
    }
    #[test]
    fn crate_root() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            //- /foo.rs
+mod foo;
-            $0
+//- /foo.rs
-        "#;
+$0
-        check_found_path(code, "crate", "crate", "crate", "crate");
+        "#,
+            "crate",
+            "crate",
+            "crate",
+            "crate",
+        );
    }
    #[test]
    fn same_crate() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            struct S;
+mod foo;
-            //- /foo.rs
+struct S;
-            $0
+//- /foo.rs
-        "#;
+$0
-        check_found_path(code, "crate::S", "crate::S", "crate::S", "crate::S");
+        "#,
+            "crate::S",
+            "crate::S",
+            "crate::S",
+            "crate::S",
+        );
    }
    #[test]
    fn different_crate() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs crate:main deps:std
+            r#"
-            $0
+//- /main.rs crate:main deps:std
-            //- /std.rs crate:std
+$0
-            pub struct S;
+//- /std.rs crate:std
-        "#;
+pub struct S;
-        check_found_path(code, "std::S", "std::S", "std::S", "std::S");
+        "#,
+            "std::S",
+            "std::S",
+            "std::S",
+            "std::S",
+        );
    }
    #[test]
    fn different_crate_renamed() {
-        let code = r#"
-            //- /main.rs crate:main deps:std
-            extern crate std as std_renamed;
-            $0
-            //- /std.rs crate:std
-            pub struct S;
-        "#;
        check_found_path(
-            code,
+            r#"
+//- /main.rs crate:main deps:std
+extern crate std as std_renamed;
+$0
+//- /std.rs crate:std
+pub struct S;
+        "#,
            "std_renamed::S",
            "std_renamed::S",
            "std_renamed::S",
@@ -537,41 +573,38 @@ mod tests {
        cov_mark::check!(partially_imported);
        // Tests that short paths are used even for external items, when parts of the path are
        // already in scope.
-        let code = r#"
+        check_found_path(
-            //- /main.rs crate:main deps:syntax
+            r#"
+//- /main.rs crate:main deps:syntax
-            use syntax::ast;
+use syntax::ast;
-            $0
+$0
-            //- /lib.rs crate:syntax
+//- /lib.rs crate:syntax
-            pub mod ast {
+pub mod ast {
-                pub enum ModuleItem {
+    pub enum ModuleItem {
-                    A, B, C,
+        A, B, C,
-                }
+    }
-            }
+}
-        "#;
+        "#,
-        check_found_path(
-            code,
            "ast::ModuleItem",
            "syntax::ast::ModuleItem",
            "syntax::ast::ModuleItem",
            "syntax::ast::ModuleItem",
        );
-        let code = r#"
-            //- /main.rs crate:main deps:syntax
-            $0
-            //- /lib.rs crate:syntax
-            pub mod ast {
-                pub enum ModuleItem {
-                    A, B, C,
-                }
-            }
-        "#;
        check_found_path(
-            code,
+            r#"
+//- /main.rs crate:main deps:syntax
+$0
+//- /lib.rs crate:syntax
+pub mod ast {
+    pub enum ModuleItem {
+        A, B, C,
+    }
+}
+        "#,
            "syntax::ast::ModuleItem",
            "syntax::ast::ModuleItem",
            "syntax::ast::ModuleItem",
@@ -581,68 +614,86 @@ mod tests {
    #[test]
    fn same_crate_reexport() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod bar {
+mod bar {
-                mod foo { pub(super) struct S; }
+    mod foo { pub(super) struct S; }
-                pub(crate) use foo::*;
+    pub(crate) use foo::*;
-            }
+}
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "bar::S", "bar::S", "crate::bar::S", "self::bar::S");
+            "bar::S",
+            "bar::S",
+            "crate::bar::S",
+            "self::bar::S",
+        );
    }
    #[test]
    fn same_crate_reexport_rename() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod bar {
+mod bar {
-                mod foo { pub(super) struct S; }
+    mod foo { pub(super) struct S; }
-                pub(crate) use foo::S as U;
+    pub(crate) use foo::S as U;
-            }
+}
-            $0
+$0
-        "#;
+        "#,
-        check_found_path(code, "bar::U", "bar::U", "crate::bar::U", "self::bar::U");
+            "bar::U",
+            "bar::U",
+            "crate::bar::U",
+            "self::bar::U",
+        );
    }
    #[test]
    fn different_crate_reexport() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs crate:main deps:std
+            r#"
-            $0
+//- /main.rs crate:main deps:std
-            //- /std.rs crate:std deps:core
+$0
-            pub use core::S;
+//- /std.rs crate:std deps:core
-            //- /core.rs crate:core
+pub use core::S;
-            pub struct S;
+//- /core.rs crate:core
-        "#;
+pub struct S;
-        check_found_path(code, "std::S", "std::S", "std::S", "std::S");
+        "#,
+            "std::S",
+            "std::S",
+            "std::S",
+            "std::S",
+        );
    }
    #[test]
    fn prelude() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs crate:main deps:std
+            r#"
-            $0
+//- /main.rs crate:main deps:std
-            //- /std.rs crate:std
+$0
-            pub mod prelude { pub struct S; }
+//- /std.rs crate:std
-            #[prelude_import]
+pub mod prelude { pub struct S; }
-            pub use prelude::*;
+#[prelude_import]
-        "#;
+pub use prelude::*;
-        check_found_path(code, "S", "S", "S", "S");
+        "#,
+            "S",
+            "S",
+            "S",
+            "S",
+        );
    }
    #[test]
    fn enum_variant_from_prelude() {
        let code = r#"
-            //- /main.rs crate:main deps:std
+//- /main.rs crate:main deps:std
-            $0
+$0
-            //- /std.rs crate:std
+//- /std.rs crate:std
-            pub mod prelude {
+pub mod prelude {
-                pub enum Option<T> { Some(T), None }
+    pub enum Option<T> { Some(T), None }
-                pub use Option::*;
+    pub use Option::*;
-            }
+}
-            #[prelude_import]
+#[prelude_import]
-            pub use prelude::*;
+pub use prelude::*;
        "#;
        check_found_path(code, "None", "None", "None", "None");
        check_found_path(code, "Some", "Some", "Some", "Some");
@@ -650,71 +701,85 @@ mod tests {
    #[test]
    fn shortest_path() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            pub mod foo;
+//- /main.rs
-            pub mod baz;
+pub mod foo;
-            struct S;
+pub mod baz;
-            $0
+struct S;
-            //- /foo.rs
+$0
-            pub mod bar { pub struct S; }
+//- /foo.rs
-            //- /baz.rs
+pub mod bar { pub struct S; }
-            pub use crate::foo::bar::S;
+//- /baz.rs
-        "#;
+pub use crate::foo::bar::S;
-        check_found_path(code, "baz::S", "baz::S", "crate::baz::S", "self::baz::S");
+        "#,
+            "baz::S",
+            "baz::S",
+            "crate::baz::S",
+            "self::baz::S",
+        );
    }
    #[test]
    fn discount_private_imports() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            mod foo;
+//- /main.rs
-            pub mod bar { pub struct S; }
+mod foo;
-            use bar::S;
+pub mod bar { pub struct S; }
-            //- /foo.rs
+use bar::S;
-            $0
+//- /foo.rs
-        "#;
+$0
-        // crate::S would be shorter, but using private imports seems wrong
+        "#,
-        check_found_path(code, "crate::bar::S", "crate::bar::S", "crate::bar::S", "crate::bar::S");
+            // crate::S would be shorter, but using private imports seems wrong
+            "crate::bar::S",
+            "crate::bar::S",
+            "crate::bar::S",
+            "crate::bar::S",
+        );
    }
    #[test]
    fn import_cycle() {
-        let code = r#"
+        check_found_path(
-            //- /main.rs
+            r#"
-            pub mod foo;
+//- /main.rs
-            pub mod bar;
+pub mod foo;
-            pub mod baz;
+pub mod bar;
-            //- /bar.rs
+pub mod baz;
-            $0
+//- /bar.rs
-            //- /foo.rs
+$0
-            pub use super::baz;
+//- /foo.rs
-            pub struct S;
+pub use super::baz;
-            //- /baz.rs
+pub struct S;
-            pub use super::foo;
+//- /baz.rs
-        "#;
+pub use super::foo;
-        check_found_path(code, "crate::foo::S", "crate::foo::S", "crate::foo::S", "crate::foo::S");
+        "#,
+            "crate::foo::S",
+            "crate::foo::S",
+            "crate::foo::S",
+            "crate::foo::S",
+        );
    }
    #[test]
    fn prefer_std_paths_over_alloc() {
        cov_mark::check!(prefer_std_paths);
-        let code = r#"
+        check_found_path(
-        //- /main.rs crate:main deps:alloc,std
+            r#"
-        $0
+//- /main.rs crate:main deps:alloc,std
+$0
-        //- /std.rs crate:std deps:alloc
+//- /std.rs crate:std deps:alloc
-        pub mod sync {
+pub mod sync {
-            pub use alloc::sync::Arc;
+    pub use alloc::sync::Arc;
-        }
+}
-        //- /zzz.rs crate:alloc
+//- /zzz.rs crate:alloc
-        pub mod sync {
+pub mod sync {
-            pub struct Arc;
+    pub struct Arc;
-        }
+}
-        "#;
+        "#,
-        check_found_path(
-            code,
            "std::sync::Arc",
            "std::sync::Arc",
            "std::sync::Arc",
@@ -725,26 +790,25 @@ mod tests {
    #[test]
    fn prefer_core_paths_over_std() {
        cov_mark::check!(prefer_no_std_paths);
-        let code = r#"
+        check_found_path(
-        //- /main.rs crate:main deps:core,std
+            r#"
-        #![no_std]
+//- /main.rs crate:main deps:core,std
+#![no_std]
-        $0
+$0
-        //- /std.rs crate:std deps:core
+//- /std.rs crate:std deps:core
-        pub mod fmt {
+pub mod fmt {
-            pub use core::fmt::Error;
+    pub use core::fmt::Error;
-        }
+}
-        //- /zzz.rs crate:core
+//- /zzz.rs crate:core
-        pub mod fmt {
+pub mod fmt {
-            pub struct Error;
+    pub struct Error;
-        }
+}
-        "#;
+        "#,
-        check_found_path(
-            code,
            "core::fmt::Error",
            "core::fmt::Error",
            "core::fmt::Error",
@@ -754,26 +818,25 @@ mod tests {
    #[test]
    fn prefer_alloc_paths_over_std() {
-        let code = r#"
+        check_found_path(
-        //- /main.rs crate:main deps:alloc,std
+            r#"
-        #![no_std]
+//- /main.rs crate:main deps:alloc,std
+#![no_std]
-        $0
+$0
-        //- /std.rs crate:std deps:alloc
+//- /std.rs crate:std deps:alloc
-        pub mod sync {
+pub mod sync {
-            pub use alloc::sync::Arc;
+    pub use alloc::sync::Arc;
-        }
+}
-        //- /zzz.rs crate:alloc
+//- /zzz.rs crate:alloc
-        pub mod sync {
+pub mod sync {
-            pub struct Arc;
+    pub struct Arc;
-        }
+}
-        "#;
+            "#,
-        check_found_path(
-            code,
            "alloc::sync::Arc",
            "alloc::sync::Arc",
            "alloc::sync::Arc",
@@ -783,20 +846,19 @@ mod tests {
    #[test]
    fn prefer_shorter_paths_if_not_alloc() {
-        let code = r#"
+        check_found_path(
-        //- /main.rs crate:main deps:megaalloc,std
+            r#"
-        $0
+//- /main.rs crate:main deps:megaalloc,std
+$0
-        //- /std.rs crate:std deps:megaalloc
+//- /std.rs crate:std deps:megaalloc
-        pub mod sync {
+pub mod sync {
-            pub use megaalloc::sync::Arc;
+    pub use megaalloc::sync::Arc;
-        }
+}
-        //- /zzz.rs crate:megaalloc
+//- /zzz.rs crate:megaalloc
-        pub struct Arc;
+pub struct Arc;
-        "#;
+            "#,
-        check_found_path(
-            code,
            "megaalloc::Arc",
            "megaalloc::Arc",
            "megaalloc::Arc",
@@ -807,12 +869,11 @@ mod tests {
    #[test]
    fn builtins_are_in_scope() {
        let code = r#"
-        //- /main.rs
+$0
-        $0
-        pub mod primitive {
+pub mod primitive {
-            pub use u8;
+    pub use u8;
-        }
+}
        "#;
        check_found_path(code, "u8", "u8", "u8", "u8");
        check_found_path(code, "u16", "u16", "u16", "u16");
@@ -822,10 +883,10 @@ mod tests {
    fn inner_items() {
        check_found_path(
            r#"
-            fn main() {
+fn main() {
-                struct Inner {}
+    struct Inner {}
-                $0
+    $0
-            }
+}
        "#,
            "Inner",
            "Inner",
@@ -838,12 +899,12 @@ mod tests {
    fn inner_items_from_outer_scope() {
        check_found_path(
            r#"
-            fn main() {
+fn main() {
-                struct Struct {}
+    struct Struct {}
-                {
+    {
-                    $0
+        $0
-                }
+    }
-            }
+}
        "#,
            "Struct",
            "Struct",
@@ -857,14 +918,14 @@ mod tests {
        cov_mark::check!(prefixed_in_block_expression);
        check_found_path(
            r#"
-            fn main() {
+fn main() {
-                mod module {
+    mod module {
-                    struct Struct {}
+        struct Struct {}
-                }
+    }
-                {
+    {
-                    $0
+        $0
-                }
+    }
-            }
+}
        "#,
            "module::Struct",
            "module::Struct",
@@ -877,14 +938,14 @@ mod tests {
    fn outer_items_with_inner_items_present() {
        check_found_path(
            r#"
-            mod module {
+mod module {
-                pub struct CompleteMe;
+    pub struct CompleteMe;
-            }
+}
-            fn main() {
+fn main() {
-                fn inner() {}
+    fn inner() {}
-                $0
+    $0
-            }
+}
            "#,
            "module::CompleteMe",
            "module::CompleteMe",
@@ -894,6 +955,29 @@ mod tests {
    }
    #[test]
+    fn from_inside_module() {
+        // This worked correctly, but the test suite logic was broken.
+        cov_mark::check!(submodule_in_testdb);
+        check_found_path(
+            r#"
+mod baz {
+    pub struct Foo {}
+}
+mod bar {
+    fn bar() {
+        $0
+    }
+}
+            "#,
+            "crate::baz::Foo",
+            "crate::baz::Foo",
+            "crate::baz::Foo",
+            "crate::baz::Foo",
+        )
+    }
+    #[test]
    fn recursive_pub_mod_reexport() {
        cov_mark::check!(recursive_imports);
        check_found_path(
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index d69116d51..5ac1670b5 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -66,6 +66,7 @@ use hir_expand::{
 };
 use la_arena::Idx;
 use nameres::DefMap;
+use path::ModPath;
 use syntax::ast;
 use crate::builtin_type::BuiltinType;
@@ -107,6 +108,18 @@ impl ModuleId {
    pub fn containing_module(&self, db: &dyn db::DefDatabase) -> Option<ModuleId> {
        self.def_map(db).containing_module(self.local_id)
    }
+    /// Returns `true` if this module represents a block expression.
+    ///
+    /// Returns `false` if this module is a submodule *inside* a block expression
+    /// (eg. `m` in `{ mod m {} }`).
+    pub fn is_block_root(&self, db: &dyn db::DefDatabase) -> bool {
+        if self.block.is_none() {
+            return false;
+        }
+        self.def_map(db)[self.local_id].parent.is_none()
+    }
 }
 /// An ID of a module, **local** to a specific crate
@@ -435,6 +448,16 @@ impl_from!(
    for AttrDefId
 );
+impl From<AssocContainerId> for AttrDefId {
+    fn from(acid: AssocContainerId) -> Self {
+        match acid {
+            AssocContainerId::ModuleId(mid) => AttrDefId::ModuleId(mid),
+            AssocContainerId::ImplId(iid) => AttrDefId::ImplId(iid),
+            AssocContainerId::TraitId(tid) => AttrDefId::TraitId(tid),
+        }
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum VariantId {
    EnumVariantId(EnumVariantId),
@@ -665,7 +688,9 @@ impl<T: ast::AstNode> AstIdWithPath<T> {
    }
 }
-pub struct UnresolvedMacro;
+pub struct UnresolvedMacro {
+    pub path: ModPath,
+}
 fn macro_call_as_call_id(
    call: &AstIdWithPath<ast::MacroCall>,
@@ -674,7 +699,8 @@ fn macro_call_as_call_id(
    resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
    error_sink: &mut dyn FnMut(mbe::ExpandError),
 ) -> Result<Result<MacroCallId, ErrorEmitted>, UnresolvedMacro> {
-    let def: MacroDefId = resolver(call.path.clone()).ok_or(UnresolvedMacro)?;
+    let def: MacroDefId =
+        resolver(call.path.clone()).ok_or_else(|| UnresolvedMacro { path: call.path.clone() })?;
    let res = if let MacroDefKind::BuiltInEager(..) = def.kind {
        let macro_call = InFile::new(call.ast_id.file_id, call.ast_id.to_node(db.upcast()));
@@ -704,8 +730,13 @@ fn derive_macro_as_call_id(
    krate: CrateId,
    resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
 ) -> Result<MacroCallId, UnresolvedMacro> {
-    let def: MacroDefId = resolver(item_attr.path.clone()).ok_or(UnresolvedMacro)?;
+    let def: MacroDefId = resolver(item_attr.path.clone())
-    let last_segment = item_attr.path.segments().last().ok_or(UnresolvedMacro)?;
+        .ok_or_else(|| UnresolvedMacro { path: item_attr.path.clone() })?;
+    let last_segment = item_attr
+        .path
+        .segments()
+        .last()
+        .ok_or_else(|| UnresolvedMacro { path: item_attr.path.clone() })?;
    let res = def
        .as_lazy_macro(
            db.upcast(),
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 9e181751c..542f190a1 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -481,7 +481,7 @@ mod diagnostics {
        UnresolvedProcMacro { ast: MacroCallKind },
-        UnresolvedMacroCall { ast: AstId<ast::MacroCall> },
+        UnresolvedMacroCall { ast: AstId<ast::MacroCall>, path: ModPath },
        MacroError { ast: MacroCallKind, message: String },
    }
@@ -546,8 +546,9 @@ mod diagnostics {
        pub(super) fn unresolved_macro_call(
            container: LocalModuleId,
            ast: AstId<ast::MacroCall>,
+            path: ModPath,
        ) -> Self {
-            Self { in_module: container, kind: DiagnosticKind::UnresolvedMacroCall { ast } }
+            Self { in_module: container, kind: DiagnosticKind::UnresolvedMacroCall { ast, path } }
        }
        pub(super) fn add_to(
@@ -662,9 +663,13 @@ mod diagnostics {
                    });
                }
-                DiagnosticKind::UnresolvedMacroCall { ast } => {
+                DiagnosticKind::UnresolvedMacroCall { ast, path } => {
                    let node = ast.to_node(db.upcast());
-                    sink.push(UnresolvedMacroCall { file: ast.file_id, node: AstPtr::new(&node) });
+                    sink.push(UnresolvedMacroCall {
+                        file: ast.file_id,
+                        node: AstPtr::new(&node),
+                        path: path.clone(),
+                    });
                }
                DiagnosticKind::MacroError { ast, message } => {
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index fb4ddff5e..05ceb1efb 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -829,7 +829,7 @@ impl DefCollector<'_> {
                            res = ReachedFixedPoint::No;
                            return false;
                        }
-                        Err(UnresolvedMacro) | Ok(Err(_)) => {}
+                        Err(UnresolvedMacro { .. }) | Ok(Err(_)) => {}
                    }
                }
                MacroDirectiveKind::Derive { ast_id, derive_attr } => {
@@ -845,7 +845,7 @@ impl DefCollector<'_> {
                            res = ReachedFixedPoint::No;
                            return false;
                        }
-                        Err(UnresolvedMacro) => (),
+                        Err(UnresolvedMacro { .. }) => (),
                    }
                }
            }
@@ -943,10 +943,11 @@ impl DefCollector<'_> {
                    &mut |_| (),
                ) {
                    Ok(_) => (),
-                    Err(UnresolvedMacro) => {
+                    Err(UnresolvedMacro { path }) => {
                        self.def_map.diagnostics.push(DefDiagnostic::unresolved_macro_call(
                            directive.module_id,
                            ast_id.ast_id,
+                            path,
                        ));
                    }
                },
@@ -1530,7 +1531,7 @@ impl ModCollector<'_, '_> {
                ));
                return;
            }
-            Err(UnresolvedMacro) => (),
+            Err(UnresolvedMacro { .. }) => (),
        }
        // Case 2: resolve in module scope, expand during name resolution.
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index ccc9f22eb..c984148c3 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -387,7 +387,13 @@ impl DefMap {
            .get_legacy_macro(name)
            .map_or_else(PerNs::none, |m| PerNs::macros(m, Visibility::Public));
        let from_scope = self[module].scope.get(name);
-        let from_builtin = BUILTIN_SCOPE.get(name).copied().unwrap_or_else(PerNs::none);
+        let from_builtin = match self.block {
+            Some(_) => {
+                // Only resolve to builtins in the root `DefMap`.
+                PerNs::none()
+            }
+            None => BUILTIN_SCOPE.get(name).copied().unwrap_or_else(PerNs::none),
+        };
        let from_scope_or_builtin = match shadow {
            BuiltinShadowMode::Module => from_scope.or(from_builtin),
            BuiltinShadowMode::Other => {
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
index 1ac88fc89..543975e07 100644
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -170,7 +170,7 @@ fn unresolved_legacy_scope_macro() {
          m!();
          m2!();
-        //^^^^^^ unresolved macro call
+        //^^^^^^ unresolved macro `self::m2!`
        "#,
    );
 }
@@ -187,7 +187,7 @@ fn unresolved_module_scope_macro() {
          self::m!();
          self::m2!();
-        //^^^^^^^^^^^^ unresolved macro call
+        //^^^^^^^^^^^^ unresolved macro `self::m2!`
        "#,
    );
 }
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index dd36106f8..8fa703a57 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -15,7 +15,12 @@ use rustc_hash::FxHashSet;
 use syntax::{algo, ast, AstNode, TextRange, TextSize};
 use test_utils::extract_annotations;
-use crate::{db::DefDatabase, nameres::DefMap, src::HasSource, Lookup, ModuleDefId, ModuleId};
+use crate::{
+    db::DefDatabase,
+    nameres::{DefMap, ModuleSource},
+    src::HasSource,
+    LocalModuleId, Lookup, ModuleDefId, ModuleId,
+};
 #[salsa::database(
    base_db::SourceDatabaseExtStorage,
@@ -87,10 +92,11 @@ impl TestDB {
    pub(crate) fn module_at_position(&self, position: FilePosition) -> ModuleId {
        let file_module = self.module_for_file(position.file_id);
        let mut def_map = file_module.def_map(self);
+        let module = self.mod_at_position(&def_map, position);
        def_map = match self.block_at_position(&def_map, position) {
            Some(it) => it,
-            None => return file_module,
+            None => return def_map.module_id(module),
        };
        loop {
            let new_map = self.block_at_position(&def_map, position);
@@ -106,6 +112,47 @@ impl TestDB {
        }
    }
+    /// Finds the smallest/innermost module in `def_map` containing `position`.
+    fn mod_at_position(&self, def_map: &DefMap, position: FilePosition) -> LocalModuleId {
+        let mut size = None;
+        let mut res = def_map.root();
+        for (module, data) in def_map.modules() {
+            let src = data.definition_source(self);
+            if src.file_id != position.file_id.into() {
+                continue;
+            }
+            let range = match src.value {
+                ModuleSource::SourceFile(it) => it.syntax().text_range(),
+                ModuleSource::Module(it) => it.syntax().text_range(),
+                ModuleSource::BlockExpr(it) => it.syntax().text_range(),
+            };
+            if !range.contains(position.offset) {
+                continue;
+            }
+            let new_size = match size {
+                None => range.len(),
+                Some(size) => {
+                    if range.len() < size {
+                        range.len()
+                    } else {
+                        size
+                    }
+                }
+            };
+            if size != Some(new_size) {
+                cov_mark::hit!(submodule_in_testdb);
+                size = Some(new_size);
+                res = module;
+            }
+        }
+        res
+    }
    fn block_at_position(&self, def_map: &DefMap, position: FilePosition) -> Option<Arc<DefMap>> {
        // Find the smallest (innermost) function in `def_map` containing the cursor.
        let mut size = None;
diff --git a/crates/hir_def/src/visibility.rs b/crates/hir_def/src/visibility.rs
index 9908cd926..d4b7c9970 100644
--- a/crates/hir_def/src/visibility.rs
+++ b/crates/hir_def/src/visibility.rs
@@ -123,11 +123,19 @@ impl Visibility {
        def_map: &DefMap,
        mut from_module: crate::LocalModuleId,
    ) -> bool {
-        let to_module = match self {
+        let mut to_module = match self {
            Visibility::Module(m) => m,
            Visibility::Public => return true,
        };
+        // `to_module` might be the root module of a block expression. Those have the same
+        // visibility as the containing module (even though no items are directly nameable from
+        // there, getting this right is important for method resolution).
+        // In that case, we adjust the visibility of `to_module` to point to the containing module.
+        if to_module.is_block_root(db) {
+            to_module = to_module.containing_module(db).unwrap();
+        }
        // from_module needs to be a descendant of to_module
        let mut def_map = def_map;
        let mut parent_arc;
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 80365fc16..179de61f9 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -110,6 +110,7 @@ register_builtin! {
    (format_args_nl, FormatArgsNl) => format_args_expand,
    (llvm_asm, LlvmAsm) => asm_expand,
    (asm, Asm) => asm_expand,
+    (global_asm, GlobalAsm) => global_asm_expand,
    (cfg, Cfg) => cfg_expand,
    (core_panic, CorePanic) => panic_expand,
    (std_panic, StdPanic) => panic_expand,
@@ -274,6 +275,15 @@ fn asm_expand(
    ExpandResult::ok(expanded)
 }
+fn global_asm_expand(
+    _db: &dyn AstDatabase,
+    _id: LazyMacroId,
+    _tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+    // Expand to nothing (at item-level)
+    ExpandResult::ok(quote! {})
+}
 fn cfg_expand(
    db: &dyn AstDatabase,
    id: LazyMacroId,
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index a0f8766b0..bcfd3e524 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -221,6 +221,7 @@ pub mod known {
        option_env,
        llvm_asm,
        asm,
+        global_asm,
        // Builtin derives
        Copy,
        Clone,
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index 71bc436e6..2c07494a9 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -36,6 +36,7 @@ pub(crate) fn deref(
    krate: CrateId,
    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
+    let _p = profile::span("deref");
    if let Some(derefed) = builtin_deref(&ty.goal.value) {
        Some(Canonical { value: derefed, binders: ty.goal.binders.clone() })
    } else {
@@ -56,6 +57,7 @@ fn deref_by_trait(
    krate: CrateId,
    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
+    let _p = profile::span("deref_by_trait");
    let deref_trait = match db.lang_item(krate, "deref".into())? {
        LangItemTarget::TraitId(it) => it,
        _ => return None,
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index 1690926ad..cf67d4266 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -128,13 +128,21 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
        id: chalk_db::AssociatedTyValueId,
    ) -> Arc<chalk_db::AssociatedTyValue>;
-    #[salsa::invoke(crate::traits::trait_solve_query)]
+    #[salsa::invoke(trait_solve_wait)]
+    #[salsa::transparent]
    fn trait_solve(
        &self,
        krate: CrateId,
        goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
    ) -> Option<crate::Solution>;
+    #[salsa::invoke(crate::traits::trait_solve_query)]
+    fn trait_solve_query(
+        &self,
+        krate: CrateId,
+        goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
+    ) -> Option<crate::Solution>;
    #[salsa::invoke(chalk_db::program_clauses_for_chalk_env_query)]
    fn program_clauses_for_chalk_env(
        &self,
@@ -156,6 +164,15 @@ fn infer_wait(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult>
    db.infer_query(def)
 }
+fn trait_solve_wait(
+    db: &dyn HirDatabase,
+    krate: CrateId,
+    goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
+) -> Option<crate::Solution> {
+    let _p = profile::span("trait_solve::wait");
+    db.trait_solve_query(krate, goal)
+}
 #[test]
 fn hir_database_is_object_safe() {
    fn _assert_object_safe(_: &dyn HirDatabase) {}
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index 1c9f9ede7..075dc4131 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -35,6 +35,8 @@ use crate::{
 };
 mod allow {
+    pub(super) const BAD_STYLE: &str = "bad_style";
+    pub(super) const NONSTANDARD_STYLE: &str = "nonstandard_style";
    pub(super) const NON_SNAKE_CASE: &str = "non_snake_case";
    pub(super) const NON_UPPER_CASE_GLOBAL: &str = "non_upper_case_globals";
    pub(super) const NON_CAMEL_CASE_TYPES: &str = "non_camel_case_types";
@@ -83,10 +85,39 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    }
    /// Checks whether not following the convention is allowed for this item.
-    ///
+    fn allowed(&self, id: AttrDefId, allow_name: &str, recursing: bool) -> bool {
-    /// Currently this method doesn't check parent attributes.
+        let is_allowed = |def_id| {
-    fn allowed(&self, id: AttrDefId, allow_name: &str) -> bool {
+            let attrs = self.db.attrs(def_id);
-        self.db.attrs(id).by_key("allow").tt_values().any(|tt| tt.to_string().contains(allow_name))
+            // don't bug the user about directly no_mangle annotated stuff, they can't do anything about it
+            (!recursing && attrs.by_key("no_mangle").exists())
+                || attrs.by_key("allow").tt_values().any(|tt| {
+                    let allows = tt.to_string();
+                    allows.contains(allow_name)
+                        || allows.contains(allow::BAD_STYLE)
+                        || allows.contains(allow::NONSTANDARD_STYLE)
+                })
+        };
+        is_allowed(id)
+            // go upwards one step or give up
+            || match id {
+                AttrDefId::ModuleId(m) => m.containing_module(self.db.upcast()).map(|v| v.into()),
+                AttrDefId::FunctionId(f) => Some(f.lookup(self.db.upcast()).container.into()),
+                AttrDefId::StaticId(sid) => Some(sid.lookup(self.db.upcast()).container.into()),
+                AttrDefId::ConstId(cid) => Some(cid.lookup(self.db.upcast()).container.into()),
+                AttrDefId::TraitId(tid) => Some(tid.lookup(self.db.upcast()).container.into()),
+                AttrDefId::ImplId(iid) => Some(iid.lookup(self.db.upcast()).container.into()),
+                // These warnings should not explore macro definitions at all
+                AttrDefId::MacroDefId(_) => None,
+                // Will never occur under an enum/struct/union/type alias
+                AttrDefId::AdtId(_) => None,
+                AttrDefId::FieldId(_) => None,
+                AttrDefId::EnumVariantId(_) => None,
+                AttrDefId::TypeAliasId(_) => None,
+                AttrDefId::GenericParamId(_) => None,
+            }
+            .map(|mid| self.allowed(mid, allow_name, true))
+            .unwrap_or(false)
    }
    fn validate_func(&mut self, func: FunctionId) {
@@ -109,7 +140,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        }
        // Check whether non-snake case identifiers are allowed for this function.
-        if self.allowed(func.into(), allow::NON_SNAKE_CASE) {
+        if self.allowed(func.into(), allow::NON_SNAKE_CASE, false) {
            return;
        }
@@ -328,8 +359,9 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn validate_struct(&mut self, struct_id: StructId) {
        let data = self.db.struct_data(struct_id);
-        let non_camel_case_allowed = self.allowed(struct_id.into(), allow::NON_CAMEL_CASE_TYPES);
+        let non_camel_case_allowed =
-        let non_snake_case_allowed = self.allowed(struct_id.into(), allow::NON_SNAKE_CASE);
+            self.allowed(struct_id.into(), allow::NON_CAMEL_CASE_TYPES, false);
+        let non_snake_case_allowed = self.allowed(struct_id.into(), allow::NON_SNAKE_CASE, false);
        // Check the structure name.
        let struct_name = data.name.to_string();
@@ -461,7 +493,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let data = self.db.enum_data(enum_id);
        // Check whether non-camel case names are allowed for this enum.
-        if self.allowed(enum_id.into(), allow::NON_CAMEL_CASE_TYPES) {
+        if self.allowed(enum_id.into(), allow::NON_CAMEL_CASE_TYPES, false) {
            return;
        }
@@ -584,7 +616,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
    fn validate_const(&mut self, const_id: ConstId) {
        let data = self.db.const_data(const_id);
-        if self.allowed(const_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
+        if self.allowed(const_id.into(), allow::NON_UPPER_CASE_GLOBAL, false) {
            return;
        }
@@ -632,7 +664,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
            return;
        }
-        if self.allowed(static_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
+        if self.allowed(static_id.into(), allow::NON_UPPER_CASE_GLOBAL, false) {
            return;
        }
@@ -867,23 +899,116 @@ fn main() {
    fn allow_attributes() {
        check_diagnostics(
            r#"
-            #[allow(non_snake_case)]
+#[allow(non_snake_case)]
-    fn NonSnakeCaseName(SOME_VAR: u8) -> u8{
+fn NonSnakeCaseName(SOME_VAR: u8) -> u8{
-        let OtherVar = SOME_VAR + 1;
+    // cov_flags generated output from elsewhere in this file
-        OtherVar
+    extern "C" {
+        #[no_mangle]
+        static lower_case: u8;
    }
-    #[allow(non_snake_case, non_camel_case_types)]
+    let OtherVar = SOME_VAR + 1;
-    pub struct some_type {
+    OtherVar
-        SOME_FIELD: u8,
+}
-        SomeField: u16,
+#[allow(nonstandard_style)]
+mod CheckNonstandardStyle {
+    fn HiImABadFnName() {}
+}
+#[allow(bad_style)]
+mod CheckBadStyle {
+    fn HiImABadFnName() {}
+}
+mod F {
+    #![allow(non_snake_case)]
+    fn CheckItWorksWithModAttr(BAD_NAME_HI: u8) {}
+}
+#[allow(non_snake_case, non_camel_case_types)]
+pub struct some_type {
+    SOME_FIELD: u8,
+    SomeField: u16,
+}
+#[allow(non_upper_case_globals)]
+pub const some_const: u8 = 10;
+#[allow(non_upper_case_globals)]
+pub static SomeStatic: u8 = 10;
+    "#,
+        );
    }
-    #[allow(non_upper_case_globals)]
+    #[test]
-    pub const some_const: u8 = 10;
+    fn allow_attributes_crate_attr() {
+        check_diagnostics(
+            r#"
+#![allow(non_snake_case)]
-    #[allow(non_upper_case_globals)]
+mod F {
-    pub static SomeStatic: u8 = 10;
+    fn CheckItWorksWithCrateAttr(BAD_NAME_HI: u8) {}
+}
+    "#,
+        );
+    }
+    #[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.
+        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 {
+            const HiImAlsoBad: u8 = 2;
+            #[inline]
+            fn Dirty(&self) -> bool {
+                false
+            }
+        }
+    }
+}
+    "#,
+        );
+    }
+    #[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/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 113234fa4..0505fa4ae 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -56,6 +56,7 @@ pub use mapping::{
    to_foreign_def_id, to_placeholder_idx,
 };
 pub use traits::TraitEnvironment;
+pub use utils::all_super_traits;
 pub use walk::TypeWalk;
 pub use chalk_ir::{
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index 6178b36c8..48bbcfd9f 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -13,7 +13,6 @@ use hir_def::{
 };
 use hir_expand::name::Name;
 use rustc_hash::{FxHashMap, FxHashSet};
-use stdx::always;
 use crate::{
    autoderef,
@@ -22,8 +21,8 @@ use crate::{
    primitive::{self, FloatTy, IntTy, UintTy},
    static_lifetime,
    utils::all_super_traits,
-    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, ForeignDefId, HirDisplay, InEnvironment,
+    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, ForeignDefId, InEnvironment, Interner,
-    Interner, Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyExt, TyKind,
+    Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyExt, TyKind,
 };
 /// This is used as a key for indexing impls.
@@ -247,29 +246,39 @@ pub struct InherentImpls {
 impl InherentImpls {
    pub(crate) fn inherent_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
-        let mut map: FxHashMap<_, Vec<_>> = FxHashMap::default();
+        let mut impls = Self { map: FxHashMap::default() };
        let crate_def_map = db.crate_def_map(krate);
-        for (_module_id, module_data) in crate_def_map.modules() {
+        collect_def_map(db, &crate_def_map, &mut impls);
-            for impl_id in module_data.scope.impls() {
-                let data = db.impl_data(impl_id);
+        return Arc::new(impls);
-                if data.target_trait.is_some() {
-                    continue;
+        fn collect_def_map(db: &dyn HirDatabase, def_map: &DefMap, impls: &mut InherentImpls) {
+            for (_module_id, module_data) in def_map.modules() {
+                for impl_id in module_data.scope.impls() {
+                    let data = db.impl_data(impl_id);
+                    if data.target_trait.is_some() {
+                        continue;
+                    }
+                    let self_ty = db.impl_self_ty(impl_id);
+                    let fp = TyFingerprint::for_inherent_impl(self_ty.skip_binders());
+                    if let Some(fp) = fp {
+                        impls.map.entry(fp).or_default().push(impl_id);
+                    }
+                    // `fp` should only be `None` in error cases (either erroneous code or incomplete name resolution)
                }
-                let self_ty = db.impl_self_ty(impl_id);
+                // To better support custom derives, collect impls in all unnamed const items.
-                let fp = TyFingerprint::for_inherent_impl(self_ty.skip_binders());
+                // const _: () = { ... };
-                always!(fp.is_some(), "no fingerprint for {}", self_ty.skip_binders().display(db));
+                for konst in module_data.scope.unnamed_consts() {
-                if let Some(fp) = fp {
+                    let body = db.body(konst.into());
-                    map.entry(fp).or_default().push(impl_id);
+                    for (_, block_def_map) in body.blocks(db.upcast()) {
+                        collect_def_map(db, &block_def_map, impls);
+                    }
                }
            }
        }
-        // NOTE: We're not collecting inherent impls from unnamed consts here, we intentionally only
-        // support trait impls there.
-        Arc::new(Self { map })
    }
    pub fn for_self_ty(&self, self_ty: &Ty) -> &[ImplId] {
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index 4b2c82b41..a4c132bc5 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -1294,7 +1294,7 @@ mod b {
 }
 #[test]
-fn impl_in_unnamed_const() {
+fn trait_impl_in_unnamed_const() {
    check_types(
        r#"
 struct S;
@@ -1314,3 +1314,38 @@ fn f() {
    "#,
    );
 }
+#[test]
+fn inherent_impl_in_unnamed_const() {
+    check_types(
+        r#"
+struct S;
+const _: () = {
+    impl S {
+        fn method(&self) -> u16 { 0 }
+        pub(super) fn super_method(&self) -> u16 { 0 }
+        pub(crate) fn crate_method(&self) -> u16 { 0 }
+        pub fn pub_method(&self) -> u16 { 0 }
+    }
+};
+fn f() {
+    S.method();
+  //^^^^^^^^^^ u16
+    S.super_method();
+  //^^^^^^^^^^^^^^^^ u16
+    S.crate_method();
+  //^^^^^^^^^^^^^^^^ u16
+    S.pub_method();
+  //^^^^^^^^^^^^^^ u16
+}
+    "#,
+    );
+}
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 84c5c05fd..5948d0bc2 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -1765,6 +1765,24 @@ fn main() {
 }
 #[test]
+fn shadowing_primitive_with_inner_items() {
+    check_types(
+        r#"
+struct i32;
+struct Foo;
+impl i32 { fn foo(&self) -> Foo { Foo } }
+fn main() {
+    fn inner() {}
+    let x: i32 = i32;
+    x.foo();
+        //^ Foo
+}"#,
+    );
+}
+#[test]
 fn not_shadowing_primitive_by_module() {
    check_types(
        r#"
diff --git a/crates/hir_ty/src/utils.rs b/crates/hir_ty/src/utils.rs
index 5f6cb052a..2f04ee57a 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -78,7 +78,7 @@ fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef) -> Vec<Tr
 /// Returns an iterator over the whole super trait hierarchy (including the
 /// trait itself).
-pub(super) fn all_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
+pub fn all_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
    // we need to take care a bit here to avoid infinite loops in case of cycles
    // (i.e. if we have `trait A: B; trait B: A;`)
    let mut result = vec![trait_];
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 0ace80a1e..1c911a8b2 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -25,7 +25,7 @@ use syntax::{
 use text_edit::TextEdit;
 use unlinked_file::UnlinkedFile;
-use crate::{FileId, Label, SourceChange};
+use crate::{Assist, AssistId, AssistKind, FileId, Label, SourceChange};
 use self::fixes::DiagnosticWithFix;
@@ -35,7 +35,7 @@ pub struct Diagnostic {
    pub message: String,
    pub range: TextRange,
    pub severity: Severity,
-    pub fix: Option<Fix>,
+    pub fix: Option<Assist>,
    pub unused: bool,
    pub code: Option<DiagnosticCode>,
 }
@@ -56,7 +56,7 @@ impl Diagnostic {
        }
    }
-    fn with_fix(self, fix: Option<Fix>) -> Self {
+    fn with_fix(self, fix: Option<Assist>) -> Self {
        Self { fix, ..self }
    }
@@ -69,21 +69,6 @@ impl Diagnostic {
    }
 }
-#[derive(Debug)]
-pub struct Fix {
-    pub label: Label,
-    pub source_change: SourceChange,
-    /// Allows to trigger the fix only when the caret is in the range given
-    pub fix_trigger_range: TextRange,
-}
-impl Fix {
-    fn new(label: &str, source_change: SourceChange, fix_trigger_range: TextRange) -> Self {
-        let label = Label::new(label);
-        Self { label, source_change, fix_trigger_range }
-    }
-}
 #[derive(Debug, Copy, Clone)]
 pub enum Severity {
    Error,
@@ -99,6 +84,7 @@ pub struct DiagnosticsConfig {
 pub(crate) fn diagnostics(
    db: &RootDatabase,
    config: &DiagnosticsConfig,
+    resolve: bool,
    file_id: FileId,
 ) -> Vec<Diagnostic> {
    let _p = profile::span("diagnostics");
@@ -122,25 +108,25 @@ pub(crate) fn diagnostics(
    let res = RefCell::new(res);
    let sink_builder = DiagnosticSinkBuilder::new()
        .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::MissingFields, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::MissingOkOrSomeInTailExpr, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::NoSuchField, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::RemoveThisSemicolon, _>(|d| {
-            res.borrow_mut().push(diagnostic_with_fix(d, &sema));
+            res.borrow_mut().push(diagnostic_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::IncorrectCase, _>(|d| {
-            res.borrow_mut().push(warning_with_fix(d, &sema));
+            res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::ReplaceFilterMapNextWithFindMap, _>(|d| {
-            res.borrow_mut().push(warning_with_fix(d, &sema));
+            res.borrow_mut().push(warning_with_fix(d, &sema, resolve));
        })
        .on::<hir::diagnostics::InactiveCode, _>(|d| {
            // If there's inactive code somewhere in a macro, don't propagate to the call-site.
@@ -167,7 +153,7 @@ pub(crate) fn diagnostics(
            // Override severity and mark as unused.
            res.borrow_mut().push(
                Diagnostic::hint(range, d.message())
-                    .with_fix(d.fix(&sema))
+                    .with_fix(d.fix(&sema, resolve))
                    .with_code(Some(d.code())),
            );
        })
@@ -223,15 +209,23 @@ pub(crate) fn diagnostics(
    res.into_inner()
 }
-fn diagnostic_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
+fn diagnostic_with_fix<D: DiagnosticWithFix>(
+    d: &D,
+    sema: &Semantics<RootDatabase>,
+    resolve: bool,
+) -> Diagnostic {
    Diagnostic::error(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fix(d.fix(&sema))
+        .with_fix(d.fix(&sema, resolve))
        .with_code(Some(d.code()))
 }
-fn warning_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
+fn warning_with_fix<D: DiagnosticWithFix>(
+    d: &D,
+    sema: &Semantics<RootDatabase>,
+    resolve: bool,
+) -> Diagnostic {
    Diagnostic::hint(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fix(d.fix(&sema))
+        .with_fix(d.fix(&sema, resolve))
        .with_code(Some(d.code()))
 }
@@ -261,7 +255,8 @@ fn check_unnecessary_braces_in_use_statement(
        acc.push(
            Diagnostic::hint(use_range, "Unnecessary braces in use statement".to_string())
-                .with_fix(Some(Fix::new(
+                .with_fix(Some(fix(
+                    "remove_braces",
                    "Remove unnecessary braces",
                    SourceChange::from_text_edit(file_id, edit),
                    use_range,
@@ -284,6 +279,23 @@ fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
    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, Expect};
@@ -302,16 +314,17 @@ mod tests {
        let (analysis, file_position) = fixture::position(ra_fixture_before);
        let diagnostic = analysis
-            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .diagnostics(&DiagnosticsConfig::default(), true, file_position.file_id)
            .unwrap()
            .pop()
            .unwrap();
        let fix = diagnostic.fix.unwrap();
        let actual = {
-            let file_id = *fix.source_change.source_file_edits.keys().next().unwrap();
+            let source_change = fix.source_change.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 fix.source_change.source_file_edits.values() {
+            for edit in source_change.source_file_edits.values() {
                edit.apply(&mut actual);
            }
            actual
@@ -319,9 +332,9 @@ mod tests {
        assert_eq_text!(&after, &actual);
        assert!(
-            fix.fix_trigger_range.contains_inclusive(file_position.offset),
+            fix.target.contains_inclusive(file_position.offset),
            "diagnostic fix range {:?} does not touch cursor position {:?}",
-            fix.fix_trigger_range,
+            fix.target,
            file_position.offset
        );
    }
@@ -330,7 +343,7 @@ mod tests {
    fn check_no_fix(ra_fixture: &str) {
        let (analysis, file_position) = fixture::position(ra_fixture);
        let diagnostic = analysis
-            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .diagnostics(&DiagnosticsConfig::default(), true, file_position.file_id)
            .unwrap()
            .pop()
            .unwrap();
@@ -344,7 +357,7 @@ mod tests {
        let diagnostics = files
            .into_iter()
            .flat_map(|file_id| {
-                analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap()
+                analysis.diagnostics(&DiagnosticsConfig::default(), true, file_id).unwrap()
            })
            .collect::<Vec<_>>();
        assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
@@ -352,7 +365,8 @@ mod tests {
    fn check_expect(ra_fixture: &str, expect: Expect) {
        let (analysis, file_id) = fixture::file(ra_fixture);
-        let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
+        let diagnostics =
+            analysis.diagnostics(&DiagnosticsConfig::default(), true, file_id).unwrap();
        expect.assert_debug_eq(&diagnostics)
    }
@@ -665,24 +679,31 @@ fn test_fn() {
                        range: 0..8,
                        severity: Error,
                        fix: Some(
-                            Fix {
+                            Assist {
+                                id: AssistId(
+                                    "create_module",
+                                    QuickFix,
+                                ),
                                label: "Create module",
-                                source_change: SourceChange {
+                                group: None,
-                                    source_file_edits: {},
+                                target: 0..8,
-                                    file_system_edits: [
+                                source_change: Some(
-                                        CreateFile {
+                                    SourceChange {
-                                            dst: AnchoredPathBuf {
+                                        source_file_edits: {},
-                                                anchor: FileId(
+                                        file_system_edits: [
-                                                    0,
+                                            CreateFile {
-                                                ),
+                                                dst: AnchoredPathBuf {
-                                                path: "foo.rs",
+                                                    anchor: FileId(
+                                                        0,
+                                                    ),
+                                                    path: "foo.rs",
+                                                },
+                                                initial_contents: "",
                                            },
-                                            initial_contents: "",
+                                        ],
-                                        },
+                                        is_snippet: false,
-                                    ],
+                                    },
-                                    is_snippet: false,
+                                ),
-                                },
-                                fix_trigger_range: 0..8,
                            },
                        ),
                        unused: false,
@@ -704,7 +725,7 @@ fn test_fn() {
            expect![[r#"
                [
                    Diagnostic {
-                        message: "unresolved macro call",
+                        message: "unresolved macro `foo::bar!`",
                        range: 5..8,
                        severity: Error,
                        fix: None,
@@ -890,10 +911,11 @@ struct Foo {
        let (analysis, file_id) = fixture::file(r#"mod foo;"#);
-        let diagnostics = analysis.diagnostics(&config, file_id).unwrap();
+        let diagnostics = analysis.diagnostics(&config, true, file_id).unwrap();
        assert!(diagnostics.is_empty());
-        let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
+        let diagnostics =
+            analysis.diagnostics(&DiagnosticsConfig::default(), true, file_id).unwrap();
        assert!(!diagnostics.is_empty());
    }
@@ -999,8 +1021,9 @@ impl TestStruct {
        let expected = r#"fn foo() {}"#;
        let (analysis, file_position) = fixture::position(input);
-        let diagnostics =
+        let diagnostics = analysis
-            analysis.diagnostics(&DiagnosticsConfig::default(), file_position.file_id).unwrap();
+            .diagnostics(&DiagnosticsConfig::default(), true, file_position.file_id)
+            .unwrap();
        assert_eq!(diagnostics.len(), 1);
        check_fix(input, expected);
diff --git a/crates/ide/src/diagnostics/field_shorthand.rs b/crates/ide/src/diagnostics/field_shorthand.rs
index 5c89e2170..2b1787f9b 100644
--- a/crates/ide/src/diagnostics/field_shorthand.rs
+++ b/crates/ide/src/diagnostics/field_shorthand.rs
@@ -5,7 +5,7 @@ use ide_db::{base_db::FileId, source_change::SourceChange};
 use syntax::{ast, match_ast, AstNode, SyntaxNode};
 use text_edit::TextEdit;
-use crate::{Diagnostic, Fix};
+use crate::{diagnostics::fix, Diagnostic};
 pub(super) fn check(acc: &mut Vec<Diagnostic>, file_id: FileId, node: &SyntaxNode) {
    match_ast! {
@@ -47,7 +47,8 @@ fn check_expr_field_shorthand(
        let field_range = record_field.syntax().text_range();
        acc.push(
            Diagnostic::hint(field_range, "Shorthand struct initialization".to_string()).with_fix(
-                Some(Fix::new(
+                Some(fix(
+                    "use_expr_field_shorthand",
                    "Use struct shorthand initialization",
                    SourceChange::from_text_edit(file_id, edit),
                    field_range,
@@ -86,7 +87,8 @@ fn check_pat_field_shorthand(
        let field_range = record_pat_field.syntax().text_range();
        acc.push(Diagnostic::hint(field_range, "Shorthand struct pattern".to_string()).with_fix(
-            Some(Fix::new(
+            Some(fix(
+                "use_pat_field_shorthand",
                "Use struct field shorthand",
                SourceChange::from_text_edit(file_id, edit),
                field_range,
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 5fb3e2d91..7be8b3459 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -20,20 +20,30 @@ use syntax::{
 };
 use text_edit::TextEdit;
-use crate::{diagnostics::Fix, references::rename::rename_with_semantics, FilePosition};
+use crate::{
+    diagnostics::{fix, unresolved_fix},
+    references::rename::rename_with_semantics,
+    Assist, FilePosition,
+};
 /// A [Diagnostic] that potentially has a fix available.
 ///
 /// [Diagnostic]: hir::diagnostics::Diagnostic
 pub(crate) trait DiagnosticWithFix: Diagnostic {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix>;
+    /// `resolve` determines if the diagnostic should fill in the `edit` field
+    /// of the assist.
+    ///
+    /// If `resolve` is false, the edit will be computed later, on demand, and
+    /// can be omitted.
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist>;
 }
 impl DiagnosticWithFix for UnresolvedModule {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let unresolved_module = self.decl.to_node(&root);
-        Some(Fix::new(
+        Some(fix(
+            "create_module",
            "Create module",
            FileSystemEdit::CreateFile {
                dst: AnchoredPathBuf {
@@ -49,7 +59,7 @@ impl DiagnosticWithFix for UnresolvedModule {
 }
 impl DiagnosticWithFix for NoSuchField {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        missing_record_expr_field_fix(
            &sema,
@@ -60,7 +70,7 @@ impl DiagnosticWithFix for NoSuchField {
 }
 impl DiagnosticWithFix for MissingFields {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        // Note that although we could add a diagnostics to
        // fill the missing tuple field, e.g :
        // `struct A(usize);`
@@ -86,7 +96,8 @@ impl DiagnosticWithFix for MissingFields {
                .into_text_edit(&mut builder);
            builder.finish()
        };
-        Some(Fix::new(
+        Some(fix(
+            "fill_missing_fields",
            "Fill struct fields",
            SourceChange::from_text_edit(self.file.original_file(sema.db), edit),
            sema.original_range(&field_list_parent.syntax()).range,
@@ -95,7 +106,7 @@ impl DiagnosticWithFix for MissingFields {
 }
 impl DiagnosticWithFix for MissingOkOrSomeInTailExpr {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let tail_expr = self.expr.to_node(&root);
        let tail_expr_range = tail_expr.syntax().text_range();
@@ -103,12 +114,12 @@ impl DiagnosticWithFix for MissingOkOrSomeInTailExpr {
        let edit = TextEdit::replace(tail_expr_range, replacement);
        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
        let name = if self.required == "Ok" { "Wrap with Ok" } else { "Wrap with Some" };
-        Some(Fix::new(name, source_change, tail_expr_range))
+        Some(fix("wrap_tail_expr", name, source_change, tail_expr_range))
    }
 }
 impl DiagnosticWithFix for RemoveThisSemicolon {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let semicolon = self
@@ -123,12 +134,12 @@ impl DiagnosticWithFix for RemoveThisSemicolon {
        let edit = TextEdit::delete(semicolon);
        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-        Some(Fix::new("Remove this semicolon", source_change, semicolon))
+        Some(fix("remove_semicolon", "Remove this semicolon", source_change, semicolon))
    }
 }
 impl DiagnosticWithFix for IncorrectCase {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let name_node = self.ident.to_node(&root);
@@ -136,16 +147,19 @@ impl DiagnosticWithFix for IncorrectCase {
        let frange = name_node.original_file_range(sema.db);
        let file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
-        let rename_changes =
-            rename_with_semantics(sema, file_position, &self.suggested_text).ok()?;
        let label = format!("Rename to {}", self.suggested_text);
-        Some(Fix::new(&label, rename_changes, frange.range))
+        let mut res = unresolved_fix("change_case", &label, frange.range);
+        if resolve {
+            let source_change = rename_with_semantics(sema, file_position, &self.suggested_text);
+            res.source_change = Some(source_change.ok().unwrap_or_default());
+        }
+        Some(res)
    }
 }
 impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap {
-    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        let root = sema.db.parse_or_expand(self.file)?;
        let next_expr = self.next_expr.to_node(&root);
        let next_call = ast::MethodCallExpr::cast(next_expr.syntax().clone())?;
@@ -163,7 +177,8 @@ impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap {
        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-        Some(Fix::new(
+        Some(fix(
+            "replace_with_find_map",
            "Replace filter_map(..).next() with find_map()",
            source_change,
            trigger_range,
@@ -175,7 +190,7 @@ fn missing_record_expr_field_fix(
    sema: &Semantics<RootDatabase>,
    usage_file_id: FileId,
    record_expr_field: &ast::RecordExprField,
-) -> Option<Fix> {
+) -> Option<Assist> {
    let record_lit = ast::RecordExpr::cast(record_expr_field.syntax().parent()?.parent()?)?;
    let def_id = sema.resolve_variant(record_lit)?;
    let module;
@@ -233,7 +248,12 @@ fn missing_record_expr_field_fix(
        def_file_id,
        TextEdit::insert(last_field_syntax.text_range().end(), new_field),
    );
-    return Some(Fix::new("Create field", source_change, record_expr_field.syntax().text_range()));
+    return Some(fix(
+        "create_field",
+        "Create field",
+        source_change,
+        record_expr_field.syntax().text_range(),
+    ));
    fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> {
        match field_def_list {
diff --git a/crates/ide/src/diagnostics/unlinked_file.rs b/crates/ide/src/diagnostics/unlinked_file.rs
index e174fb767..7d39f4fbe 100644
--- a/crates/ide/src/diagnostics/unlinked_file.rs
+++ b/crates/ide/src/diagnostics/unlinked_file.rs
@@ -16,9 +16,10 @@ use syntax::{
 };
 use text_edit::TextEdit;
-use crate::Fix;
+use crate::{
+    diagnostics::{fix, fixes::DiagnosticWithFix},
-use super::fixes::DiagnosticWithFix;
+    Assist,
+};
 // Diagnostic: unlinked-file
 //
@@ -49,7 +50,7 @@ impl Diagnostic for UnlinkedFile {
 }
 impl DiagnosticWithFix for UnlinkedFile {
-    fn fix(&self, sema: &hir::Semantics<RootDatabase>) -> Option<Fix> {
+    fn fix(&self, sema: &hir::Semantics<RootDatabase>, _resolve: bool) -> Option<Assist> {
        // If there's an existing module that could add a `mod` item to include the unlinked file,
        // suggest that as a fix.
@@ -100,7 +101,7 @@ fn make_fix(
    parent_file_id: FileId,
    new_mod_name: &str,
    added_file_id: FileId,
-) -> Option<Fix> {
+) -> Option<Assist> {
    fn is_outline_mod(item: &ast::Item) -> bool {
        matches!(item, ast::Item::Module(m) if m.item_list().is_none())
    }
@@ -152,7 +153,8 @@ fn make_fix(
    let edit = builder.finish();
    let trigger_range = db.parse(added_file_id).tree().syntax().text_range();
-    Some(Fix::new(
+    Some(fix(
+        "add_mod_declaration",
        &format!("Insert `{}`", mod_decl),
        SourceChange::from_text_edit(parent_file_id, edit),
        trigger_range,
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index d057d5402..a04333e63 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -110,6 +110,13 @@ mod tests {
        assert_eq!(expected, FileRange { file_id: nav.file_id, range: nav.focus_or_full_range() });
    }
+    fn check_unresolved(ra_fixture: &str) {
+        let (analysis, position) = fixture::position(ra_fixture);
+        let navs = analysis.goto_definition(position).unwrap().expect("no definition found").info;
+        assert!(navs.is_empty(), "didn't expect this to resolve anywhere: {:?}", navs)
+    }
    #[test]
    fn goto_def_for_extern_crate() {
        check(
@@ -927,17 +934,12 @@ fn f() -> impl Iterator<Item$0 = u8> {}
    }
    #[test]
-    #[should_panic = "unresolved reference"]
    fn unknown_assoc_ty() {
-        check(
+        check_unresolved(
            r#"
-trait Iterator {
+trait Iterator { type Item; }
-    type Item;
-       //^^^^
-}
 fn f() -> impl Iterator<Invalid$0 = u8> {}
-            "#,
+"#,
        )
    }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 3f73c0632..b24c664ba 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -69,7 +69,7 @@ use crate::display::ToNav;
 pub use crate::{
    annotations::{Annotation, AnnotationConfig, AnnotationKind},
    call_hierarchy::CallItem,
-    diagnostics::{Diagnostic, DiagnosticsConfig, Fix, Severity},
+    diagnostics::{Diagnostic, DiagnosticsConfig, Severity},
    display::navigation_target::NavigationTarget,
    expand_macro::ExpandedMacro,
    file_structure::{StructureNode, StructureNodeKind},
@@ -82,7 +82,7 @@ pub use crate::{
    references::{rename::RenameError, ReferenceSearchResult},
    runnables::{Runnable, RunnableKind, TestId},
    syntax_highlighting::{
-        tags::{Highlight, HlMod, HlMods, HlPunct, HlTag},
+        tags::{Highlight, HlMod, HlMods, HlOperator, HlPunct, HlTag},
        HlRange,
    },
 };
@@ -526,9 +526,39 @@ impl Analysis {
    pub fn diagnostics(
        &self,
        config: &DiagnosticsConfig,
+        resolve: bool,
        file_id: FileId,
    ) -> Cancelable<Vec<Diagnostic>> {
-        self.with_db(|db| diagnostics::diagnostics(db, config, file_id))
+        self.with_db(|db| diagnostics::diagnostics(db, config, resolve, file_id))
+    }
+    /// Convenience function to return assists + quick fixes for diagnostics
+    pub fn assists_with_fixes(
+        &self,
+        assist_config: &AssistConfig,
+        diagnostics_config: &DiagnosticsConfig,
+        resolve: bool,
+        frange: FileRange,
+    ) -> Cancelable<Vec<Assist>> {
+        let include_fixes = match &assist_config.allowed {
+            Some(it) => it.iter().any(|&it| it == AssistKind::None || it == AssistKind::QuickFix),
+            None => true,
+        };
+        self.with_db(|db| {
+            let mut res = Assist::get(db, assist_config, resolve, frange);
+            ssr::add_ssr_assist(db, &mut res, resolve, frange);
+            if include_fixes {
+                res.extend(
+                    diagnostics::diagnostics(db, diagnostics_config, resolve, frange.file_id)
+                        .into_iter()
+                        .filter_map(|it| it.fix)
+                        .filter(|it| it.target.intersect(frange.range).is_some()),
+                );
+            }
+            res
+        })
    }
    /// Returns the edit required to rename reference at the position to the new
diff --git a/crates/ide/src/move_item.rs b/crates/ide/src/move_item.rs
index 8d37f4f92..246f10a0a 100644
--- a/crates/ide/src/move_item.rs
+++ b/crates/ide/src/move_item.rs
@@ -1,4 +1,4 @@
-use std::iter::once;
+use std::{iter::once, mem};
 use hir::Semantics;
 use ide_db::{base_db::FileRange, RootDatabase};
@@ -102,7 +102,7 @@ fn move_in_direction(
            ast::GenericArgList(it) => swap_sibling_in_list(node, it.generic_args(), range, direction),
            ast::VariantList(it) => swap_sibling_in_list(node, it.variants(), range, direction),
            ast::TypeBoundList(it) => swap_sibling_in_list(node, it.bounds(), range, direction),
-            _ => Some(replace_nodes(node, &match direction {
+            _ => Some(replace_nodes(range, node, &match direction {
                Direction::Up => node.prev_sibling(),
                Direction::Down => node.next_sibling(),
            }?))
@@ -125,7 +125,7 @@ fn swap_sibling_in_list<A: AstNode + Clone, I: Iterator<Item = A>>(
        .next();
    if let Some((l, r)) = list_lookup {
-        Some(replace_nodes(l.syntax(), r.syntax()))
+        Some(replace_nodes(range, l.syntax(), r.syntax()))
    } else {
        // Cursor is beyond any movable list item (for example, on curly brace in enum).
        // It's not necessary, that parent of list is movable (arg list's parent is not, for example),
@@ -134,11 +134,38 @@ fn swap_sibling_in_list<A: AstNode + Clone, I: Iterator<Item = A>>(
    }
 }
-fn replace_nodes(first: &SyntaxNode, second: &SyntaxNode) -> TextEdit {
+fn replace_nodes<'a>(
+    range: TextRange,
+    mut first: &'a SyntaxNode,
+    mut second: &'a SyntaxNode,
+) -> TextEdit {
+    let cursor_offset = if range.is_empty() {
+        // FIXME: `applySnippetTextEdits` does not support non-empty selection ranges
+        if first.text_range().contains_range(range) {
+            Some(range.start() - first.text_range().start())
+        } else if second.text_range().contains_range(range) {
+            mem::swap(&mut first, &mut second);
+            Some(range.start() - first.text_range().start())
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+    let first_with_cursor = match cursor_offset {
+        Some(offset) => {
+            let mut item_text = first.text().to_string();
+            item_text.insert_str(offset.into(), "$0");
+            item_text
+        }
+        None => first.text().to_string(),
+    };
    let mut edit = TextEditBuilder::default();
    algo::diff(first, second).into_text_edit(&mut edit);
-    algo::diff(second, first).into_text_edit(&mut edit);
+    edit.replace(second.text_range(), first_with_cursor);
    edit.finish()
 }
@@ -188,7 +215,7 @@ fn main() {
            expect![[r#"
 fn main() {
    match true {
-        false => {
+        false =>$0 {
            println!("Test");
        },
        true => {
@@ -222,7 +249,7 @@ fn main() {
        false => {
            println!("Test");
        },
-        true => {
+        true =>$0 {
            println!("Hello, world");
        }
    };
@@ -274,7 +301,7 @@ fn main() {
            "#,
            expect![[r#"
 fn main() {
-    let test2 = 456;
+    let test2$0 = 456;
    let test = 123;
 }
            "#]],
@@ -293,7 +320,7 @@ fn main() {
            "#,
            expect![[r#"
 fn main() {
-    println!("All I want to say is...");
+    println!("All I want to say is...");$0
    println!("Hello, world");
 }
            "#]],
@@ -313,7 +340,7 @@ fn main() {
 fn main() {
    if true {
        println!("Test");
-    }
+    }$0
    println!("Hello, world");
 }
@@ -334,7 +361,7 @@ fn main() {
 fn main() {
    for i in 0..10 {
        println!("Test");
-    }
+    }$0
    println!("Hello, world");
 }
@@ -355,7 +382,7 @@ fn main() {
 fn main() {
    loop {
        println!("Test");
-    }
+    }$0
    println!("Hello, world");
 }
@@ -376,7 +403,7 @@ fn main() {
 fn main() {
    while true {
        println!("Test");
-    }
+    }$0
    println!("Hello, world");
 }
@@ -393,7 +420,7 @@ fn main() {
            "#,
            expect![[r#"
 fn main() {
-    return 123;
+    return 123;$0
    println!("Hello, world");
 }
@@ -430,7 +457,7 @@ fn main() {}
 fn foo() {}$0$0
            "#,
            expect![[r#"
-fn foo() {}
+fn foo() {}$0
 fn main() {}
            "#]],
@@ -451,7 +478,7 @@ impl Wow for Yay $0$0{}
            expect![[r#"
 struct Yay;
-impl Wow for Yay {}
+impl Wow for Yay $0{}
 trait Wow {}
            "#]],
@@ -467,7 +494,7 @@ use std::vec::Vec;
 use std::collections::HashMap$0$0;
            "#,
            expect![[r#"
-use std::collections::HashMap;
+use std::collections::HashMap$0;
 use std::vec::Vec;
            "#]],
            Direction::Up,
@@ -502,7 +529,7 @@ fn main() {
    }
    #[test]
-    fn test_moves_param_up() {
+    fn test_moves_param() {
        check(
            r#"
 fn test(one: i32, two$0$0: u32) {}
@@ -512,7 +539,7 @@ fn main() {
 }
            "#,
            expect![[r#"
-fn test(two: u32, one: i32) {}
+fn test(two$0: u32, one: i32) {}
 fn main() {
    test(123, 456);
@@ -520,6 +547,15 @@ fn main() {
            "#]],
            Direction::Up,
        );
+        check(
+            r#"
+fn f($0$0arg: u8, arg2: u16) {}
+            "#,
+            expect![[r#"
+fn f(arg2: u16, $0arg: u8) {}
+            "#]],
+            Direction::Down,
+        );
    }
    #[test]
@@ -536,7 +572,7 @@ fn main() {
 fn test(one: i32, two: u32) {}
 fn main() {
-    test(456, 123);
+    test(456$0, 123);
 }
            "#]],
            Direction::Up,
@@ -557,7 +593,7 @@ fn main() {
 fn test(one: i32, two: u32) {}
 fn main() {
-    test(456, 123);
+    test(456, 123$0);
 }
            "#]],
            Direction::Down,
@@ -594,7 +630,7 @@ struct Test<A, B$0$0>(A, B);
 fn main() {}
            "#,
            expect![[r#"
-struct Test<B, A>(A, B);
+struct Test<B$0, A>(A, B);
 fn main() {}
            "#]],
@@ -616,7 +652,7 @@ fn main() {
 struct Test<A, B>(A, B);
 fn main() {
-    let t = Test::<&str, i32>(123, "yay");
+    let t = Test::<&str$0, i32>(123, "yay");
 }
            "#]],
            Direction::Up,
@@ -636,7 +672,7 @@ fn main() {}
            "#,
            expect![[r#"
 enum Hello {
-    Two,
+    Two$0,
    One
 }
@@ -663,7 +699,7 @@ trait One {}
 trait Two {}
-fn test<T: Two + One>(t: T) {}
+fn test<T: Two$0 + One>(t: T) {}
 fn main() {}
            "#]],
@@ -709,7 +745,7 @@ trait Yay {
 impl Yay for Test {
    type One = i32;
-    fn inner() {
+    fn inner() {$0
        println!("Mmmm");
    }
@@ -736,7 +772,7 @@ fn test() {
            "#,
            expect![[r#"
 fn test() {
-    mod hi {
+    mod hi {$0
        fn inner() {}
    }
@@ -764,7 +800,7 @@ fn main() {}
            expect![[r#"
 fn main() {}
-#[derive(Debug)]
+$0#[derive(Debug)]
 enum FooBar {
    Foo,
    Bar,
@@ -784,7 +820,7 @@ fn main() {}
            expect![[r#"
 fn main() {}
-enum FooBar {
+$0enum FooBar {
    Foo,
    Bar,
 }
@@ -804,7 +840,7 @@ fn main() {}
            expect![[r#"
 struct Test;
-impl SomeTrait for Test {}
+$0impl SomeTrait for Test {}
 trait SomeTrait {}
@@ -831,7 +867,7 @@ fn main() {}
 enum FooBar {
    Foo,
    Bar,
-}
+}$0
            "#]],
            Direction::Down,
        );
@@ -848,7 +884,7 @@ fn main() {}
            expect![[r#"
 struct Test;
-impl SomeTrait for Test {}
+impl SomeTrait for Test {}$0
 trait SomeTrait {}
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index e921784bf..8cc877c1c 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -12,7 +12,10 @@ use syntax::{
    SyntaxNode, SyntaxToken, T,
 };
-use crate::{syntax_highlighting::tags::HlPunct, Highlight, HlMod, HlTag};
+use crate::{
+    syntax_highlighting::tags::{HlOperator, HlPunct},
+    Highlight, HlMod, HlTag,
+};
 pub(super) fn element(
    sema: &Semantics<RootDatabase>,
@@ -132,7 +135,7 @@ pub(super) fn element(
        INT_NUMBER | FLOAT_NUMBER => HlTag::NumericLiteral.into(),
        BYTE => HlTag::ByteLiteral.into(),
        CHAR => HlTag::CharLiteral.into(),
-        QUESTION => Highlight::new(HlTag::Operator) | HlMod::ControlFlow,
+        QUESTION => Highlight::new(HlTag::Operator(HlOperator::Other)) | HlMod::ControlFlow,
        LIFETIME => {
            let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
@@ -146,8 +149,11 @@ pub(super) fn element(
            }
        }
        p if p.is_punct() => match p {
+            T![&] if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+                HlTag::Operator(HlOperator::Bitwise).into()
+            }
            T![&] => {
-                let h = HlTag::Operator.into();
+                let h = HlTag::Operator(HlOperator::Other).into();
                let is_unsafe = element
                    .parent()
                    .and_then(ast::RefExpr::cast)
@@ -159,13 +165,18 @@ pub(super) fn element(
                    h
                }
            }
-            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => HlTag::Operator.into(),
+            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => {
+                HlTag::Operator(HlOperator::Other).into()
+            }
            T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
                HlTag::Symbol(SymbolKind::Macro).into()
            }
            T![!] if element.parent().and_then(ast::NeverType::cast).is_some() => {
                HlTag::BuiltinType.into()
            }
+            T![!] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
+                HlTag::Operator(HlOperator::Logical).into()
+            }
            T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
                HlTag::Keyword.into()
            }
@@ -175,9 +186,9 @@ pub(super) fn element(
                let expr = prefix_expr.expr()?;
                let ty = sema.type_of_expr(&expr)?;
                if ty.is_raw_ptr() {
-                    HlTag::Operator | HlMod::Unsafe
+                    HlTag::Operator(HlOperator::Other) | HlMod::Unsafe
                } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
-                    HlTag::Operator.into()
+                    HlTag::Operator(HlOperator::Other).into()
                } else {
                    HlTag::Punctuation(HlPunct::Other).into()
                }
@@ -188,19 +199,43 @@ pub(super) fn element(
                let expr = prefix_expr.expr()?;
                match expr {
                    ast::Expr::Literal(_) => HlTag::NumericLiteral,
-                    _ => HlTag::Operator,
+                    _ => HlTag::Operator(HlOperator::Other),
                }
                .into()
            }
            _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
-                HlTag::Operator.into()
+                HlTag::Operator(HlOperator::Other).into()
+            }
+            T![+] | T![-] | T![*] | T![/] | T![+=] | T![-=] | T![*=] | T![/=]
+                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+            {
+                HlTag::Operator(HlOperator::Arithmetic).into()
+            }
+            T![|] | T![&] | T![!] | T![^] | T![|=] | T![&=] | T![^=]
+                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+            {
+                HlTag::Operator(HlOperator::Bitwise).into()
+            }
+            T![&&] | T![||] if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+                HlTag::Operator(HlOperator::Logical).into()
+            }
+            T![>] | T![<] | T![==] | T![>=] | T![<=] | T![!=]
+                if element.parent().and_then(ast::BinExpr::cast).is_some() =>
+            {
+                HlTag::Operator(HlOperator::Comparision).into()
+            }
+            _ if element.parent().and_then(ast::BinExpr::cast).is_some() => {
+                HlTag::Operator(HlOperator::Other).into()
            }
-            _ if element.parent().and_then(ast::BinExpr::cast).is_some() => HlTag::Operator.into(),
            _ if element.parent().and_then(ast::RangeExpr::cast).is_some() => {
-                HlTag::Operator.into()
+                HlTag::Operator(HlOperator::Other).into()
+            }
+            _ if element.parent().and_then(ast::RangePat::cast).is_some() => {
+                HlTag::Operator(HlOperator::Other).into()
+            }
+            _ if element.parent().and_then(ast::RestPat::cast).is_some() => {
+                HlTag::Operator(HlOperator::Other).into()
            }
-            _ if element.parent().and_then(ast::RangePat::cast).is_some() => HlTag::Operator.into(),
-            _ if element.parent().and_then(ast::RestPat::cast).is_some() => HlTag::Operator.into(),
            _ if element.parent().and_then(ast::Attr::cast).is_some() => HlTag::Attribute.into(),
            kind => HlTag::Punctuation(match kind {
                T!['['] | T![']'] => HlPunct::Bracket,
diff --git a/crates/ide/src/syntax_highlighting/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
index 04fafd244..855c7fba8 100644
--- a/crates/ide/src/syntax_highlighting/inject.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -90,6 +90,13 @@ const RUSTDOC_FENCE_TOKENS: &[&'static str] = &[
    "edition2021",
 ];
+fn is_rustdoc_fence_token(token: &str) -> bool {
+    if RUSTDOC_FENCE_TOKENS.contains(&token) {
+        return true;
+    }
+    token.starts_with('E') && token.len() == 5 && token[1..].parse::<u32>().is_ok()
+}
 /// Injection of syntax highlighting of doctests.
 pub(super) fn doc_comment(
    hl: &mut Highlights,
@@ -174,8 +181,7 @@ pub(super) fn doc_comment(
                    is_codeblock = !is_codeblock;
                    // Check whether code is rust by inspecting fence guards
                    let guards = &line[idx + RUSTDOC_FENCE.len()..];
-                    let is_rust =
+                    let is_rust = guards.split(',').all(|sub| is_rustdoc_fence_token(sub.trim()));
-                        guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
                    is_doctest = is_codeblock && is_rust;
                    continue;
                }
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index 1cec991aa..8128d231d 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -28,7 +28,7 @@ pub enum HlTag {
    FormatSpecifier,
    Keyword,
    NumericLiteral,
-    Operator,
+    Operator(HlOperator),
    Punctuation(HlPunct),
    StringLiteral,
    UnresolvedReference,
@@ -87,6 +87,20 @@ pub enum HlPunct {
    Other,
 }
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum HlOperator {
+    /// |, &, !, ^, |=, &=, ^=
+    Bitwise,
+    /// +, -, *, /, +=, -=, *=, /=
+    Arithmetic,
+    /// &&, ||, !
+    Logical,
+    /// >, <, ==, >=, <=, !=
+    Comparision,
+    ///
+    Other,
+}
 impl HlTag {
    fn as_str(self) -> &'static str {
        match self {
@@ -133,7 +147,13 @@ impl HlTag {
                HlPunct::Other => "punctuation",
            },
            HlTag::NumericLiteral => "numeric_literal",
-            HlTag::Operator => "operator",
+            HlTag::Operator(op) => match op {
+                HlOperator::Bitwise => "bitwise",
+                HlOperator::Arithmetic => "arithmetic",
+                HlOperator::Logical => "logical",
+                HlOperator::Comparision => "comparision",
+                HlOperator::Other => "operator",
+            },
            HlTag::StringLiteral => "string_literal",
            HlTag::UnresolvedReference => "unresolved_reference",
            HlTag::None => "none",
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 b6d1cac4e..6ee6d85fb 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -76,7 +76,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment documentation">/// </span><span class="comment injected">// calls bar on foo</span>
    <span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="parenthesis injected">(</span><span class="none injected">foo</span><span class="operator injected">.</span><span class="none injected">bar</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
    <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">bar</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="none injected"> </span><span class="operator injected">||</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="semicolon injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">bar</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="none injected"> </span><span class="logical injected">||</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="semicolon injected">;</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// </span><span class="comment injected">/* multi-line</span>
    <span class="comment documentation">/// </span><span class="comment injected">       comment */</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 973173254..c43bcb691 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -213,7 +213,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="numeric_literal">-</span><span class="numeric_literal">42</span><span class="semicolon">;</span>
    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="operator">-</span><span class="variable">baz</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="operator">!</span><span class="bool_literal">true</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="logical">!</span><span class="bool_literal">true</span><span class="semicolon">;</span>
    <span class="label declaration">'foo</span><span class="colon">:</span> <span class="keyword control">loop</span> <span class="brace">{</span>
        <span class="keyword control">break</span> <span class="label">'foo</span><span class="semicolon">;</span>
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index de2d22ac7..933cfa6f3 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -2,8 +2,7 @@ use std::time::Instant;
 use expect_test::{expect_file, ExpectFile};
 use ide_db::SymbolKind;
-use stdx::format_to;
+use test_utils::{bench, bench_fixture, skip_slow_tests, AssertLinear};
-use test_utils::{bench, bench_fixture, skip_slow_tests};
 use crate::{fixture, FileRange, HlTag, TextRange};
@@ -266,90 +265,27 @@ fn syntax_highlighting_not_quadratic() {
        return;
    }
-    let mut measures = Vec::new();
+    let mut al = AssertLinear::default();
-    for i in 6..=10 {
+    while al.next_round() {
-        let n = 1 << i;
+        for i in 6..=10 {
-        let fixture = bench_fixture::big_struct_n(n);
+            let n = 1 << i;
-        let (analysis, file_id) = fixture::file(&fixture);
-        let time = Instant::now();
+            let fixture = bench_fixture::big_struct_n(n);
+            let (analysis, file_id) = fixture::file(&fixture);
-        let hash = analysis
+            let time = Instant::now();
-            .highlight(file_id)
-            .unwrap()
-            .iter()
-            .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
-            .count();
-        assert!(hash > n as usize);
-        let elapsed = time.elapsed();
+            let hash = analysis
-        measures.push((n as f64, elapsed.as_millis() as f64))
+                .highlight(file_id)
-    }
+                .unwrap()
+                .iter()
+                .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Struct))
+                .count();
+            assert!(hash > n as usize);
-    assert_linear(&measures)
+            let elapsed = time.elapsed();
-}
+            al.sample(n as f64, elapsed.as_millis() as f64);
-/// Checks that a set of measurements looks like a liner function rather than
-/// like a quadratic function. Algorithm:
-///
-/// 1. Linearly scale input to be in [0; 1)
-/// 2. Using linear regression, compute the best linear function approximating
-///    the input.
-/// 3. Compute RMSE and  maximal absolute error.
-/// 4. Check that errors are within tolerances and that the constant term is not