83 files changed, 2042 insertions, 668 deletions
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index b5160eaa3..060a05d41 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -14,8 +14,9 @@ Forum for questions: https://users.rust-lang.org/c/ide/14
 Before submitting, please make sure that you're not running into one of these known issues:
 1. on-the-fly diagnostics are mostly unimplemented (`cargo check` diagnostics will be shown when saving a file)
- 2. some settings are required for procedural macro and build script support (`rust-analyzer.cargo.loadOutDirsFromCheck`, `rust-analyzer.procMacro.enable`): #6448
+ 2. some platform-specific imports are not resolved: #6038
- 3. some platform-specific imports are not resolved: #6038
+ 3. attribute proc macros are not supported: #6029
+ 4. the version string is misleading (includes the previous week): #8571
 Otherwise please try to provide information which will help us to fix the issue faster. Minimal reproducible examples with few dependencies are especially lovely <3.
 -->
diff --git a/Cargo.lock b/Cargo.lock
index 2fff7e3e7..1bb66c66e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -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/src/semantics.rs b/crates/hir/src/semantics.rs
index 7955bf0b5..62500602a 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -6,10 +6,11 @@ use std::{cell::RefCell, fmt, iter::successors};
 use base_db::{FileId, FileRange};
 use hir_def::{
+    body,
    resolver::{self, HasResolver, Resolver, TypeNs},
    AsMacroCall, FunctionId, TraitId, VariantId,
 };
-use hir_expand::{hygiene::Hygiene, name::AsName, ExpansionInfo};
+use hir_expand::{name::AsName, ExpansionInfo};
 use hir_ty::associated_type_shorthand_candidates;
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -853,8 +854,8 @@ impl<'a> SemanticsScope<'a> {
    /// Resolve a path as-if it was written at the given scope. This is
    /// necessary a heuristic, as it doesn't take hygiene into account.
    pub fn speculative_resolve(&self, path: &ast::Path) -> Option<PathResolution> {
-        let hygiene = Hygiene::new(self.db.upcast(), self.file_id);
+        let ctx = body::LowerCtx::new(self.db.upcast(), self.file_id);
-        let path = Path::from_src(path.clone(), &hygiene)?;
+        let path = Path::from_src(path.clone(), &ctx)?;
        resolve_hir_path(self.db, &self.resolver, &path)
    }
 }
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 847d2537d..0895bd6f1 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -9,6 +9,7 @@ use std::{iter::once, sync::Arc};
 use hir_def::{
    body::{
+        self,
        scope::{ExprScopes, ScopeId},
        Body, BodySourceMap,
    },
@@ -202,8 +203,8 @@ impl SourceAnalyzer {
        db: &dyn HirDatabase,
        macro_call: InFile<&ast::MacroCall>,
    ) -> Option<MacroDef> {
-        let hygiene = Hygiene::new(db.upcast(), macro_call.file_id);
+        let ctx = body::LowerCtx::new(db.upcast(), macro_call.file_id);
-        let path = macro_call.value.path().and_then(|ast| Path::from_src(ast, &hygiene))?;
+        let path = macro_call.value.path().and_then(|ast| Path::from_src(ast, &ctx))?;
        self.resolver.resolve_path_as_macro(db.upcast(), path.mod_path()).map(|it| it.into())
    }
@@ -281,7 +282,9 @@ impl SourceAnalyzer {
        }
        // This must be a normal source file rather than macro file.
-        let hir_path = Path::from_src(path.clone(), &Hygiene::new(db.upcast(), self.file_id))?;
+        let hygiene = Hygiene::new(db.upcast(), self.file_id);
+        let ctx = body::LowerCtx::with_hygiene(&hygiene);
+        let hir_path = Path::from_src(path.clone(), &ctx)?;
        // Case where path is a qualifier of another path, e.g. foo::bar::Baz where we
        // trying to resolve foo::bar.
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 96b959967..131f424cc 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -21,7 +21,7 @@ use profile::Count;
 use rustc_hash::FxHashMap;
 use syntax::{ast, AstNode, AstPtr};
-pub(crate) use lower::LowerCtx;
+pub use lower::LowerCtx;
 use crate::{
    attr::{Attrs, RawAttrs},
@@ -37,13 +37,15 @@ use crate::{
 /// A subset of Expander that only deals with cfg attributes. We only need it to
 /// avoid cyclic queries in crate def map during enum processing.
+#[derive(Debug)]
 pub(crate) struct CfgExpander {
    cfg_options: CfgOptions,
    hygiene: Hygiene,
    krate: CrateId,
 }
-pub(crate) struct Expander {
+#[derive(Debug)]
+pub struct Expander {
    cfg_expander: CfgExpander,
    def_map: Arc<DefMap>,
    current_file_id: HirFileId,
@@ -80,11 +82,7 @@ impl CfgExpander {
 }
 impl Expander {
-    pub(crate) fn new(
+    pub fn new(db: &dyn DefDatabase, current_file_id: HirFileId, module: ModuleId) -> Expander {
-        db: &dyn DefDatabase,
-        current_file_id: HirFileId,
-        module: ModuleId,
-    ) -> Expander {
        let cfg_expander = CfgExpander::new(db, current_file_id, module.krate);
        let def_map = module.def_map(db);
        let ast_id_map = db.ast_id_map(current_file_id);
@@ -98,7 +96,7 @@ impl Expander {
        }
    }
-    pub(crate) fn enter_expand<T: ast::AstNode>(
+    pub fn enter_expand<T: ast::AstNode>(
        &mut self,
        db: &dyn DefDatabase,
        macro_call: ast::MacroCall,
@@ -170,7 +168,7 @@ impl Expander {
        Ok(ExpandResult { value: Some((mark, node)), err })
    }
-    pub(crate) fn exit(&mut self, db: &dyn DefDatabase, mut mark: Mark) {
+    pub fn exit(&mut self, db: &dyn DefDatabase, mut mark: Mark) {
        self.cfg_expander.hygiene = Hygiene::new(db.upcast(), mark.file_id);
        self.current_file_id = mark.file_id;
        self.ast_id_map = mem::take(&mut mark.ast_id_map);
@@ -190,8 +188,13 @@ impl Expander {
        &self.cfg_expander.cfg_options
    }
+    pub fn current_file_id(&self) -> HirFileId {
+        self.current_file_id
+    }
    fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
-        Path::from_src(path, &self.cfg_expander.hygiene)
+        let ctx = LowerCtx::with_hygiene(&self.cfg_expander.hygiene);
+        Path::from_src(path, &ctx)
    }
    fn resolve_path_as_macro(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<MacroDefId> {
@@ -204,7 +207,8 @@ impl Expander {
    }
 }
-pub(crate) struct Mark {
+#[derive(Debug)]
+pub struct Mark {
    file_id: HirFileId,
    ast_id_map: Arc<AstIdMap>,
    bomb: DropBomb,
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index ed07d6928..c11da30d2 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -1,10 +1,11 @@
 //! Transforms `ast::Expr` into an equivalent `hir_def::expr::Expr`
 //! representation.
-use std::mem;
+use std::{mem, sync::Arc};
 use either::Either;
 use hir_expand::{
+    ast_id_map::{AstIdMap, FileAstId},
    hygiene::Hygiene,
    name::{name, AsName, Name},
    ExpandError, HirFileId,
@@ -39,20 +40,39 @@ use crate::{
 use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
-pub(crate) struct LowerCtx {
+pub struct LowerCtx {
    hygiene: Hygiene,
+    file_id: Option<HirFileId>,
+    source_ast_id_map: Option<Arc<AstIdMap>>,
 }
 impl LowerCtx {
-    pub(crate) fn new(db: &dyn DefDatabase, file_id: HirFileId) -> Self {
+    pub fn new(db: &dyn DefDatabase, file_id: HirFileId) -> Self {
-        LowerCtx { hygiene: Hygiene::new(db.upcast(), file_id) }
+        LowerCtx {
+            hygiene: Hygiene::new(db.upcast(), file_id),
+            file_id: Some(file_id),
+            source_ast_id_map: Some(db.ast_id_map(file_id)),
+        }
+    }
+    pub fn with_hygiene(hygiene: &Hygiene) -> Self {
+        LowerCtx { hygiene: hygiene.clone(), file_id: None, source_ast_id_map: None }
+    }
+    pub(crate) fn hygiene(&self) -> &Hygiene {
+        &self.hygiene
    }
-    pub(crate) fn with_hygiene(hygiene: &Hygiene) -> Self {
-        LowerCtx { hygiene: hygiene.clone() }
+    pub(crate) fn file_id(&self) -> HirFileId {
+        self.file_id.unwrap()
    }
    pub(crate) fn lower_path(&self, ast: ast::Path) -> Option<Path> {
-        Path::from_src(ast, &self.hygiene)
+        Path::from_src(ast, self)
+    }
+    pub(crate) fn ast_id<N: AstNode>(&self, item: &N) -> Option<FileAstId<N>> {
+        self.source_ast_id_map.as_ref().map(|ast_id_map| ast_id_map.ast_id(item))
    }
 }
@@ -568,9 +588,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/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 94e08f835..16a94a058 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -104,6 +104,11 @@ impl ItemTree {
                    // items and expanded during block DefMap computation
                    return Default::default();
                },
+                ast::Type(ty) => {
+                    // Types can contain inner items. We return an empty item tree in this case, but
+                    // still need to collect inner items.
+                    ctx.lower_inner_items(ty.syntax())
+                },
                ast::Expr(e) => {
                    // Macros can expand to expressions. We return an empty item tree in this case, but
                    // still need to collect inner items.
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index ffee05500..25694f037 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
@@ -675,7 +688,10 @@ impl<T: ast::AstNode> AstIdWithPath<T> {
    }
 }
-pub struct UnresolvedMacro;
+#[derive(Debug)]
+pub struct UnresolvedMacro {
+    pub path: ModPath,
+}
 fn macro_call_as_call_id(
    call: &AstIdWithPath<ast::MacroCall>,
@@ -684,7 +700,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()));
@@ -714,8 +731,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/path.rs b/crates/hir_def/src/path.rs
index b528ff8ba..509f77850 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -48,7 +48,8 @@ pub enum ImportAlias {
 impl ModPath {
    pub fn from_src(path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
-        lower::lower_path(path, hygiene).map(|it| (*it.mod_path).clone())
+        let ctx = LowerCtx::with_hygiene(hygiene);
+        lower::lower_path(path, &ctx).map(|it| (*it.mod_path).clone())
    }
    pub fn from_segments(kind: PathKind, segments: impl IntoIterator<Item = Name>) -> ModPath {
@@ -167,8 +168,8 @@ pub enum GenericArg {
 impl Path {
    /// Converts an `ast::Path` to `Path`. Works with use trees.
    /// It correctly handles `$crate` based path from macro call.
-    pub fn from_src(path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
+    pub fn from_src(path: ast::Path, ctx: &LowerCtx) -> Option<Path> {
-        lower::lower_path(path, hygiene)
+        lower::lower_path(path, ctx)
    }
    /// Converts a known mod path to `Path`.
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index 7b29d9d4f..1df6db525 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -6,10 +6,7 @@ use crate::intern::Interned;
 use std::sync::Arc;
 use either::Either;
-use hir_expand::{
+use hir_expand::name::{name, AsName};
-    hygiene::Hygiene,
-    name::{name, AsName},
-};
 use syntax::ast::{self, AstNode, TypeBoundsOwner};
 use super::AssociatedTypeBinding;
@@ -23,12 +20,12 @@ pub(super) use lower_use::lower_use_tree;
 /// Converts an `ast::Path` to `Path`. Works with use trees.
 /// It correctly handles `$crate` based path from macro call.
-pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
+pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx) -> Option<Path> {
    let mut kind = PathKind::Plain;
    let mut type_anchor = None;
    let mut segments = Vec::new();
    let mut generic_args = Vec::new();
-    let ctx = LowerCtx::with_hygiene(hygiene);
+    let hygiene = ctx.hygiene();
    loop {
        let segment = path.segment()?;
@@ -43,10 +40,10 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                    Either::Left(name) => {
                        let args = segment
                            .generic_arg_list()
-                            .and_then(|it| lower_generic_args(&ctx, it))
+                            .and_then(|it| lower_generic_args(ctx, it))
                            .or_else(|| {
                                lower_generic_args_from_fn_path(
-                                    &ctx,
+                                    ctx,
                                    segment.param_list(),
                                    segment.ret_type(),
                                )
@@ -64,7 +61,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
            ast::PathSegmentKind::Type { type_ref, trait_ref } => {
                assert!(path.qualifier().is_none()); // this can only occur at the first segment
-                let self_type = TypeRef::from_ast(&ctx, type_ref?);
+                let self_type = TypeRef::from_ast(ctx, type_ref?);
                match trait_ref {
                    // <T>::foo
@@ -74,7 +71,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                    }
                    // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
                    Some(trait_ref) => {
-                        let path = Path::from_src(trait_ref.path()?, hygiene)?;
+                        let path = Path::from_src(trait_ref.path()?, ctx)?;
                        let mod_path = (*path.mod_path).clone();
                        let num_segments = path.mod_path.segments.len();
                        kind = mod_path.kind;
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/type_ref.rs b/crates/hir_def/src/type_ref.rs
index 4c24aae94..ea29da5da 100644
--- a/crates/hir_def/src/type_ref.rs
+++ b/crates/hir_def/src/type_ref.rs
@@ -1,6 +1,7 @@
 //! HIR for references to types. Paths in these are not yet resolved. They can
 //! be directly created from an ast::TypeRef, without further queries.
-use hir_expand::name::Name;
+use hir_expand::{name::Name, AstId, InFile};
 use syntax::ast;
 use crate::{body::LowerCtx, path::Path};
@@ -68,6 +69,7 @@ impl TraitRef {
        }
    }
 }
 /// Compare ty::Ty
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub enum TypeRef {
@@ -84,6 +86,7 @@ pub enum TypeRef {
    // For
    ImplTrait(Vec<TypeBound>),
    DynTrait(Vec<TypeBound>),
+    Macro(AstId<ast::MacroCall>),
    Error,
 }
@@ -116,7 +119,7 @@ pub enum TypeBound {
 impl TypeRef {
    /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
-    pub(crate) fn from_ast(ctx: &LowerCtx, node: ast::Type) -> Self {
+    pub fn from_ast(ctx: &LowerCtx, node: ast::Type) -> Self {
        match node {
            ast::Type::ParenType(inner) => TypeRef::from_ast_opt(&ctx, inner.ty()),
            ast::Type::TupleType(inner) => {
@@ -176,8 +179,13 @@ impl TypeRef {
            ast::Type::DynTraitType(inner) => {
                TypeRef::DynTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
            }
-            // FIXME: Macros in type position are not yet supported.
+            ast::Type::MacroType(mt) => match mt.macro_call() {
-            ast::Type::MacroType(_) => TypeRef::Error,
+                Some(mc) => ctx
+                    .ast_id(&mc)
+                    .map(|mc| TypeRef::Macro(InFile::new(ctx.file_id(), mc)))
+                    .unwrap_or(TypeRef::Error),
+                None => TypeRef::Error,
+            },
        }
    }
@@ -215,7 +223,7 @@ impl TypeRef {
                    }
                }
                TypeRef::Path(path) => go_path(path, f),
-                TypeRef::Never | TypeRef::Placeholder | TypeRef::Error => {}
+                TypeRef::Never | TypeRef::Placeholder | TypeRef::Macro(_) | TypeRef::Error => {}
            };
        }
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/db.rs b/crates/hir_expand/src/db.rs
index ca705ee9d..1e4b0cc19 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -440,6 +440,7 @@ fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
        MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
        MACRO_STMTS => FragmentKind::Statements,
        MACRO_PAT => FragmentKind::Pattern,
+        MACRO_TYPE => FragmentKind::Type,
        ITEM_LIST => FragmentKind::Items,
        LET_STMT => {
            // FIXME: Handle LHS Pattern
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index ef126e4ad..a5ac32d3c 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -31,6 +31,7 @@ use parser::FragmentKind;
 use std::sync::Arc;
 use syntax::{algo::SyntaxRewriter, SyntaxNode};
+#[derive(Debug)]
 pub struct ErrorEmitted {
    _private: (),
 }
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/display.rs b/crates/hir_ty/src/display.rs
index e7c9dabc2..4fb7d9cf2 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -9,6 +9,7 @@ use std::{
 use chalk_ir::BoundVar;
 use hir_def::{
+    body,
    db::DefDatabase,
    find_path,
    generics::TypeParamProvenance,
@@ -18,7 +19,7 @@ use hir_def::{
    visibility::Visibility,
    AssocContainerId, Lookup, ModuleId, TraitId,
 };
-use hir_expand::name::Name;
+use hir_expand::{hygiene::Hygiene, name::Name};
 use crate::{
    const_from_placeholder_idx, db::HirDatabase, from_assoc_type_id, from_foreign_def_id,
@@ -997,6 +998,18 @@ impl HirDisplay for TypeRef {
                write!(f, "dyn ")?;
                f.write_joined(bounds, " + ")?;
            }
+            TypeRef::Macro(macro_call) => {
+                let macro_call = macro_call.to_node(f.db.upcast());
+                let ctx = body::LowerCtx::with_hygiene(&Hygiene::new_unhygienic());
+                match macro_call.path() {
+                    Some(path) => match Path::from_src(path, &ctx) {
+                        Some(path) => path.hir_fmt(f)?,
+                        None => write!(f, "{{macro}}")?,
+                    },
+                    None => write!(f, "{{macro}}")?,
+                }
+                write!(f, "!(..)")?;
+            }
            TypeRef::Error => write!(f, "{{error}}")?,
        }
        Ok(())
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/lower.rs b/crates/hir_ty/src/lower.rs
index a035686bc..7fd46becd 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -5,12 +5,14 @@
 //!  - Building the type for an item: This happens through the `type_for_def` query.
 //!
 //! This usually involves resolving names, collecting generic arguments etc.
+use std::cell::{Cell, RefCell};
 use std::{iter, sync::Arc};
 use base_db::CrateId;
 use chalk_ir::{cast::Cast, fold::Shift, interner::HasInterner, Mutability, Safety};
 use hir_def::{
    adt::StructKind,
+    body::{Expander, LowerCtx},
    builtin_type::BuiltinType,
    generics::{TypeParamProvenance, WherePredicate, WherePredicateTypeTarget},
    path::{GenericArg, Path, PathSegment, PathSegments},
@@ -20,10 +22,11 @@ use hir_def::{
    GenericDefId, HasModule, ImplId, LocalFieldId, Lookup, StaticId, StructId, TraitId,
    TypeAliasId, TypeParamId, UnionId, VariantId,
 };
-use hir_expand::name::Name;
+use hir_expand::{name::Name, ExpandResult};
 use la_arena::ArenaMap;
 use smallvec::SmallVec;
 use stdx::impl_from;
+use syntax::ast;
 use crate::{
    db::HirDatabase,
@@ -50,7 +53,7 @@ pub struct TyLoweringContext<'a> {
    /// possible currently, so this should be fine for now.
    pub type_param_mode: TypeParamLoweringMode,
    pub impl_trait_mode: ImplTraitLoweringMode,
-    impl_trait_counter: std::cell::Cell<u16>,
+    impl_trait_counter: Cell<u16>,
    /// When turning `impl Trait` into opaque types, we have to collect the
    /// bounds at the same time to get the IDs correct (without becoming too
    /// complicated). I don't like using interior mutability (as for the
@@ -59,16 +62,17 @@ pub struct TyLoweringContext<'a> {
    /// we're grouping the mutable data (the counter and this field) together
    /// with the immutable context (the references to the DB and resolver).
    /// Splitting this up would be a possible fix.
-    opaque_type_data: std::cell::RefCell<Vec<ReturnTypeImplTrait>>,
+    opaque_type_data: RefCell<Vec<ReturnTypeImplTrait>>,
+    expander: RefCell<Option<Expander>>,
 }
 impl<'a> TyLoweringContext<'a> {
    pub fn new(db: &'a dyn HirDatabase, resolver: &'a Resolver) -> Self {
-        let impl_trait_counter = std::cell::Cell::new(0);
+        let impl_trait_counter = Cell::new(0);
        let impl_trait_mode = ImplTraitLoweringMode::Disallowed;
        let type_param_mode = TypeParamLoweringMode::Placeholder;
        let in_binders = DebruijnIndex::INNERMOST;
-        let opaque_type_data = std::cell::RefCell::new(Vec::new());
+        let opaque_type_data = RefCell::new(Vec::new());
        Self {
            db,
            resolver,
@@ -77,6 +81,7 @@ impl<'a> TyLoweringContext<'a> {
            impl_trait_counter,
            type_param_mode,
            opaque_type_data,
+            expander: RefCell::new(None),
        }
    }
@@ -86,15 +91,18 @@ impl<'a> TyLoweringContext<'a> {
        f: impl FnOnce(&TyLoweringContext) -> T,
    ) -> T {
        let opaque_ty_data_vec = self.opaque_type_data.replace(Vec::new());
+        let expander = self.expander.replace(None);
        let new_ctx = Self {
            in_binders: debruijn,
-            impl_trait_counter: std::cell::Cell::new(self.impl_trait_counter.get()),
+            impl_trait_counter: Cell::new(self.impl_trait_counter.get()),
-            opaque_type_data: std::cell::RefCell::new(opaque_ty_data_vec),
+            opaque_type_data: RefCell::new(opaque_ty_data_vec),
+            expander: RefCell::new(expander),
            ..*self
        };
        let result = f(&new_ctx);
        self.impl_trait_counter.set(new_ctx.impl_trait_counter.get());
        self.opaque_type_data.replace(new_ctx.opaque_type_data.into_inner());
+        self.expander.replace(new_ctx.expander.into_inner());
        result
    }
@@ -287,6 +295,53 @@ impl<'a> TyLoweringContext<'a> {
                    }
                }
            }
+            TypeRef::Macro(macro_call) => {
+                let (expander, recursion_start) = {
+                    let mut expander = self.expander.borrow_mut();
+                    if expander.is_some() {
+                        (Some(expander), false)
+                    } else {
+                        if let Some(module_id) = self.resolver.module() {
+                            *expander = Some(Expander::new(
+                                self.db.upcast(),
+                                macro_call.file_id,
+                                module_id,
+                            ));
+                            (Some(expander), true)
+                        } else {
+                            (None, false)
+                        }
+                    }
+                };
+                let ty = if let Some(mut expander) = expander {
+                    let expander_mut = expander.as_mut().unwrap();
+                    let macro_call = macro_call.to_node(self.db.upcast());
+                    match expander_mut.enter_expand::<ast::Type>(self.db.upcast(), macro_call) {
+                        Ok(ExpandResult { value: Some((mark, expanded)), .. }) => {
+                            let ctx =
+                                LowerCtx::new(self.db.upcast(), expander_mut.current_file_id());
+                            let type_ref = TypeRef::from_ast(&ctx, expanded);
+                            drop(expander);
+                            let ty = self.lower_ty(&type_ref);
+                            self.expander
+                                .borrow_mut()
+                                .as_mut()
+                                .unwrap()
+                                .exit(self.db.upcast(), mark);
+                            Some(ty)
+                        }
+                        _ => None,
+                    }
+                } else {
+                    None
+                };
+                if recursion_start {
+                    *self.expander.borrow_mut() = None;
+                }
+                ty.unwrap_or_else(|| TyKind::Error.intern(&Interner))
+            }
            TypeRef::Error => TyKind::Error.intern(&Interner),
        };
        (ty, res)
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index 3693e3284..48bbcfd9f 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -246,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 _: () = { ... };
-                if let Some(fp) = fp {
+                for konst in module_data.scope.unnamed_consts() {
-                    map.entry(fp).or_default().push(impl_id);
+                    let body = db.body(konst.into());
+                    for (_, block_def_map) in body.blocks(db.upcast()) {
+                        collect_def_map(db, &block_def_map, impls);
+                    }
                }
-                // `fp` should only be `None` in error cases (either erroneous code or incomplete name resolution)
            }
        }
-        // 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/macros.rs b/crates/hir_ty/src/tests/macros.rs
index b8e373ed8..6588aa46c 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -1074,3 +1074,202 @@ fn macro_in_arm() {
        "#]],
    );
 }
+#[test]
+fn macro_in_type_alias_position() {
+    check_infer(
+        r#"
+        macro_rules! U32 {
+            () => { u32 };
+        }
+        trait Foo {
+            type Ty;
+        }
+        impl<T> Foo for T {
+            type Ty = U32!();
+        }
+        type TayTo = U32!();
+        fn testy() {
+            let a: <() as Foo>::Ty;
+            let b: TayTo;
+        }
+        "#,
+        expect![[r#"
+            147..196 '{     ...yTo; }': ()
+            157..158 'a': u32
+            185..186 'b': u32
+        "#]],
+    );
+}
+#[test]
+fn nested_macro_in_type_alias_position() {
+    check_infer(
+        r#"
+        macro_rules! U32Inner2 {
+            () => { u32 };
+        }
+        macro_rules! U32Inner1 {
+            () => { U32Inner2!() };
+        }
+        macro_rules! U32 {
+            () => { U32Inner1!() };
+        }
+        trait Foo {
+            type Ty;
+        }
+        impl<T> Foo for T {
+            type Ty = U32!();
+        }
+        type TayTo = U32!();
+        fn testy() {
+            let a: <() as Foo>::Ty;
+            let b: TayTo;
+        }
+        "#,
+        expect![[r#"
+            259..308 '{     ...yTo; }': ()
+            269..270 'a': u32
+            297..298 'b': u32
+        "#]],
+    );
+}
+#[test]
+fn macros_in_type_alias_position_generics() {
+    check_infer(
+        r#"
+        struct Foo<A, B>(A, B);
+        macro_rules! U32 {
+            () => { u32 };
+        }
+        macro_rules! Bar {
+            () => { Foo<U32!(), U32!()> };
+        }
+        trait Moo {
+            type Ty;
+        }
+        impl<T> Moo for T {
+            type Ty = Bar!();
+        }
+        type TayTo = Bar!();
+        fn main() {
+            let a: <() as Moo>::Ty;
+            let b: TayTo;
+        }
+        "#,
+        expect![[r#"
+            228..277 '{     ...yTo; }': ()
+            238..239 'a': Foo<u32, u32>
+            266..267 'b': Foo<u32, u32>
+        "#]],
+    );
+}
+#[test]
+fn macros_in_type_position() {
+    check_infer(
+        r#"
+        struct Foo<A, B>(A, B);
+        macro_rules! U32 {
+            () => { u32 };
+        }
+        macro_rules! Bar {
+            () => { Foo<U32!(), U32!()> };
+        }
+        fn main() {
+            let a: Bar!();
+        }
+        "#,
+        expect![[r#"
+            133..155 '{     ...!(); }': ()
+            143..144 'a': Foo<u32, u32>
+        "#]],
+    );
+}
+#[test]
+fn macros_in_type_generics() {
+    check_infer(
+        r#"
+        struct Foo<A, B>(A, B);
+        macro_rules! U32 {
+            () => { u32 };
+        }
+        macro_rules! Bar {
+            () => { Foo<U32!(), U32!()> };
+        }
+        trait Moo {
+            type Ty;
+        }
+        impl<T> Moo for T {
+            type Ty = Foo<Bar!(), Bar!()>;
+        }
+        type TayTo = Foo<Bar!(), U32!()>;
+        fn main() {
+            let a: <() as Moo>::Ty;
+            let b: TayTo;
+        }
+        "#,
+        expect![[r#"
+            254..303 '{     ...yTo; }': ()
+            264..265 'a': Foo<Foo<u32, u32>, Foo<u32, u32>>
+            292..293 'b': Foo<Foo<u32, u32>, u32>
+        "#]],
+    );
+}
+#[test]
+fn infinitely_recursive_macro_type() {
+    check_infer(
+        r#"
+        struct Bar<T, X>(T, X);
+        macro_rules! Foo {
+            () => { Foo!() }
+        }
+        macro_rules! U32 {
+            () => { u32 }
+        }
+        type A = Foo!();
+        type B = Bar<Foo!(), U32!()>;
+        fn main() {
+            let a: A;
+            let b: B;
+        }
+        "#,
+        expect![[r#"
+            166..197 '{     ...: B; }': ()
+            176..177 'a': {unknown}
+            190..191 'b': Bar<{unknown}, u32>
+        "#]],
+    );
+}
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 9a883acb9..1c911a8b2 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -725,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,
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index b24c664ba..99e45633e 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -244,6 +244,12 @@ impl Analysis {
        self.with_db(|db| db.parse(file_id).tree())
    }
+    /// Returns true if this file belongs to an immutable library.
+    pub fn is_library_file(&self, file_id: FileId) -> Cancelable<bool> {
+        use ide_db::base_db::SourceDatabaseExt;
+        self.with_db(|db| db.source_root(db.file_source_root(file_id)).is_library)
+    }
    /// Gets the file's `LineIndex`: data structure to convert between absolute
    /// offsets and line/column representation.
    pub fn file_line_index(&self, file_id: FileId) -> Cancelable<Arc<LineIndex>> {
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/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
index 04fafd244..bc221d599 100644
--- a/crates/ide/src/syntax_highlighting/inject.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -4,7 +4,7 @@ use std::mem;
 use either::Either;
 use hir::{InFile, Semantics};
-use ide_db::{call_info::ActiveParameter, SymbolKind};
+use ide_db::{call_info::ActiveParameter, helpers::rust_doc::is_rust_fence, SymbolKind};
 use syntax::{
    ast::{self, AstNode},
    AstToken, NodeOrToken, SyntaxNode, SyntaxToken, TextRange, TextSize,
@@ -78,17 +78,6 @@ pub(super) fn ra_fixture(
 }
 const RUSTDOC_FENCE: &'static str = "```";
-const RUSTDOC_FENCE_TOKENS: &[&'static str] = &[
-    "",
-    "rust",
-    "should_panic",
-    "ignore",
-    "no_run",
-    "compile_fail",
-    "edition2015",
-    "edition2018",
-    "edition2021",
-];
 /// Injection of syntax highlighting of doctests.
 pub(super) fn doc_comment(
@@ -174,8 +163,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 = is_rust_fence(guards);
-                        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/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 933cfa6f3..17cc6334b 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -307,7 +307,7 @@ fn benchmark_syntax_highlighting_parser() {
            .filter(|it| it.highlight.tag == HlTag::Symbol(SymbolKind::Function))
            .count()
    };
-    assert_eq!(hash, 1629);
+    assert_eq!(hash, 1632);
 }
 #[test]
diff --git a/crates/ide_assists/src/handlers/fill_match_arms.rs b/crates/ide_assists/src/handlers/fill_match_arms.rs
index 878b3a3fa..a30c4d04e 100644
--- a/crates/ide_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ide_assists/src/handlers/fill_match_arms.rs
@@ -1,5 +1,6 @@
 use std::iter;
+use either::Either;
 use hir::{Adt, HasSource, ModuleDef, Semantics};
 use ide_db::helpers::{mod_path_to_ast, FamousDefs};
 use ide_db::RootDatabase;
@@ -7,7 +8,7 @@ use itertools::Itertools;
 use syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
 use crate::{
-    utils::{does_pat_match_variant, render_snippet, Cursor},
+    utils::{self, render_snippet, Cursor},
    AssistContext, AssistId, AssistKind, Assists,
 };
@@ -48,6 +49,18 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
        }
    }
+    let top_lvl_pats: Vec<_> = arms
+        .iter()
+        .filter_map(ast::MatchArm::pat)
+        .flat_map(|pat| match pat {
+            // Special casee OrPat as separate top-level pats
+            Pat::OrPat(or_pat) => Either::Left(or_pat.pats()),
+            _ => Either::Right(iter::once(pat)),
+        })
+        // Exclude top level wildcards so that they are expanded by this assist, retains status quo in #8129.
+        .filter(|pat| !matches!(pat, Pat::WildcardPat(_)))
+        .collect();
    let module = ctx.sema.scope(expr.syntax()).module()?;
    let missing_arms: Vec<MatchArm> = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr) {
@@ -56,7 +69,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
        let mut variants = variants
            .into_iter()
            .filter_map(|variant| build_pat(ctx.db(), module, variant))
-            .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
+            .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat))
            .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
            .collect::<Vec<_>>();
        if Some(enum_def) == FamousDefs(&ctx.sema, Some(module.krate())).core_option_Option() {
@@ -66,17 +79,6 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
        }
        variants
    } else if let Some(enum_defs) = resolve_tuple_of_enum_def(&ctx.sema, &expr) {
-        // Partial fill not currently supported for tuple of enums.
-        if !arms.is_empty() {
-            return None;
-        }
-        // We do not currently support filling match arms for a tuple
-        // containing a single enum.
-        if enum_defs.len() < 2 {
-            return None;
-        }
        // When calculating the match arms for a tuple of enums, we want
        // to create a match arm for each possible combination of enum
        // values. The `multi_cartesian_product` method transforms
@@ -91,7 +93,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
                    variants.into_iter().filter_map(|variant| build_pat(ctx.db(), module, variant));
                ast::Pat::from(make::tuple_pat(patterns))
            })
-            .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
+            .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat))
            .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
            .collect()
    } else {
@@ -134,16 +136,19 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
    )
 }
-fn is_variant_missing(existing_arms: &mut Vec<MatchArm>, var: &Pat) -> bool {
+fn is_variant_missing(existing_pats: &[Pat], var: &Pat) -> bool {
-    existing_arms.iter().filter_map(|arm| arm.pat()).all(|pat| {
+    !existing_pats.iter().any(|pat| does_pat_match_variant(pat, var))
-        // Special casee OrPat as separate top-level pats
+}
-        let top_level_pats: Vec<Pat> = match pat {
-            Pat::OrPat(pats) => pats.pats().collect::<Vec<_>>(),
-            _ => vec![pat],
-        };
-        !top_level_pats.iter().any(|pat| does_pat_match_variant(pat, var))
+// Fixme: this is still somewhat limited, use hir_ty::diagnostics::match_check?
-    })
+fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
+    match (pat, var) {
+        (Pat::WildcardPat(_), _) => true,
+        (Pat::TuplePat(tpat), Pat::TuplePat(tvar)) => {
+            tpat.fields().zip(tvar.fields()).all(|(p, v)| does_pat_match_variant(&p, &v))
+        }
+        _ => utils::does_pat_match_variant(pat, var),
+    }
 }
 fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<hir::Enum> {
@@ -473,20 +478,81 @@ fn main() {
    #[test]
    fn fill_match_arms_tuple_of_enum_partial() {
-        check_assist_not_applicable(
+        check_assist(
            fill_match_arms,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            enum B { One, Two }
+enum B { One, Two }
-            fn main() {
+fn main() {
-                let a = A::One;
+    let a = A::One;
-                let b = B::One;
+    let b = B::One;
-                match (a$0, b) {
+    match (a$0, b) {
-                    (A::Two, B::One) => {}
+        (A::Two, B::One) => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
+            r#"
+enum A { One, Two }
+enum B { One, Two }
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a, b) {
+        (A::Two, B::One) => {}
+        $0(A::One, B::One) => {}
+        (A::One, B::Two) => {}
+        (A::Two, B::Two) => {}
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn fill_match_arms_tuple_of_enum_partial_with_wildcards() {
+        let ra_fixture = r#"
+fn main() {
+    let a = Some(1);
+    let b = Some(());
+    match (a$0, b) {
+        (Some(_), _) => {}
+        (None, Some(_)) => {}
+    }
+}
+"#;
+        check_assist(
+            fill_match_arms,
+            &format!("//- /main.rs crate:main deps:core{}{}", ra_fixture, FamousDefs::FIXTURE),
+            r#"
+fn main() {
+    let a = Some(1);
+    let b = Some(());
+    match (a, b) {
+        (Some(_), _) => {}
+        (None, Some(_)) => {}
+        $0(None, None) => {}
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn fill_match_arms_partial_with_deep_pattern() {
+        // Fixme: cannot handle deep patterns
+        let ra_fixture = r#"
+fn main() {
+    match $0Some(true) {
+        Some(true) => {}
+        None => {}
+    }
+}
+"#;
+        check_assist_not_applicable(
+            fill_match_arms,
+            &format!("//- /main.rs crate:main deps:core{}{}", ra_fixture, FamousDefs::FIXTURE),
        );
    }
@@ -514,10 +580,7 @@ fn main() {
    #[test]
    fn fill_match_arms_single_element_tuple_of_enum() {
-        // For now we don't hande the case of a single element tuple, but
+        check_assist(
-        // we could handle this in the future if `make::tuple_pat` allowed
-        // creating a tuple with a single pattern.
-        check_assist_not_applicable(
            fill_match_arms,
            r#"
            enum A { One, Two }
@@ -528,6 +591,17 @@ fn main() {
                }
            }
            "#,
+            r#"
+            enum A { One, Two }
+            fn main() {
+                let a = A::One;
+                match (a, ) {
+                    $0(A::One,) => {}
+                    (A::Two,) => {}
+                }
+            }
+            "#,
        );
    }
diff --git a/crates/ide_assists/src/handlers/generate_deref.rs b/crates/ide_assists/src/handlers/generate_deref.rs
new file mode 100644
index 000000000..4998ff7a4
--- /dev/null
+++ b/crates/ide_assists/src/handlers/generate_deref.rs
@@ -0,0 +1,227 @@
+use std::fmt::Display;
+use ide_db::{helpers::FamousDefs, RootDatabase};
+use syntax::{
+    ast::{self, NameOwner},
+    AstNode, SyntaxNode,
+};
+use crate::{
+    assist_context::{AssistBuilder, AssistContext, Assists},
+    utils::generate_trait_impl_text,
+    AssistId, AssistKind,
+};
+// Assist: generate_deref
+//
+// Generate `Deref` impl using the given struct field.
+//
+// ```
+// struct A;
+// struct B {
+//    $0a: A
+// }
+// ```
+// ->
+// ```
+// struct A;
+// struct B {
+//    a: A
+// }
+//
+// impl std::ops::Deref for B {
+//     type Target = A;
+//
+//     fn deref(&self) -> &Self::Target {
+//         &self.a
+//     }
+// }
+// ```
+pub(crate) fn generate_deref(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    generate_record_deref(acc, ctx).or_else(|| generate_tuple_deref(acc, ctx))
+}
+fn generate_record_deref(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
+    let field = ctx.find_node_at_offset::<ast::RecordField>()?;
+    if existing_deref_impl(&ctx.sema, &strukt).is_some() {
+        cov_mark::hit!(test_add_record_deref_impl_already_exists);
+        return None;
+    }
+    let field_type = field.ty()?;
+    let field_name = field.name()?;
+    let target = field.syntax().text_range();
+    acc.add(
+        AssistId("generate_deref", AssistKind::Generate),
+        format!("Generate `Deref` impl using `{}`", field_name),
+        target,
+        |edit| generate_edit(edit, strukt, field_type.syntax(), field_name.syntax()),
+    )
+}
+fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
+    let field = ctx.find_node_at_offset::<ast::TupleField>()?;
+    let field_list = ctx.find_node_at_offset::<ast::TupleFieldList>()?;
+    let field_list_index =
+        field_list.syntax().children().into_iter().position(|s| &s == field.syntax())?;
+    if existing_deref_impl(&ctx.sema, &strukt).is_some() {
+        cov_mark::hit!(test_add_field_deref_impl_already_exists);
+        return None;
+    }
+    let field_type = field.ty()?;
+    let target = field.syntax().text_range();
+    acc.add(
+        AssistId("generate_deref", AssistKind::Generate),
+        format!("Generate `Deref` impl using `{}`", field.syntax()),
+        target,
+        |edit| generate_edit(edit, strukt, field_type.syntax(), field_list_index),
+    )
+}
+fn generate_edit(
+    edit: &mut AssistBuilder,
+    strukt: ast::Struct,
+    field_type_syntax: &SyntaxNode,
+    field_name: impl Display,
+) {
+    let start_offset = strukt.syntax().text_range().end();
+    let impl_code = format!(
+        r#"    type Target = {0};
+    fn deref(&self) -> &Self::Target {{
+        &self.{1}
+    }}"#,
+        field_type_syntax, field_name
+    );
+    let strukt_adt = ast::Adt::Struct(strukt);
+    let deref_impl = generate_trait_impl_text(&strukt_adt, "std::ops::Deref", &impl_code);
+    edit.insert(start_offset, deref_impl);
+}
+fn existing_deref_impl(
+    sema: &'_ hir::Semantics<'_, RootDatabase>,
+    strukt: &ast::Struct,
+) -> Option<()> {
+    let strukt = sema.to_def(strukt)?;
+    let krate = strukt.module(sema.db).krate();
+    let deref_trait = FamousDefs(sema, Some(krate)).core_ops_Deref()?;
+    let strukt_type = strukt.ty(sema.db);
+    if strukt_type.impls_trait(sema.db, deref_trait, &[]) {
+        Some(())
+    } else {
+        None
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn test_generate_record_deref() {
+        check_assist(
+            generate_deref,
+            r#"struct A { }
+struct B { $0a: A }"#,
+            r#"struct A { }
+struct B { a: A }
+impl std::ops::Deref for B {
+    type Target = A;
+    fn deref(&self) -> &Self::Target {
+        &self.a
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn test_generate_field_deref_idx_0() {
+        check_assist(
+            generate_deref,
+            r#"struct A { }
+struct B($0A);"#,
+            r#"struct A { }
+struct B(A);
+impl std::ops::Deref for B {
+    type Target = A;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn test_generate_field_deref_idx_1() {
+        check_assist(
+            generate_deref,
+            r#"struct A { }
+struct B(u8, $0A);"#,
+            r#"struct A { }
+struct B(u8, A);
+impl std::ops::Deref for B {
+    type Target = A;
+    fn deref(&self) -> &Self::Target {
+        &self.1
+    }
+}"#,
+        );
+    }
+    fn check_not_applicable(ra_fixture: &str) {
+        let fixture = format!(
+            "//- /main.rs crate:main deps:core,std\n{}\n{}",
+            ra_fixture,
+            FamousDefs::FIXTURE
+        );
+        check_assist_not_applicable(generate_deref, &fixture)
+    }
+    #[test]
+    fn test_generate_record_deref_not_applicable_if_already_impl() {
+        cov_mark::check!(test_add_record_deref_impl_already_exists);
+        check_not_applicable(
+            r#"struct A { }
+struct B { $0a: A }
+impl std::ops::Deref for B {
+    type Target = A;
+    fn deref(&self) -> &Self::Target {
+        &self.a
+    }
+}"#,
+        )
+    }
+    #[test]
+    fn test_generate_field_deref_not_applicable_if_already_impl() {
+        cov_mark::check!(test_add_field_deref_impl_already_exists);
+        check_not_applicable(
+            r#"struct A { }
+struct B($0A)
+impl std::ops::Deref for B {
+    type Target = A;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}"#,
+        )
+    }
+}
diff --git a/crates/ide_assists/src/handlers/introduce_named_lifetime.rs b/crates/ide_assists/src/handlers/introduce_named_lifetime.rs
index 02782eb6d..9f4f71d6c 100644
--- a/crates/ide_assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/ide_assists/src/handlers/introduce_named_lifetime.rs
@@ -1,7 +1,8 @@
 use rustc_hash::FxHashSet;
 use syntax::{
-    ast::{self, GenericParamsOwner, NameOwner},
+    ast::{self, edit_in_place::GenericParamsOwnerEdit, make, GenericParamsOwner},
-    AstNode, TextRange, TextSize,
+    ted::{self, Position},
+    AstNode, TextRange,
 };
 use crate::{assist_context::AssistBuilder, AssistContext, AssistId, AssistKind, Assists};
@@ -37,10 +38,12 @@ static ASSIST_LABEL: &str = "Introduce named lifetime";
 pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let lifetime =
        ctx.find_node_at_offset::<ast::Lifetime>().filter(|lifetime| lifetime.text() == "'_")?;
+    let lifetime_loc = lifetime.lifetime_ident_token()?.text_range();
    if let Some(fn_def) = lifetime.syntax().ancestors().find_map(ast::Fn::cast) {
-        generate_fn_def_assist(acc, &fn_def, lifetime.lifetime_ident_token()?.text_range())
+        generate_fn_def_assist(acc, fn_def, lifetime_loc, lifetime)
    } else if let Some(impl_def) = lifetime.syntax().ancestors().find_map(ast::Impl::cast) {
-        generate_impl_def_assist(acc, &impl_def, lifetime.lifetime_ident_token()?.text_range())
+        generate_impl_def_assist(acc, impl_def, lifetime_loc, lifetime)
    } else {
        None
    }
@@ -49,26 +52,26 @@ pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -
 /// Generate the assist for the fn def case
 fn generate_fn_def_assist(
    acc: &mut Assists,
-    fn_def: &ast::Fn,
+    fn_def: ast::Fn,
    lifetime_loc: TextRange,
+    lifetime: ast::Lifetime,
 ) -> Option<()> {
    let param_list: ast::ParamList = fn_def.param_list()?;
-    let new_lifetime_param = generate_unique_lifetime_param_name(&fn_def.generic_param_list())?;
+    let new_lifetime_param = generate_unique_lifetime_param_name(fn_def.generic_param_list())?;
-    let end_of_fn_ident = fn_def.name()?.ident_token()?.text_range().end();
    let self_param =
        // use the self if it's a reference and has no explicit lifetime
        param_list.self_param().filter(|p| p.lifetime().is_none() && p.amp_token().is_some());
    // compute the location which implicitly has the same lifetime as the anonymous lifetime
    let loc_needing_lifetime = if let Some(self_param) = self_param {
        // if we have a self reference, use that
-        Some(self_param.name()?.syntax().text_range().start())
+        Some(NeedsLifetime::SelfParam(self_param))
    } else {
        // otherwise, if there's a single reference parameter without a named liftime, use that
        let fn_params_without_lifetime: Vec<_> = param_list
            .params()
            .filter_map(|param| match param.ty() {
                Some(ast::Type::RefType(ascribed_type)) if ascribed_type.lifetime().is_none() => {
-                    Some(ascribed_type.amp_token()?.text_range().end())
+                    Some(NeedsLifetime::RefType(ascribed_type))
                }
                _ => None,
            })
@@ -81,30 +84,46 @@ fn generate_fn_def_assist(
        }
    };
    acc.add(AssistId(ASSIST_NAME, AssistKind::Refactor), ASSIST_LABEL, lifetime_loc, |builder| {
-        add_lifetime_param(fn_def, builder, end_of_fn_ident, new_lifetime_param);
+        let fn_def = builder.make_ast_mut(fn_def);
-        builder.replace(lifetime_loc, format!("'{}", new_lifetime_param));
+        let lifetime = builder.make_ast_mut(lifetime);
-        loc_needing_lifetime.map(|loc| builder.insert(loc, format!("'{} ", new_lifetime_param)));
+        let loc_needing_lifetime =
+            loc_needing_lifetime.and_then(|it| it.make_mut(builder).to_position());
+        add_lifetime_param(fn_def.get_or_create_generic_param_list(), new_lifetime_param);
+        ted::replace(
+            lifetime.syntax(),
+            make_ast_lifetime(new_lifetime_param).clone_for_update().syntax(),
+        );
+        loc_needing_lifetime.map(|position| {
+            ted::insert(position, make_ast_lifetime(new_lifetime_param).clone_for_update().syntax())
+        });
    })
 }
 /// Generate the assist for the impl def case
 fn generate_impl_def_assist(
    acc: &mut Assists,
-    impl_def: &ast::Impl,
+    impl_def: ast::Impl,
    lifetime_loc: TextRange,
+    lifetime: ast::Lifetime,
 ) -> Option<()> {
-    let new_lifetime_param = generate_unique_lifetime_param_name(&impl_def.generic_param_list())?;
+    let new_lifetime_param = generate_unique_lifetime_param_name(impl_def.generic_param_list())?;
-    let end_of_impl_kw = impl_def.impl_token()?.text_range().end();
    acc.add(AssistId(ASSIST_NAME, AssistKind::Refactor), ASSIST_LABEL, lifetime_loc, |builder| {
-        add_lifetime_param(impl_def, builder, end_of_impl_kw, new_lifetime_param);
+        let impl_def = builder.make_ast_mut(impl_def);
-        builder.replace(lifetime_loc, format!("'{}", new_lifetime_param));
+        let lifetime = builder.make_ast_mut(lifetime);
+        add_lifetime_param(impl_def.get_or_create_generic_param_list(), new_lifetime_param);
+        ted::replace(
+            lifetime.syntax(),
+            make_ast_lifetime(new_lifetime_param).clone_for_update().syntax(),
+        );
    })
 }
 /// Given a type parameter list, generate a unique lifetime parameter name
 /// which is not in the list
 fn generate_unique_lifetime_param_name(
-    existing_type_param_list: &Option<ast::GenericParamList>,
+    existing_type_param_list: Option<ast::GenericParamList>,
 ) -> Option<char> {
    match existing_type_param_list {
        Some(type_params) => {
@@ -118,25 +137,37 @@ fn generate_unique_lifetime_param_name(
    }
 }
-/// Add the lifetime param to `builder`. If there are type parameters in `type_params_owner`, add it to the end. Otherwise
+fn add_lifetime_param(type_params: ast::GenericParamList, new_lifetime_param: char) {
-/// add new type params brackets with the lifetime parameter at `new_type_params_loc`.
+    let generic_param =
-fn add_lifetime_param<TypeParamsOwner: ast::GenericParamsOwner>(
+        make::generic_param(format!("'{}", new_lifetime_param), None).clone_for_update();
-    type_params_owner: &TypeParamsOwner,
+    type_params.add_generic_param(generic_param);
-    builder: &mut AssistBuilder,
+}
-    new_type_params_loc: TextSize,
-    new_lifetime_param: char,
+fn make_ast_lifetime(new_lifetime_param: char) -> ast::Lifetime {
-) {
+    make::generic_param(format!("'{}", new_lifetime_param), None)
-    match type_params_owner.generic_param_list() {
+        .syntax()
-        // add the new lifetime parameter to an existing type param list
+        .descendants()
-        Some(type_params) => {
+        .find_map(ast::Lifetime::cast)
-            builder.insert(
+        .unwrap()
-                (u32::from(type_params.syntax().text_range().end()) - 1).into(),
+}
-                format!(", '{}", new_lifetime_param),
-            );
+enum NeedsLifetime {
+    SelfParam(ast::SelfParam),
+    RefType(ast::RefType),
+}
+impl NeedsLifetime {
+    fn make_mut(self, builder: &mut AssistBuilder) -> Self {
+        match self {
+            Self::SelfParam(it) => Self::SelfParam(builder.make_ast_mut(it)),
+            Self::RefType(it) => Self::RefType(builder.make_ast_mut(it)),
        }
-        // create a new type param list containing only the new lifetime parameter
+    }
-        None => {
-            builder.insert(new_type_params_loc, format!("<'{}>", new_lifetime_param));
+    fn to_position(self) -> Option<Position> {
+        match self {
+            Self::SelfParam(it) => Some(Position::after(it.amp_token()?)),
+            Self::RefType(it) => Some(Position::after(it.amp_token()?)),
        }
    }
 }
@@ -312,4 +343,13 @@ mod tests {
            r#"fn my_fun<'other, 'a>(self, f: &'a Foo, b: &'other Bar) -> X<'a>"#,
        );
    }
+    #[test]
+    fn test_function_add_lifetime_to_self_ref_mut() {
+        check_assist(
+            introduce_named_lifetime,
+            r#"fn foo(&mut self) -> &'_$0 ()"#,
+            r#"fn foo<'a>(&'a mut self) -> &'a ()"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 3694f468f..8996c1b61 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -134,6 +134,7 @@ mod handlers {
    mod generate_default_from_enum_variant;
    mod generate_default_from_new;
    mod generate_is_empty_from_len;
+    mod generate_deref;
    mod generate_derive;
    mod generate_enum_is_method;
    mod generate_enum_projection_method;
@@ -201,6 +202,7 @@ mod handlers {
            generate_default_from_enum_variant::generate_default_from_enum_variant,
            generate_default_from_new::generate_default_from_new,
            generate_is_empty_from_len::generate_is_empty_from_len,
+            generate_deref::generate_deref,
            generate_derive::generate_derive,
            generate_enum_is_method::generate_enum_is_method,
            generate_enum_projection_method::generate_enum_as_method,
diff --git a/crates/ide_assists/src/tests.rs b/crates/ide_assists/src/tests.rs
index a7a923beb..49533e7d2 100644
--- a/crates/ide_assists/src/tests.rs
+++ b/crates/ide_assists/src/tests.rs
@@ -84,7 +84,8 @@ fn check_doc_test(assist_id: &str, before: &str, after: &str) {
        });
    let actual = {
-        let source_change = assist.source_change.unwrap();
+        let source_change =
+            assist.source_change.expect("Assist did not contain any source changes");
        let mut actual = before;
        if let Some(source_file_edit) = source_change.get_source_edit(file_id) {
            source_file_edit.apply(&mut actual);
@@ -121,7 +122,8 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult, assist_label:
    match (assist, expected) {
        (Some(assist), ExpectedResult::After(after)) => {
-            let source_change = assist.source_change.unwrap();
+            let source_change =
+                assist.source_change.expect("Assist did not contain any source changes");
            assert!(!source_change.source_file_edits.is_empty());
            let skip_header = source_change.source_file_edits.len() == 1
                && source_change.file_system_edits.len() == 0;
@@ -191,6 +193,7 @@ fn assist_order_field_struct() {
    let mut assists = assists.iter();
    assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
+    assert_eq!(assists.next().expect("expected assist").label, "Generate `Deref` impl using `bar`");
    assert_eq!(assists.next().expect("expected assist").label, "Generate a mut getter method");
    assert_eq!(assists.next().expect("expected assist").label, "Generate a getter method");
    assert_eq!(assists.next().expect("expected assist").label, "Generate a setter method");
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 27a22ca10..41559b43a 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -552,6 +552,33 @@ impl Default for Example {
 }
 #[test]
+fn doctest_generate_deref() {
+    check_doc_test(
+        "generate_deref",
+        r#####"
+struct A;
+struct B {
+   $0a: A
+}
+"#####,
+        r#####"
+struct A;
+struct B {
+   a: A
+}
+impl std::ops::Deref for B {
+    type Target = A;
+    fn deref(&self) -> &Self::Target {
+        &self.a
+    }
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_generate_derive() {
    check_doc_test(
        "generate_derive",
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index 9ace13e41..8e211ae1e 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -114,6 +114,8 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
        || ctx.attribute_under_caret.is_some()
        || ctx.mod_declaration_under_caret.is_some()
        || ctx.record_lit_syntax.is_some()
+        || ctx.has_trait_parent
+        || ctx.has_impl_parent
    {
        return None;
    }
@@ -1077,4 +1079,75 @@ fn main() {
            "#]],
        );
    }
+    #[test]
+    fn no_flyimports_in_traits_and_impl_declarations() {
+        check(
+            r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+trait Foo {
+    som$0
+}
+"#,
+            expect![[r#""#]],
+        );
+        check(
+            r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo;
+impl Foo {
+    som$0
+}
+"#,
+            expect![[r#""#]],
+        );
+        check(
+            r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo;
+trait Bar {}
+impl Bar for Foo {
+    som$0
+}
+"#,
+            expect![[r#""#]],
+        );
+    }
+    #[test]
+    fn no_inherent_candidates_proposed() {
+        check(
+            r#"
+mod baz {
+    pub trait DefDatabase {
+        fn method1(&self);
+    }
+    pub trait HirDatabase: DefDatabase {
+        fn method2(&self);
+    }
+}
+mod bar {
+    fn test(db: &dyn crate::baz::HirDatabase) {
+        db.metho$0
+    }
+}
+            "#,
+            expect![[r#""#]],
+        );
+    }
 }
diff --git a/crates/ide_db/src/apply_change.rs b/crates/ide_db/src/apply_change.rs
index 6c67425d7..eac5ef6b9 100644
--- a/crates/ide_db/src/apply_change.rs
+++ b/crates/ide_db/src/apply_change.rs
@@ -201,7 +201,7 @@ impl RootDatabase {
            hir::db::InternImplTraitIdQuery
            hir::db::InternClosureQuery
            hir::db::AssociatedTyValueQuery
-            hir::db::TraitSolveQuery
+            hir::db::TraitSolveQueryQuery
            // SymbolsDatabase
            crate::symbol_index::FileSymbolsQuery
diff --git a/crates/ide_db/src/call_info.rs b/crates/ide_db/src/call_info.rs
index e583a52f4..bad277a95 100644
--- a/crates/ide_db/src/call_info.rs
+++ b/crates/ide_db/src/call_info.rs
@@ -4,8 +4,9 @@ use either::Either;
 use hir::{HasAttrs, HirDisplay, Semantics, Type};
 use stdx::format_to;
 use syntax::{
+    algo,
    ast::{self, ArgListOwner, NameOwner},
-    match_ast, AstNode, SyntaxNode, SyntaxToken, TextRange, TextSize,
+    match_ast, AstNode, Direction, SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
 use crate::RootDatabase;
@@ -43,7 +44,12 @@ pub fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo>
    let sema = Semantics::new(db);
    let file = sema.parse(position.file_id);
    let file = file.syntax();
-    let token = file.token_at_offset(position.offset).next()?;
+    let token = file
+        .token_at_offset(position.offset)
+        .left_biased()
+        // if the cursor is sandwiched between two space tokens and the call is unclosed
+        // this prevents us from leaving the CallExpression
+        .and_then(|tok| algo::skip_trivia_token(tok, Direction::Prev))?;
    let token = sema.descend_into_macros(token);
    let (callable, active_parameter) = call_info_impl(&sema, token)?;
diff --git a/crates/ide_db/src/call_info/tests.rs b/crates/ide_db/src/call_info/tests.rs
index 281a081a3..be1cc12de 100644
--- a/crates/ide_db/src/call_info/tests.rs
+++ b/crates/ide_db/src/call_info/tests.rs
@@ -522,3 +522,30 @@ fn main(f: fn(i32, f64) -> char) {
            "#]],
    )
 }
+#[test]
+fn call_info_for_unclosed_call() {
+    check(
+        r#"
+fn foo(foo: u32, bar: u32) {}
+fn main() {
+    foo($0
+}"#,
+        expect![[r#"
+            fn foo(foo: u32, bar: u32)
+            (<foo: u32>, bar: u32)
+        "#]],
+    );
+    // check with surrounding space
+    check(
+        r#"
+fn foo(foo: u32, bar: u32) {}
+fn main() {
+    foo( $0
+}"#,
+        expect![[r#"
+            fn foo(foo: u32, bar: u32)
+            (<foo: u32>, bar: u32)
+        "#]],
+    )
+}
diff --git a/crates/ide_db/src/helpers.rs b/crates/ide_db/src/helpers.rs
index 66798ea3a..720de0d1f 100644
--- a/crates/ide_db/src/helpers.rs
+++ b/crates/ide_db/src/helpers.rs
@@ -1,6 +1,7 @@
 //! A module with ide helpers for high-level ide features.
 pub mod insert_use;
 pub mod import_assets;
+pub mod rust_doc;
 use std::collections::VecDeque;
@@ -113,6 +114,10 @@ impl FamousDefs<'_, '_> {
        self.find_module("core:iter")
    }
+    pub fn core_ops_Deref(&self) -> Option<Trait> {
+        self.find_trait("core:ops:Deref")
+    }
    fn find_trait(&self, path: &str) -> Option<Trait> {
        match self.find_def(path)? {
            hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
diff --git a/crates/ide_db/src/helpers/famous_defs_fixture.rs b/crates/ide_db/src/helpers/famous_defs_fixture.rs
index 4d79e064e..29ae12dcf 100644
--- a/crates/ide_db/src/helpers/famous_defs_fixture.rs
+++ b/crates/ide_db/src/helpers/famous_defs_fixture.rs
@@ -112,6 +112,12 @@ pub mod ops {
        type Output;
        extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
    }
+    #[lang = "deref"]
+    pub trait Deref {
+        type Target: ?Sized;
+        fn deref(&self) -> &Self::Target;
+    }
 }
 pub mod option {
@@ -141,3 +147,5 @@ mod return_keyword {}
 /// Docs for prim_str
 mod prim_str {}
+pub use core::ops;
+\ No newline at end of file
diff --git a/crates/ide_db/src/helpers/import_assets.rs b/crates/ide_db/src/helpers/import_assets.rs
index 8ce648367..91d6a4665 100644
--- a/crates/ide_db/src/helpers/import_assets.rs
+++ b/crates/ide_db/src/helpers/import_assets.rs
@@ -436,6 +436,8 @@ fn trait_applicable_items(
    })
    .collect();
+    let related_dyn_traits =
+        trait_candidate.receiver_ty.applicable_inherent_traits(db).collect::<FxHashSet<_>>();
    let mut located_imports = FxHashSet::default();
    if trait_assoc_item {
@@ -451,12 +453,16 @@ fn trait_applicable_items(
                            return None;
                        }
                    }
+                    let located_trait = assoc.containing_trait(db)?;
+                    if related_dyn_traits.contains(&located_trait) {
+                        return None;
+                    }
-                    let item = ItemInNs::from(ModuleDef::from(assoc.containing_trait(db)?));
+                    let trait_item = ItemInNs::from(ModuleDef::from(located_trait));
                    let original_item = assoc_to_item(assoc);
                    located_imports.insert(LocatedImport::new(
-                        mod_path(item)?,
+                        mod_path(trait_item)?,
-                        item,
+                        trait_item,
                        original_item,
                        mod_path(original_item),
                    ));
@@ -473,11 +479,15 @@ fn trait_applicable_items(
            |_, function| {
                let assoc = function.as_assoc_item(db)?;
                if required_assoc_items.contains(&assoc) {
-                    let item = ItemInNs::from(ModuleDef::from(assoc.containing_trait(db)?));
+                    let located_trait = assoc.containing_trait(db)?;
+                    if related_dyn_traits.contains(&located_trait) {
+                        return None;
+                    }
+                    let trait_item = ItemInNs::from(ModuleDef::from(located_trait));
                    let original_item = assoc_to_item(assoc);
                    located_imports.insert(LocatedImport::new(
-                        mod_path(item)?,
+                        mod_path(trait_item)?,
-                        item,
+                        trait_item,
                        original_item,
                        mod_path(original_item),
                    ));
diff --git a/crates/ide_db/src/helpers/rust_doc.rs b/crates/ide_db/src/helpers/rust_doc.rs
new file mode 100644
index 000000000..e27e23867
--- /dev/null
+++ b/crates/ide_db/src/helpers/rust_doc.rs
@@ -0,0 +1,34 @@
+//! Rustdoc specific doc comment handling
+// stripped down version of https://github.com/rust-lang/rust/blob/392ba2ba1a7d6c542d2459fb8133bebf62a4a423/src/librustdoc/html/markdown.rs#L810-L933
+pub fn is_rust_fence(s: &str) -> bool {
+    let mut seen_rust_tags = false;
+    let mut seen_other_tags = false;
+    let tokens = s
+        .trim()
+        .split(|c| c == ',' || c == ' ' || c == '\t')
+        .map(str::trim)
+        .filter(|t| !t.is_empty());
+    for token in tokens {
+        match token {
+            "should_panic" | "no_run" | "ignore" | "allow_fail" => {
+                seen_rust_tags = !seen_other_tags
+            }
+            "rust" => seen_rust_tags = true,
+            "test_harness" | "compile_fail" => seen_rust_tags = !seen_other_tags || seen_rust_tags,
+            x if x.starts_with("edition") => {}
+            x if x.starts_with('E') && x.len() == 5 => {
+                if x[1..].parse::<u32>().is_ok() {
+                    seen_rust_tags = !seen_other_tags || seen_rust_tags;
+                } else {
+                    seen_other_tags = true;
+                }
+            }
+            _ => seen_other_tags = true,
+        }
+    }
+    !seen_other_tags || seen_rust_tags
+}
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index 9ba98f7fb..a7c8c13c6 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -213,7 +213,7 @@ fn doc_comment_text(comment: &ast::Comment) -> SmolStr {
    // Quote the string
    // Note that `tt::Literal` expect an escaped string
-    let text = format!("{:?}", text.escape_debug().to_string());
+    let text = format!("\"{}\"", text.escape_debug());
    text.into()
 }
diff --git a/crates/mbe/src/tests/expand.rs b/crates/mbe/src/tests/expand.rs
index e02d038b6..3a1d840ea 100644
--- a/crates/mbe/src/tests/expand.rs
+++ b/crates/mbe/src/tests/expand.rs
@@ -936,7 +936,25 @@ fn test_meta_doc_comments() {
                MultiLines Doc
            */
        }"#,
-        "# [doc = \" Single Line Doc 1\"] # [doc = \"\\\\n                MultiLines Doc\\\\n            \"] fn bar () {}",
+        "# [doc = \" Single Line Doc 1\"] # [doc = \"\\n                MultiLines Doc\\n            \"] fn bar () {}",
+    );
+}
+#[test]
+fn test_meta_extended_key_value_attributes() {
+    parse_macro(
+        r#"
+macro_rules! foo {
+    (#[$i:meta]) => (
+        #[$ i]
+        fn bar() {}
+    )
+}
+"#,
+    )
+    .assert_expand_items(
+        r#"foo! { #[doc = concat!("The `", "bla", "` lang item.")] }"#,
+        r#"# [doc = concat ! ("The `" , "bla" , "` lang item.")] fn bar () {}"#,
    );
 }
@@ -959,7 +977,27 @@ fn test_meta_doc_comments_non_latin() {
                莊生曉夢迷蝴蝶，望帝春心託杜鵑。
            */
        }"#,
-        "# [doc = \" 錦瑟無端五十弦，一弦一柱思華年。\"] # [doc = \"\\\\n                莊生曉夢迷蝴蝶，望帝春心託杜鵑。\\\\n            \"] fn bar () {}",
+        "# [doc = \" 錦瑟無端五十弦，一弦一柱思華年。\"] # [doc = \"\\n                莊生曉夢迷蝴蝶，望帝春心託杜鵑。\\n            \"] fn bar () {}",
+    );
+}
+#[test]
+fn test_meta_doc_comments_escaped_characters() {
+    parse_macro(
+        r#"
+        macro_rules! foo {
+            ($(#[$ i:meta])+) => (
+                $(#[$ i])+
+                fn bar() {}
+            )
+        }
+"#,
+    )
+    .assert_expand_items(
+        r#"foo! {
+            /// \ " '
+        }"#,
+        r#"# [doc = " \\ \" \'"] fn bar () {}"#,
    );
 }
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index cebb8f400..9bdf0b5fa 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -76,42 +76,7 @@ pub(crate) mod fragments {
    // Parse a meta item , which excluded [], e.g : #[ MetaItem ]
    pub(crate) fn meta_item(p: &mut Parser) {
-        fn is_delimiter(p: &mut Parser) -> bool {
+        attributes::meta(p);
-            matches!(p.current(), T!['{'] | T!['('] | T!['['])
-        }
-        if is_delimiter(p) {
-            items::token_tree(p);
-            return;
-        }
-        let m = p.start();
-        while !p.at(EOF) {
-            if is_delimiter(p) {
-                items::token_tree(p);
-                break;
-            } else {
-                // https://doc.rust-lang.org/reference/attributes.html
-                // https://doc.rust-lang.org/reference/paths.html#simple-paths
-                // The start of an meta must be a simple path
-                match p.current() {
-                    IDENT | T![super] | T![self] | T![crate] => p.bump_any(),
-                    T![=] => {
-                        p.bump_any();
-                        match p.current() {
-                            c if c.is_literal() => p.bump_any(),
-                            T![true] | T![false] => p.bump_any(),
-                            _ => {}
-                        }
-                        break;
-                    }
-                    _ if p.at(T![::]) => p.bump(T![::]),
-                    _ => break,
-                }
-            }
-        }
-        m.complete(p, TOKEN_TREE);
    }
    pub(crate) fn item(p: &mut Parser) {
diff --git a/crates/parser/src/grammar/attributes.rs b/crates/parser/src/grammar/attributes.rs
index 96791ffc2..124a10eb2 100644
--- a/crates/parser/src/grammar/attributes.rs
+++ b/crates/parser/src/grammar/attributes.rs
@@ -14,6 +14,21 @@ pub(super) fn outer_attrs(p: &mut Parser) {
    }
 }
+pub(super) fn meta(p: &mut Parser) {
+    paths::use_path(p);
+    match p.current() {
+        T![=] => {
+            p.bump(T![=]);
+            if expressions::expr(p).0.is_none() {
+                p.error("expected expression");
+            }
+        }
+        T!['('] | T!['['] | T!['{'] => items::token_tree(p),
+        _ => {}
+    }
+}
 fn attr(p: &mut Parser, inner: bool) {
    let attr = p.start();
    assert!(p.at(T![#]));
@@ -25,18 +40,7 @@ fn attr(p: &mut Parser, inner: bool) {
    }
    if p.eat(T!['[']) {
-        paths::use_path(p);
+        meta(p);
-        match p.current() {
-            T![=] => {
-                p.bump(T![=]);
-                if expressions::expr(p).0.is_none() {
-                    p.error("expected expression");
-                }
-            }
-            T!['('] | T!['['] | T!['{'] => items::token_tree(p),
-            _ => {}
-        }
        if !p.eat(T![']']) {
            p.error("expected `]`");
diff --git a/crates/parser/src/grammar/types.rs b/crates/parser/src/grammar/types.rs
index 94cbf7d85..6ae3e734f 100644
--- a/crates/parser/src/grammar/types.rs
+++ b/crates/parser/src/grammar/types.rs
@@ -283,17 +283,21 @@ pub(super) fn path_type(p: &mut Parser) {
 // type B = crate::foo!();
 fn path_or_macro_type_(p: &mut Parser, allow_bounds: bool) {
    assert!(paths::is_path_start(p));
+    let r = p.start();
    let m = p.start();
    paths::type_path(p);
    let kind = if p.at(T![!]) && !p.at(T![!=]) {
        items::macro_call_after_excl(p);
-        MACRO_CALL
+        m.complete(p, MACRO_CALL);
+        MACRO_TYPE
    } else {
+        m.abandon(p);
        PATH_TYPE
    };
-    let path = m.complete(p, kind);
+    let path = r.complete(p, kind);
    if allow_bounds {
        opt_type_bounds_as_dyn_trait_type(p, path);
@@ -319,7 +323,7 @@ pub(super) fn path_type_(p: &mut Parser, allow_bounds: bool) {
 fn opt_type_bounds_as_dyn_trait_type(p: &mut Parser, type_marker: CompletedMarker) {
    assert!(matches!(
        type_marker.kind(),
-        SyntaxKind::PATH_TYPE | SyntaxKind::FOR_TYPE | SyntaxKind::MACRO_CALL
+        SyntaxKind::PATH_TYPE | SyntaxKind::FOR_TYPE | SyntaxKind::MACRO_TYPE
    ));
    if !p.at(T![+]) {
        return;
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 1edaa394a..7ddea22c8 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -400,6 +400,17 @@ impl Config {
    pub fn will_rename(&self) -> bool {
        try_or!(self.caps.workspace.as_ref()?.file_operations.as_ref()?.will_rename?, false)
    }
+    pub fn change_annotation_support(&self) -> bool {
+        try_!(self
+            .caps
+            .workspace
+            .as_ref()?
+            .workspace_edit
+            .as_ref()?
+            .change_annotation_support
+            .as_ref()?)
+        .is_some()
+    }
    pub fn code_action_resolve(&self) -> bool {
        try_or!(
            self.caps
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/clippy_pass_by_ref.txt b/crates/rust-analyzer/src/diagnostics/test_data/clippy_pass_by_ref.txt
index 23ec2efba..227d96d51 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/clippy_pass_by_ref.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/clippy_pass_by_ref.txt
@@ -326,6 +326,7 @@
                            },
                        ),
                        document_changes: None,
+                        change_annotations: None,
                    },
                ),
                is_preferred: Some(
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable.txt b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable.txt
index b6acb5f42..f8adfad3b 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable.txt
@@ -179,6 +179,7 @@
                            },
                        ),
                        document_changes: None,
+                        change_annotations: None,
                    },
                ),
                is_preferred: Some(
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_hint.txt b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_hint.txt
index d765257c4..5a70d2ed7 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_hint.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_hint.txt
@@ -179,6 +179,7 @@
                            },
                        ),
                        document_changes: None,
+                        change_annotations: None,
                    },
                ),
                is_preferred: Some(
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_info.txt b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_info.txt
index 6b0d94878..04ca0c9c2 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_info.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_info.txt
@@ -179,6 +179,7 @@
                            },
                        ),
                        document_changes: None,
+                        change_annotations: None,
                    },
                ),
                is_preferred: Some(
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/snap_multi_line_fix.txt b/crates/rust-analyzer/src/diagnostics/test_data/snap_multi_line_fix.txt
index a0cfb8d33..57d2f1ae3 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/snap_multi_line_fix.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/snap_multi_line_fix.txt
@@ -339,6 +339,7 @@
                            },
                        ),
                        document_changes: None,
+                        change_annotations: None,
                    },
                ),
                is_preferred: Some(
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index e2f319f6b..ca18997e4 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -136,6 +136,7 @@ fn map_rust_child_diagnostic(
                    // FIXME: there's no good reason to use edit_map here....
                    changes: Some(edit_map),
                    document_changes: None,
+                    change_annotations: None,
                }),
                is_preferred: Some(true),
                data: None,
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 4f0c9d23c..1f59402e5 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -1410,7 +1410,7 @@ pub(crate) fn handle_open_cargo_toml(
 pub(crate) fn handle_move_item(
    snap: GlobalStateSnapshot,
    params: lsp_ext::MoveItemParams,
-) -> Result<Option<lsp_types::TextDocumentEdit>> {
+) -> Result<Vec<lsp_ext::SnippetTextEdit>> {
    let _p = profile::span("handle_move_item");
    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
    let range = from_proto::file_range(&snap, params.text_document, params.range)?;
@@ -1421,8 +1421,11 @@ pub(crate) fn handle_move_item(
    };
    match snap.analysis.move_item(range, direction)? {
-        Some(text_edit) => Ok(Some(to_proto::text_document_edit(&snap, file_id, text_edit)?)),
+        Some(text_edit) => {
-        None => Ok(None),
+            let line_index = snap.file_line_index(file_id)?;
+            Ok(to_proto::snippet_text_edit_vec(&line_index, true, text_edit))
+        }
+        None => Ok(vec![]),
    }
 }
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 81a6f22f1..b8835a534 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -312,6 +312,9 @@ pub struct SnippetWorkspaceEdit {
    pub changes: Option<HashMap<lsp_types::Url, Vec<lsp_types::TextEdit>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub document_changes: Option<Vec<SnippetDocumentChangeOperation>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub change_annotations:
+        Option<HashMap<lsp_types::ChangeAnnotationIdentifier, lsp_types::ChangeAnnotation>>,
 }
 #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
@@ -335,6 +338,9 @@ pub struct SnippetTextEdit {
    pub new_text: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub insert_text_format: Option<lsp_types::InsertTextFormat>,
+    /// The annotation id if this is an annotated
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub annotation_id: Option<lsp_types::ChangeAnnotationIdentifier>,
 }
 pub enum HoverRequest {}
@@ -407,7 +413,7 @@ pub enum MoveItem {}
 impl Request for MoveItem {
    type Params = MoveItemParams;
-    type Result = Option<lsp_types::TextDocumentEdit>;
+    type Result = Vec<SnippetTextEdit>;
    const METHOD: &'static str = "experimental/moveItem";
 }
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index b3d4c6ec5..6ea775d68 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -248,7 +248,7 @@ impl GlobalState {
                                }
                            };
-                            self.report_progress("fetching", state, msg, None);
+                            self.report_progress("Fetching", state, msg, None);
                        }
                        Task::FetchBuildData(progress) => {
                            let (state, msg) = match progress {
@@ -266,7 +266,7 @@ impl GlobalState {
                            };
                            if let Some(state) = state {
-                                self.report_progress("loading", state, msg, None);
+                                self.report_progress("Loading", state, msg, None);
                            }
                        }
                    }
@@ -298,7 +298,7 @@ impl GlobalState {
                        }
                    };
-                    self.report_progress("indexing", state, message, Some(fraction));
+                    self.report_progress("Indexing", state, message, Some(fraction));
                }
            }
            Event::Vfs(mut task) => {
@@ -330,7 +330,7 @@ impl GlobalState {
                                Progress::End
                            };
                            self.report_progress(
-                                "roots scanned",
+                                "Roots Scanned",
                                state,
                                Some(format!("{}/{}", n_done, n_total)),
                                Some(Progress::fraction(n_done, n_total)),
diff --git a/crates/rust-analyzer/src/markdown.rs b/crates/rust-analyzer/src/markdown.rs
index 865eaae9b..35eaffba8 100644
--- a/crates/rust-analyzer/src/markdown.rs
+++ b/crates/rust-analyzer/src/markdown.rs
@@ -1,17 +1,7 @@
 //! Transforms markdown
+use ide_db::helpers::rust_doc::is_rust_fence;
 const RUSTDOC_FENCE: &str = "```";
-const RUSTDOC_CODE_BLOCK_ATTRIBUTES_RUST_SPECIFIC: &[&str] = &[
-    "",
-    "rust",
-    "should_panic",
-    "ignore",
-    "no_run",
-    "compile_fail",
-    "edition2015",
-    "edition2018",
-    "edition2021",
-];
 pub(crate) fn format_docs(src: &str) -> String {
    let mut processed_lines = Vec::new();
@@ -27,9 +17,7 @@ pub(crate) fn format_docs(src: &str) -> String {
            in_code_block ^= true;
            if in_code_block {
-                is_rust = header
+                is_rust = is_rust_fence(header);
-                    .split(',')
-                    .all(|sub| RUSTDOC_CODE_BLOCK_ATTRIBUTES_RUST_SPECIFIC.contains(&sub.trim()));
                if is_rust {
                    line = "```rust";
@@ -82,6 +70,12 @@ mod tests {
    }
    #[test]
+    fn test_format_docs_handles_error_codes() {
+        let comment = "```compile_fail,E0641\nlet b = 0 as *const _;\n```";
+        assert_eq!(format_docs(comment), "```rust\nlet b = 0 as *const _;\n```");
+    }
+    #[test]
    fn test_format_docs_skips_comments_in_rust_block() {
        let comment =
            "```rust\n # skip1\n# skip2\n#stay1\nstay2\n#\n #\n   #    \n #\tskip3\n\t#\t\n```";
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 8d7cb9b74..fe4d0733d 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -1,15 +1,16 @@
 //! Conversion of rust-analyzer specific types to lsp_types equivalents.
 use std::{
+    iter::once,
    path::{self, Path},
    sync::atomic::{AtomicU32, Ordering},
 };
 use ide::{
-    Annotation, AnnotationKind, Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind,
+    Annotation, AnnotationKind, Assist, AssistKind, CallInfo, Cancelable, CompletionItem,
-    CompletionRelevance, Documentation, FileId, FileRange, FileSystemEdit, Fold, FoldKind,
+    CompletionItemKind, CompletionRelevance, Documentation, FileId, FileRange, FileSystemEdit,
-    Highlight, HlMod, HlOperator, HlPunct, HlRange, HlTag, Indel, InlayHint, InlayKind,
+    Fold, FoldKind, Highlight, HlMod, HlOperator, HlPunct, HlRange, HlTag, Indel, InlayHint,
-    InsertTextFormat, Markup, NavigationTarget, ReferenceAccess, RenameError, Runnable, Severity,
+    InlayKind, InsertTextFormat, Markup, NavigationTarget, ReferenceAccess, RenameError, Runnable,
-    SourceChange, StructureNodeKind, SymbolKind, TextEdit, TextRange, TextSize,
+    Severity, SourceChange, StructureNodeKind, SymbolKind, TextEdit, TextRange, TextSize,
 };
 use itertools::Itertools;
 use serde_json::to_value;
@@ -174,6 +175,7 @@ pub(crate) fn snippet_text_edit(
        range: text_edit.range,
        new_text: text_edit.new_text,
        insert_text_format,
+        annotation_id: None,
    }
 }
@@ -688,16 +690,8 @@ pub(crate) fn goto_definition_response(
    }
 }
-pub(crate) fn text_document_edit(
+fn outside_workspace_annotation_id() -> String {
-    snap: &GlobalStateSnapshot,
+    String::from("OutsideWorkspace")
-    file_id: FileId,
-    edit: TextEdit,
-) -> Result<lsp_types::TextDocumentEdit> {
-    let text_document = optional_versioned_text_document_identifier(snap, file_id);
-    let line_index = snap.file_line_index(file_id)?;
-    let edits =
-        edit.into_iter().map(|it| lsp_types::OneOf::Left(text_edit(&line_index, it))).collect();
-    Ok(lsp_types::TextDocumentEdit { text_document, edits })
 }
 pub(crate) fn snippet_text_document_edit(
@@ -708,14 +702,21 @@ pub(crate) fn snippet_text_document_edit(
 ) -> Result<lsp_ext::SnippetTextDocumentEdit> {
    let text_document = optional_versioned_text_document_identifier(snap, file_id);
    let line_index = snap.file_line_index(file_id)?;
-    let edits = edit.into_iter().map(|it| snippet_text_edit(&line_index, is_snippet, it)).collect();
+    let mut edits: Vec<_> =
+        edit.into_iter().map(|it| snippet_text_edit(&line_index, is_snippet, it)).collect();
+    if snap.analysis.is_library_file(file_id)? && snap.config.change_annotation_support() {
+        for edit in &mut edits {
+            edit.annotation_id = Some(outside_workspace_annotation_id())
+        }
+    }
    Ok(lsp_ext::SnippetTextDocumentEdit { text_document, edits })
 }
 pub(crate) fn snippet_text_document_ops(
    snap: &GlobalStateSnapshot,
    file_system_edit: FileSystemEdit,
-) -> Vec<lsp_ext::SnippetDocumentChangeOperation> {
+) -> Cancelable<Vec<lsp_ext::SnippetDocumentChangeOperation>> {
    let mut ops = Vec::new();
    match file_system_edit {
        FileSystemEdit::CreateFile { dst, initial_contents } => {
@@ -733,6 +734,7 @@ pub(crate) fn snippet_text_document_ops(
                    range: lsp_types::Range::default(),
                    new_text: initial_contents,
                    insert_text_format: Some(lsp_types::InsertTextFormat::PlainText),
+                    annotation_id: None,
                };
                let edit_file =
                    lsp_ext::SnippetTextDocumentEdit { text_document, edits: vec![text_edit] };
@@ -742,16 +744,19 @@ pub(crate) fn snippet_text_document_ops(
        FileSystemEdit::MoveFile { src, dst } => {
            let old_uri = snap.file_id_to_url(src);
            let new_uri = snap.anchored_path(&dst);
-            let rename_file = lsp_types::ResourceOp::Rename(lsp_types::RenameFile {
+            let mut rename_file =
-                old_uri,
+                lsp_types::RenameFile { old_uri, new_uri, options: None, annotation_id: None };
-                new_uri,
+            if snap.analysis.is_library_file(src) == Ok(true)
-                options: None,
+                && snap.config.change_annotation_support()
-                annotation_id: None,
+            {
-            });
+                rename_file.annotation_id = Some(outside_workspace_annotation_id())
-            ops.push(lsp_ext::SnippetDocumentChangeOperation::Op(rename_file))
+            }
+            ops.push(lsp_ext::SnippetDocumentChangeOperation::Op(lsp_types::ResourceOp::Rename(
+                rename_file,
+            )))
        }
    }
-    ops
+    Ok(ops)
 }
 pub(crate) fn snippet_workspace_edit(
@@ -759,16 +764,35 @@ pub(crate) fn snippet_workspace_edit(
    source_change: SourceChange,
 ) -> Result<lsp_ext::SnippetWorkspaceEdit> {
    let mut document_changes: Vec<lsp_ext::SnippetDocumentChangeOperation> = Vec::new();
    for op in source_change.file_system_edits {
-        let ops = snippet_text_document_ops(snap, op);
+        let ops = snippet_text_document_ops(snap, op)?;
        document_changes.extend_from_slice(&ops);
    }
    for (file_id, edit) in source_change.source_file_edits {
        let edit = snippet_text_document_edit(&snap, source_change.is_snippet, file_id, edit)?;
        document_changes.push(lsp_ext::SnippetDocumentChangeOperation::Edit(edit));
    }
-    let workspace_edit =
+    let mut workspace_edit = lsp_ext::SnippetWorkspaceEdit {
-        lsp_ext::SnippetWorkspaceEdit { changes: None, document_changes: Some(document_changes) };
+        changes: None,
+        document_changes: Some(document_changes),
+        change_annotations: None,
+    };
+    if snap.config.change_annotation_support() {
+        workspace_edit.change_annotations = Some(
+            once((
+                outside_workspace_annotation_id(),
+                lsp_types::ChangeAnnotation {
+                    label: String::from("Edit outside of the workspace"),
+                    needs_confirmation: Some(true),
+                    description: Some(String::from(
+                        "This edit lies outside of the workspace and may affect dependencies",
+                    )),
+                },
+            ))
+            .collect(),
+        )
+    }
    Ok(workspace_edit)
 }
@@ -796,16 +820,7 @@ impl From<lsp_ext::SnippetWorkspaceEdit> for lsp_types::WorkspaceEdit {
                                lsp_types::DocumentChangeOperation::Edit(
                                    lsp_types::TextDocumentEdit {
                                        text_document: edit.text_document,
-                                        edits: edit
+                                        edits: edit.edits.into_iter().map(From::from).collect(),
-                                            .edits
-                                            .into_iter()
-                                            .map(|edit| {
-                                                lsp_types::OneOf::Left(lsp_types::TextEdit {
-                                                    range: edit.range,
-                                                    new_text: edit.new_text,
-                                                })
-                                            })
-                                            .collect(),
                                    },
                                )
                            }
@@ -813,7 +828,23 @@ impl From<lsp_ext::SnippetWorkspaceEdit> for lsp_types::WorkspaceEdit {
                        .collect(),
                )
            }),
-            change_annotations: None,
+            change_annotations: snippet_workspace_edit.change_annotations,
+        }
+    }
+}
+impl From<lsp_ext::SnippetTextEdit>
+    for lsp_types::OneOf<lsp_types::TextEdit, lsp_types::AnnotatedTextEdit>
+{
+    fn from(
+        lsp_ext::SnippetTextEdit { annotation_id, insert_text_format:_, new_text, range }: lsp_ext::SnippetTextEdit,
+    ) -> Self {
+        match annotation_id {
+            Some(annotation_id) => lsp_types::OneOf::Right(lsp_types::AnnotatedTextEdit {
+                text_edit: lsp_types::TextEdit { range, new_text },
+                annotation_id,
+            }),
+            None => lsp_types::OneOf::Left(lsp_types::TextEdit { range, new_text }),
        }
    }
 }
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index f09cdf28a..a8c1a8075 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 cov-mark = { version = "1.1", features = ["thread-local"] }
 itertools = "0.10.0"
-rowan = "0.13.0-pre.3"
+rowan = "=0.13.0-pre.3"
 rustc_lexer = { version = "714.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.7"
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index 529bd0eb1..04f97f368 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -14,10 +14,29 @@ use crate::{
 use super::NameOwner;
 pub trait GenericParamsOwnerEdit: ast::GenericParamsOwner + AstNodeEdit {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList;
    fn get_or_create_where_clause(&self) -> ast::WhereClause;
 }
 impl GenericParamsOwnerEdit for ast::Fn {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(name) = self.name() {
+                    Position::after(name.syntax)
+                } else if let Some(fn_token) = self.fn_token() {
+                    Position::after(fn_token)
+                } else if let Some(param_list) = self.param_list() {
+                    Position::before(param_list.syntax)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
    fn get_or_create_where_clause(&self) -> WhereClause {
        if self.where_clause().is_none() {
            let position = if let Some(ty) = self.ret_type() {
@@ -34,6 +53,20 @@ impl GenericParamsOwnerEdit for ast::Fn {
 }
 impl GenericParamsOwnerEdit for ast::Impl {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(imp_token) = self.impl_token() {
+                    Position::after(imp_token)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
    fn get_or_create_where_clause(&self) -> WhereClause {
        if self.where_clause().is_none() {
            let position = if let Some(items) = self.assoc_item_list() {
@@ -48,6 +81,22 @@ impl GenericParamsOwnerEdit for ast::Impl {
 }
 impl GenericParamsOwnerEdit for ast::Trait {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(name) = self.name() {
+                    Position::after(name.syntax)
+                } else if let Some(trait_token) = self.trait_token() {
+                    Position::after(trait_token)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
    fn get_or_create_where_clause(&self) -> WhereClause {
        if self.where_clause().is_none() {
            let position = if let Some(items) = self.assoc_item_list() {
@@ -62,6 +111,22 @@ impl GenericParamsOwnerEdit for ast::Trait {
 }
 impl GenericParamsOwnerEdit for ast::Struct {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(name) = self.name() {
+                    Position::after(name.syntax)
+                } else if let Some(struct_token) = self.struct_token() {
+                    Position::after(struct_token)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
    fn get_or_create_where_clause(&self) -> WhereClause {
        if self.where_clause().is_none() {
            let tfl = self.field_list().and_then(|fl| match fl {
@@ -84,6 +149,22 @@ impl GenericParamsOwnerEdit for ast::Struct {
 }
 impl GenericParamsOwnerEdit for ast::Enum {
+    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
+        match self.generic_param_list() {
+            Some(it) => it,
+            None => {
+                let position = if let Some(name) = self.name() {
+                    Position::after(name.syntax)
+                } else if let Some(enum_token) = self.enum_token() {
+                    Position::after(enum_token)
+                } else {
+                    Position::last_child_of(self.syntax())
+                };
+                create_generic_param_list(position)
+            }
+        }
+    }
    fn get_or_create_where_clause(&self) -> WhereClause {
        if self.where_clause().is_none() {
            let position = if let Some(gpl) = self.generic_param_list() {
@@ -104,6 +185,37 @@ fn create_where_clause(position: Position) {
    ted::insert(position, where_clause.syntax());
 }
+fn create_generic_param_list(position: Position) -> ast::GenericParamList {
+    let gpl = make::generic_param_list(empty()).clone_for_update();
+    ted::insert_raw(position, gpl.syntax());
+    gpl
+}
+impl ast::GenericParamList {
+    pub fn add_generic_param(&self, generic_param: ast::GenericParam) {
+        match self.generic_params().last() {
+            Some(last_param) => {
+                let mut elems = Vec::new();
+                if !last_param
+                    .syntax()
+                    .siblings_with_tokens(Direction::Next)
+                    .any(|it| it.kind() == T![,])
+                {
+                    elems.push(make::token(T![,]).into());
+                    elems.push(make::tokens::single_space().into());
+                };
+                elems.push(generic_param.syntax().clone().into());
+                let after_last_param = Position::after(last_param.syntax());
+                ted::insert_all(after_last_param, elems);
+            }
+            None => {
+                let after_l_angle = Position::after(self.l_angle_token().unwrap());
+                ted::insert(after_l_angle, generic_param.syntax())
+            }
+        }
+    }
+}
 impl ast::WhereClause {
    pub fn add_predicate(&self, predicate: ast::WherePred) {
        if let Some(pred) = self.predicates().last() {
@@ -164,3 +276,44 @@ impl ast::Use {
        ted::remove(self.syntax())
    }
 }
+#[cfg(test)]
+mod tests {
+    use std::fmt;
+    use crate::SourceFile;
+    use super::*;
+    fn ast_mut_from_text<N: AstNode>(text: &str) -> N {
+        let parse = SourceFile::parse(text);
+        parse.tree().syntax().descendants().find_map(N::cast).unwrap().clone_for_update()
+    }
+    #[test]
+    fn test_create_generic_param_list() {
+        fn check_create_gpl<N: GenericParamsOwnerEdit + fmt::Display>(before: &str, after: &str) {
+            let gpl_owner = ast_mut_from_text::<N>(before);
+            gpl_owner.get_or_create_generic_param_list();
+            assert_eq!(gpl_owner.to_string(), after);
+        }
+        check_create_gpl::<ast::Fn>("fn foo", "fn foo<>");
+        check_create_gpl::<ast::Fn>("fn foo() {}", "fn foo<>() {}");
+        check_create_gpl::<ast::Impl>("impl", "impl<>");
+        check_create_gpl::<ast::Impl>("impl Struct {}", "impl<> Struct {}");
+        check_create_gpl::<ast::Impl>("impl Trait for Struct {}", "impl<> Trait for Struct {}");
+        check_create_gpl::<ast::Trait>("trait Trait<>", "trait Trait<>");
+        check_create_gpl::<ast::Trait>("trait Trait<> {}", "trait Trait<> {}");
+        check_create_gpl::<ast::Struct>("struct A", "struct A<>");
+        check_create_gpl::<ast::Struct>("struct A;", "struct A<>;");
+        check_create_gpl::<ast::Struct>("struct A();", "struct A<>();");
+        check_create_gpl::<ast::Struct>("struct A {}", "struct A<> {}");
+        check_create_gpl::<ast::Enum>("enum E", "enum E<>");
+        check_create_gpl::<ast::Enum>("enum E {", "enum E<> {");
+    }
+}
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index c6a7b99b7..94d4f2cf0 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -29,9 +29,13 @@ pub fn ty(text: &str) -> ast::Type {
 pub fn ty_unit() -> ast::Type {
    ty("()")
 }
-// FIXME: handle types of length == 1
 pub fn ty_tuple(types: impl IntoIterator<Item = ast::Type>) -> ast::Type {
-    let contents = types.into_iter().join(", ");
+    let mut count: usize = 0;
+    let mut contents = types.into_iter().inspect(|_| count += 1).join(", ");
+    if count == 1 {
+        contents.push(',');
+    }
    ty(&format!("({})", contents))
 }
 // FIXME: handle path to type
@@ -292,11 +296,13 @@ pub fn wildcard_pat() -> ast::WildcardPat {
 /// Creates a tuple of patterns from an iterator of patterns.
 ///
-/// Invariant: `pats` must be length > 1
+/// Invariant: `pats` must be length > 0
-///
-/// FIXME handle `pats` length == 1
 pub fn tuple_pat(pats: impl IntoIterator<Item = ast::Pat>) -> ast::TuplePat {
-    let pats_str = pats.into_iter().map(|p| p.to_string()).join(", ");
+    let mut count: usize = 0;
+    let mut pats_str = pats.into_iter().inspect(|_| count += 1).join(", ");
+    if count == 1 {
+        pats_str.push(',');
+    }
    return from_text(&format!("({})", pats_str));
    fn from_text(text: &str) -> ast::TuplePat {
diff --git a/crates/syntax/src/ted.rs b/crates/syntax/src/ted.rs
index 177d4ff67..450f2e447 100644
--- a/crates/syntax/src/ted.rs
+++ b/crates/syntax/src/ted.rs
@@ -165,6 +165,13 @@ fn ws_between(left: &SyntaxElement, right: &SyntaxElement) -> Option<SyntaxToken
    if right.kind() == T![;] || right.kind() == T![,] {
        return None;
    }
+    if left.kind() == T![<] || right.kind() == T![>] {
+        return None;
+    }
+    if left.kind() == T![&] && right.kind() == SyntaxKind::LIFETIME {
+        return None;
+    }
    if right.kind() == SyntaxKind::USE {
        let indent = IndentLevel::from_element(left);
        return Some(make::tokens::whitespace(&format!("\n{}", indent)));
diff --git a/crates/syntax/test_data/parser/inline/ok/0117_macro_call_type.rast b/crates/syntax/test_data/parser/inline/ok/0117_macro_call_type.rast
index 3016a6574..1ff3f7656 100644
--- a/crates/syntax/test_data/parser/inline/ok/0117_macro_call_type.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0117_macro_call_type.rast
@@ -7,15 +7,16 @@ [email protected]
    [email protected] " "
    [email protected] "="
    [email protected] " "
-    [email protected]
+    [email protected]
-      [email protected]
+      [email protected]
-        [email protected]
+        [email protected]
-          [email protected]
+          [email protected]
-            [email protected] "foo"
+            [email protected]
-      [email protected] "!"
+              [email protected] "foo"
-      [email protected]
+        [email protected] "!"
-        [email protected] "("
+        [email protected]
-        [email protected] ")"
+          [email protected] "("
+          [email protected] ")"
    [email protected] ";"
  [email protected] "\n"
  [email protected]
@@ -26,19 +27,20 @@ [email protected]
    [email protected] " "
    [email protected] "="
    [email protected] " "
-    [email protected]
+    [email protected]
-      [email protected]
+      [email protected]
-        [email protected]
+        [email protected]
-          [email protected]
+          [email protected]
-            [email protected]
+            [email protected]
-              [email protected] "crate"
+              [email protected]
-        [email protected] "::"
+                [email protected] "crate"
-        [email protected]
+          [email protected] "::"
-          [email protected]
+          [email protected]
-            [email protected] "foo"
+            [email protected]
-      [email protected] "!"
+              [email protected] "foo"
-      [email protected]
+        [email protected] "!"
-        [email protected] "("
+        [email protected]
-        [email protected] ")"
+          [email protected] "("
+          [email protected] ")"
    [email protected] ";"
  [email protected] "\n"
diff --git a/docs/dev/README.md b/docs/dev/README.md
index f74f7d8eb..d0e6d29d8 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -235,14 +235,14 @@ We don't do "patch" releases, unless something truly egregious comes up.
 There are three sets of people with extra permissions:
-* rust-analyzer GitHub organization (**admins**)[https://github.com/orgs/rust-analyzer/people?query=role:owner] (which include current t-compiler leads).
+* rust-analyzer GitHub organization [**admins**](https://github.com/orgs/rust-analyzer/people?query=role:owner) (which include current t-compiler leads).
  Admins have full access to the org.
-* (**review**)[https://github.com/orgs/rust-analyzer/teams/review] team in the organization.
+* [**review**](https://github.com/orgs/rust-analyzer/teams/review) team in the organization.
  Reviewers have `r+` access to all of organization's repositories and publish rights on crates.io.
  They also have direct commit access, but all changes should via bors queue.
  It's ok to self-approve if you think you know what you are doing!
  bors should automatically sync the permissions.
-* (**triage**)[https://github.com/orgs/rust-analyzer/teams/triage] team in the organization.
+* [**triage**](https://github.com/orgs/rust-analyzer/teams/triage) team in the organization.
  This team can label and close issues.
 Note that at the time being you need to be a member of the org yourself to view the links.
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index a46121bb2..a112477de 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -1,8 +1,8 @@
 <!---
-lsp_ext.rs hash: faae991334a151d0
+lsp_ext.rs hash: 28a9d5a24b7ca396
 If you need to change the above hash to make the test pass, please check if you
-need to adjust this doc as well and ping this  issue:
+need to adjust this doc as well and ping this issue:
  https://github.com/rust-analyzer/rust-analyzer/issues/4604
@@ -46,6 +46,7 @@ If this capability is set, `WorkspaceEdit`s returned from `codeAction` requests
 ```typescript
 interface SnippetTextEdit extends TextEdit {
    insertTextFormat?: InsertTextFormat;
+    annotationId?: ChangeAnnotationIdentifier;
 }
 ```
@@ -620,7 +621,7 @@ This request is sent from client to server to move item under cursor or selectio
 **Request:** `MoveItemParams`
-**Response:** `TextDocumentEdit | null`
+**Response:** `SnippetTextEdit[]`
 ```typescript
 export interface MoveItemParams {
diff --git a/docs/dev/style.md b/docs/dev/style.md
index 7c47c26b2..078c478d4 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -159,7 +159,7 @@ More than one mark per test / code branch doesn't add significantly to understan
 Do not use `#[should_panic]` tests.
 Instead, explicitly check for `None`, `Err`, etc.
-**Rationale:**a `#[should_panic]` is a tool for library authors, to makes sure that API does not fail silently, when misused.
+**Rationale:** `#[should_panic]` is a tool for library authors, to makes sure that API does not fail silently, when misused.
 `rust-analyzer` is not a library, we don't need to test for API misuse, and we have to handle any user input without panics.
 Panic messages in the logs from the `#[should_panic]` tests are confusing.
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 1a0805bd3..4092435db 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -148,34 +148,16 @@ export function moveItem(ctx: Ctx, direction: ra.Direction): Cmd {
        const client = ctx.client;
        if (!editor || !client) return;
-        const edit = await client.sendRequest(ra.moveItem, {
+        const lcEdits = await client.sendRequest(ra.moveItem, {
            range: client.code2ProtocolConverter.asRange(editor.selection),
            textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
            direction
        });
-        if (!edit) return;
+        if (!lcEdits) return;
-        let cursor: vscode.Position | null = null;
+        const edits = client.protocol2CodeConverter.asTextEdits(lcEdits);
+        await applySnippetTextEdits(editor, edits);
-        await editor.edit((builder) => {
-            client.protocol2CodeConverter.asTextEdits(edit.edits).forEach((edit: any) => {
-                builder.replace(edit.range, edit.newText);
-                if (direction === ra.Direction.Up) {
-                    if (!cursor || edit.range.end.isBeforeOrEqual(cursor)) {
-                        cursor = edit.range.end;
-                    }
-                } else {
-                    if (!cursor || edit.range.end.isAfterOrEqual(cursor)) {
-                        cursor = edit.range.end;
-                    }
-                }
-            });
-        }).then(() => {
-            const newPosition = cursor ?? editor.selection.start;
-            editor.selection = new vscode.Selection(newPosition, newPosition);
-        });
    };
 }
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index e453bb9e0..f78de894b 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -129,7 +129,7 @@ export interface OpenCargoTomlParams {
    textDocument: lc.TextDocumentIdentifier;
 }
-export const moveItem = new lc.RequestType<MoveItemParams, lc.TextDocumentEdit | void, void>("experimental/moveItem");
+export const moveItem = new lc.RequestType<MoveItemParams, lc.TextEdit[], void>("experimental/moveItem");
 export interface MoveItemParams {
    textDocument: lc.TextDocumentIdentifier;
diff --git a/xtask/src/tidy.rs b/xtask/src/tidy.rs
index 50d9efccd..c3c785eff 100644
--- a/xtask/src/tidy.rs
+++ b/xtask/src/tidy.rs
@@ -224,7 +224,7 @@ Apache-2.0 OR BSL-1.0
 Apache-2.0 OR MIT
 Apache-2.0/MIT
 BSD-3-Clause
-CC0-1.0
+CC0-1.0 OR Artistic-2.0
 ISC
 MIT
 MIT / Apache-2.0