47 files changed, 1136 insertions, 332 deletions
diff --git a/crates/assists/src/assist_context.rs b/crates/assists/src/assist_context.rs
index 69499ea32..80cf9aba1 100644
--- a/crates/assists/src/assist_context.rs
+++ b/crates/assists/src/assist_context.rs
@@ -4,10 +4,10 @@ use std::mem;
 use algo::find_covering_element;
 use hir::Semantics;
-use ide_db::base_db::{FileId, FileRange};
+use ide_db::base_db::{AnchoredPathBuf, FileId, FileRange};
 use ide_db::{
    label::Label,
-    source_change::{SourceChange, SourceFileEdit},
+    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
    RootDatabase,
 };
 use syntax::{
@@ -209,6 +209,7 @@ pub(crate) struct AssistBuilder {
    file_id: FileId,
    is_snippet: bool,
    source_file_edits: Vec<SourceFileEdit>,
+    file_system_edits: Vec<FileSystemEdit>,
 }
 impl AssistBuilder {
@@ -218,6 +219,7 @@ impl AssistBuilder {
            file_id,
            is_snippet: false,
            source_file_edits: Vec::default(),
+            file_system_edits: Vec::default(),
        }
    }
@@ -282,12 +284,17 @@ impl AssistBuilder {
            algo::diff(&node, &new).into_text_edit(&mut self.edit);
        }
    }
+    pub(crate) fn create_file(&mut self, dst: AnchoredPathBuf, content: impl Into<String>) {
+        let file_system_edit =
+            FileSystemEdit::CreateFile { dst: dst.clone(), initial_contents: content.into() };
+        self.file_system_edits.push(file_system_edit);
+    }
    fn finish(mut self) -> SourceChange {
        self.commit();
        SourceChange {
            source_file_edits: mem::take(&mut self.source_file_edits),
-            file_system_edits: Default::default(),
+            file_system_edits: mem::take(&mut self.file_system_edits),
            is_snippet: self.is_snippet,
        }
    }
diff --git a/crates/assists/src/handlers/extract_module_to_file.rs b/crates/assists/src/handlers/extract_module_to_file.rs
new file mode 100644
index 000000000..50bf67ef7
--- /dev/null
+++ b/crates/assists/src/handlers/extract_module_to_file.rs
@@ -0,0 +1,133 @@
+use ast::edit::IndentLevel;
+use ide_db::base_db::AnchoredPathBuf;
+use syntax::{
+    ast::{self, edit::AstNodeEdit, NameOwner},
+    AstNode,
+};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+// Assist: extract_module_to_file
+//
+// This assist extract module to file.
+//
+// ```
+// mod foo {<|>
+//     fn t() {}
+// }
+// ```
+// ->
+// ```
+// mod foo;
+// ```
+pub(crate) fn extract_module_to_file(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let module_ast = ctx.find_node_at_offset::<ast::Module>()?;
+    let module_name = module_ast.name()?;
+    let module_def = ctx.sema.to_def(&module_ast)?;
+    let parent_module = module_def.parent(ctx.db())?;
+    let module_items = module_ast.item_list()?;
+    let target = module_ast.syntax().text_range();
+    let anchor_file_id = ctx.frange.file_id;
+    acc.add(
+        AssistId("extract_module_to_file", AssistKind::RefactorExtract),
+        "Extract module to file",
+        target,
+        |builder| {
+            let path = {
+                let dir = match parent_module.name(ctx.db()) {
+                    Some(name) if !parent_module.is_mod_rs(ctx.db()) => format!("{}/", name),
+                    _ => String::new(),
+                };
+                format!("./{}{}.rs", dir, module_name)
+            };
+            let contents = {
+                let items = module_items.dedent(IndentLevel(1)).to_string();
+                let mut items =
+                    items.trim_start_matches('{').trim_end_matches('}').trim().to_string();
+                if !items.is_empty() {
+                    items.push('\n');
+                }
+                items
+            };
+            builder.replace(target, format!("mod {};", module_name));
+            let dst = AnchoredPathBuf { anchor: anchor_file_id, path };
+            builder.create_file(dst, contents);
+        },
+    )
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::check_assist;
+    use super::*;
+    #[test]
+    fn extract_from_root() {
+        check_assist(
+            extract_module_to_file,
+            r#"
+mod tests {<|>
+    #[test] fn t() {}
+}
+"#,
+            r#"
+//- /main.rs
+mod tests;
+//- /tests.rs
+#[test] fn t() {}
+"#,
+        );
+    }
+    #[test]
+    fn extract_from_submodule() {
+        check_assist(
+            extract_module_to_file,
+            r#"
+//- /main.rs
+mod submod;
+//- /submod.rs
+mod inner<|> {
+    fn f() {}
+}
+fn g() {}
+"#,
+            r#"
+//- /submod.rs
+mod inner;
+fn g() {}
+//- /submod/inner.rs
+fn f() {}
+"#,
+        );
+    }
+    #[test]
+    fn extract_from_mod_rs() {
+        check_assist(
+            extract_module_to_file,
+            r#"
+//- /main.rs
+mod submodule;
+//- /submodule/mod.rs
+mod inner<|> {
+    fn f() {}
+}
+fn g() {}
+"#,
+            r#"
+//- /submodule/mod.rs
+mod inner;
+fn g() {}
+//- /submodule/inner.rs
+fn f() {}
+"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/invert_if.rs b/crates/assists/src/handlers/invert_if.rs
index 91e2f5c8c..f9c33b3f7 100644
--- a/crates/assists/src/handlers/invert_if.rs
+++ b/crates/assists/src/handlers/invert_if.rs
@@ -78,6 +78,15 @@ mod tests {
    }
    #[test]
+    fn invert_if_remove_not_parentheses() {
+        check_assist(
+            invert_if,
+            "fn f() { i<|>f !(x == 3 || x == 4 || x == 5) { 3 * 2 } else { 1 } }",
+            "fn f() { if x == 3 || x == 4 || x == 5 { 1 } else { 3 * 2 } }",
+        )
+    }
+    #[test]
    fn invert_if_remove_inequality() {
        check_assist(
            invert_if,
diff --git a/crates/assists/src/handlers/remove_unused_param.rs b/crates/assists/src/handlers/remove_unused_param.rs
index 1ff5e92b0..f72dd49ed 100644
--- a/crates/assists/src/handlers/remove_unused_param.rs
+++ b/crates/assists/src/handlers/remove_unused_param.rs
@@ -2,9 +2,10 @@ use ide_db::{defs::Definition, search::Reference};
 use syntax::{
    algo::find_node_at_range,
    ast::{self, ArgListOwner},
-    AstNode, SyntaxNode, TextRange, T,
+    AstNode, SyntaxKind, SyntaxNode, TextRange, T,
 };
 use test_utils::mark;
+use SyntaxKind::WHITESPACE;
 use crate::{
    assist_context::AssistBuilder, utils::next_prev, AssistContext, AssistId, AssistKind, Assists,
@@ -56,7 +57,7 @@ pub(crate) fn remove_unused_param(acc: &mut Assists, ctx: &AssistContext) -> Opt
        "Remove unused parameter",
        param.syntax().text_range(),
        |builder| {
-            builder.delete(range_with_coma(param.syntax()));
+            builder.delete(range_to_remove(param.syntax()));
            for usage in fn_def.usages(&ctx.sema).all() {
                process_usage(ctx, builder, usage, param_position);
            }
@@ -80,19 +81,34 @@ fn process_usage(
    let arg = call_expr.arg_list()?.args().nth(arg_to_remove)?;
    builder.edit_file(usage.file_range.file_id);
-    builder.delete(range_with_coma(arg.syntax()));
+    builder.delete(range_to_remove(arg.syntax()));
    Some(())
 }
-fn range_with_coma(node: &SyntaxNode) -> TextRange {
+fn range_to_remove(node: &SyntaxNode) -> TextRange {
-    let up_to = next_prev().find_map(|dir| {
+    let up_to_comma = next_prev().find_map(|dir| {
        node.siblings_with_tokens(dir)
            .filter_map(|it| it.into_token())
            .find(|it| it.kind() == T![,])
+            .map(|it| (dir, it))
    });
-    let up_to = up_to.map_or(node.text_range(), |it| it.text_range());
+    if let Some((dir, token)) = up_to_comma {
-    node.text_range().cover(up_to)
+        if node.next_sibling().is_some() {
+            let up_to_space = token
+                .siblings_with_tokens(dir)
+                .skip(1)
+                .take_while(|it| it.kind() == WHITESPACE)
+                .last()
+                .and_then(|it| it.into_token());
+            return node
+                .text_range()
+                .cover(up_to_space.map_or(token.text_range(), |it| it.text_range()));
+        }
+        node.text_range().cover(token.text_range())
+    } else {
+        node.text_range()
+    }
 }
 #[cfg(test)]
@@ -119,6 +135,57 @@ fn b() { foo(9, ) }
    }
    #[test]
+    fn remove_unused_first_param() {
+        check_assist(
+            remove_unused_param,
+            r#"
+fn foo(<|>x: i32, y: i32) { y; }
+fn a() { foo(1, 2) }
+fn b() { foo(1, 2,) }
+"#,
+            r#"
+fn foo(y: i32) { y; }
+fn a() { foo(2) }
+fn b() { foo(2,) }
+"#,
+        );
+    }
+    #[test]
+    fn remove_unused_single_param() {
+        check_assist(
+            remove_unused_param,
+            r#"
+fn foo(<|>x: i32) { 0; }
+fn a() { foo(1) }
+fn b() { foo(1, ) }
+"#,
+            r#"
+fn foo() { 0; }
+fn a() { foo() }
+fn b() { foo( ) }
+"#,
+        );
+    }
+    #[test]
+    fn remove_unused_surrounded_by_parms() {
+        check_assist(
+            remove_unused_param,
+            r#"
+fn foo(x: i32, <|>y: i32, z: i32) { x; }
+fn a() { foo(1, 2, 3) }
+fn b() { foo(1, 2, 3,) }
+"#,
+            r#"
+fn foo(x: i32, z: i32) { x; }
+fn a() { foo(1, 3) }
+fn b() { foo(1, 3,) }
+"#,
+        );
+    }
+    #[test]
    fn remove_unused_qualified_call() {
        check_assist(
            remove_unused_param,
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 6e736ccb3..6b89b2d04 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -129,6 +129,7 @@ mod handlers {
    mod convert_integer_literal;
    mod early_return;
    mod expand_glob_import;
+    mod extract_module_to_file;
    mod extract_struct_from_enum_variant;
    mod extract_variable;
    mod fill_match_arms;
@@ -179,6 +180,7 @@ mod handlers {
            convert_integer_literal::convert_integer_literal,
            early_return::convert_to_guarded_return,
            expand_glob_import::expand_glob_import,
+            extract_module_to_file::extract_module_to_file,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
            extract_variable::extract_variable,
            fill_match_arms::fill_match_arms,
diff --git a/crates/assists/src/tests.rs b/crates/assists/src/tests.rs
index 709a34d03..b41f4874a 100644
--- a/crates/assists/src/tests.rs
+++ b/crates/assists/src/tests.rs
@@ -2,6 +2,7 @@ mod generated;
 use hir::Semantics;
 use ide_db::base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
+use ide_db::source_change::FileSystemEdit;
 use ide_db::RootDatabase;
 use syntax::TextRange;
 use test_utils::{assert_eq_text, extract_offset, extract_range};
@@ -47,7 +48,7 @@ fn check_doc_test(assist_id: &str, before: &str, after: &str) {
    let before = db.file_text(file_id).to_string();
    let frange = FileRange { file_id, range: selection.into() };
-    let mut assist = Assist::resolved(&db, &AssistConfig::default(), frange)
+    let assist = Assist::resolved(&db, &AssistConfig::default(), frange)
        .into_iter()
        .find(|assist| assist.assist.id.0 == assist_id)
        .unwrap_or_else(|| {
@@ -63,9 +64,12 @@ fn check_doc_test(assist_id: &str, before: &str, after: &str) {
        });
    let actual = {
-        let change = assist.source_change.source_file_edits.pop().unwrap();
        let mut actual = before;
-        change.edit.apply(&mut actual);
+        for source_file_edit in assist.source_change.source_file_edits {
+            if source_file_edit.file_id == file_id {
+                source_file_edit.edit.apply(&mut actual)
+            }
+        }
        actual
    };
    assert_eq_text!(&after, &actual);
@@ -99,7 +103,8 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult, assist_label:
        (Some(assist), ExpectedResult::After(after)) => {
            let mut source_change = assist.source_change;
            assert!(!source_change.source_file_edits.is_empty());
-            let skip_header = source_change.source_file_edits.len() == 1;
+            let skip_header = source_change.source_file_edits.len() == 1
+                && source_change.file_system_edits.len() == 0;
            source_change.source_file_edits.sort_by_key(|it| it.file_id);
            let mut buf = String::new();
@@ -115,6 +120,21 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult, assist_label:
                buf.push_str(&text);
            }
+            for file_system_edit in source_change.file_system_edits.clone() {
+                match file_system_edit {
+                    FileSystemEdit::CreateFile { dst, initial_contents } => {
+                        let sr = db.file_source_root(dst.anchor);
+                        let sr = db.source_root(sr);
+                        let mut base = sr.path_for_file(&dst.anchor).unwrap().clone();
+                        base.pop();
+                        let created_file_path = format!("{}{}", base.to_string(), &dst.path[1..]);
+                        format_to!(buf, "//- {}\n", created_file_path);
+                        buf.push_str(&initial_contents);
+                    }
+                    _ => (),
+                }
+            }
            assert_eq_text!(after, &buf);
        }
        (Some(assist), ExpectedResult::Target(target)) => {
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index cc7c4a343..e9093ec53 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -236,6 +236,21 @@ fn qux(bar: Bar, baz: Baz) {}
 }
 #[test]
+fn doctest_extract_module_to_file() {
+    check_doc_test(
+        "extract_module_to_file",
+        r#####"
+mod foo {<|>
+    fn t() {}
+}
+"#####,
+        r#####"
+mod foo;
+"#####,
+    )
+}
+#[test]
 fn doctest_extract_struct_from_enum_variant() {
    check_doc_test(
        "extract_struct_from_enum_variant",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index f2cacf7c8..d41084b59 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -232,7 +232,13 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
            };
            Some(make::expr_method_call(receiver, method, arg_list))
        }
-        ast::Expr::PrefixExpr(pe) if pe.op_kind()? == ast::PrefixOp::Not => pe.expr(),
+        ast::Expr::PrefixExpr(pe) if pe.op_kind()? == ast::PrefixOp::Not => {
+            if let ast::Expr::ParenExpr(parexpr) = pe.expr()? {
+                parexpr.expr()
+            } else {
+                pe.expr()
+            }
+        }
        // FIXME:
        // ast::Expr::Literal(true | false )
        _ => None,
diff --git a/crates/completion/src/completions.rs b/crates/completion/src/completions.rs
index 1ef6b5f48..d9fe13485 100644
--- a/crates/completion/src/completions.rs
+++ b/crates/completion/src/completions.rs
@@ -19,9 +19,14 @@ use hir::{ModPath, ScopeDef, Type};
 use crate::{
    item::Builder,
    render::{
-        const_::render_const, enum_variant::render_variant, function::render_fn,
+        const_::render_const,
-        macro_::render_macro, render_field, render_resolution, render_tuple_field,
+        enum_variant::render_variant,
-        type_alias::render_type_alias, RenderContext,
+        function::render_fn,
+        macro_::render_macro,
+        pattern::{render_struct_pat, render_variant_pat},
+        render_field, render_resolution, render_tuple_field,
+        type_alias::render_type_alias,
+        RenderContext,
    },
    CompletionContext, CompletionItem,
 };
@@ -105,6 +110,28 @@ impl Completions {
        self.add(item)
    }
+    pub(crate) fn add_variant_pat(
+        &mut self,
+        ctx: &CompletionContext,
+        variant: hir::Variant,
+        local_name: Option<hir::Name>,
+    ) {
+        if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, local_name) {
+            self.add(item);
+        }
+    }
+    pub(crate) fn add_struct_pat(
+        &mut self,
+        ctx: &CompletionContext,
+        strukt: hir::Struct,
+        local_name: Option<hir::Name>,
+    ) {
+        if let Some(item) = render_struct_pat(RenderContext::new(ctx), strukt, local_name) {
+            self.add(item);
+        }
+    }
    pub(crate) fn add_const(&mut self, ctx: &CompletionContext, constant: hir::Const) {
        if let Some(item) = render_const(RenderContext::new(ctx), constant) {
            self.add(item);
diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 4d56731ec..eee31098d 100644
--- a/crates/completion/src/completions/pattern.rs
+++ b/crates/completion/src/completions/pattern.rs
@@ -2,9 +2,9 @@
 use crate::{CompletionContext, Completions};
-/// Completes constats and paths in patterns.
+/// Completes constants and paths in patterns.
 pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_let_pat_binding) {
+    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_pat_binding) {
        return;
    }
    if ctx.record_pat_syntax.is_some() {
@@ -15,20 +15,21 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
    // suggest variants + auto-imports
    ctx.scope.process_all_names(&mut |name, res| {
        let add_resolution = match &res {
-            hir::ScopeDef::ModuleDef(def) => {
+            hir::ScopeDef::ModuleDef(def) => match def {
-                if ctx.is_irrefutable_let_pat_binding {
+                hir::ModuleDef::Adt(hir::Adt::Struct(strukt)) => {
-                    matches!(def, hir::ModuleDef::Adt(hir::Adt::Struct(_)))
+                    acc.add_struct_pat(ctx, strukt.clone(), Some(name.clone()));
-                } else {
+                    true
-                    matches!(
-                        def,
-                        hir::ModuleDef::Adt(hir::Adt::Enum(..))
-                            | hir::ModuleDef::Adt(hir::Adt::Struct(..))
-                            | hir::ModuleDef::Variant(..)
-                            | hir::ModuleDef::Const(..)
-                            | hir::ModuleDef::Module(..)
-                    )
                }
-            }
+                hir::ModuleDef::Variant(variant) if !ctx.is_irrefutable_pat_binding => {
+                    acc.add_variant_pat(ctx, variant.clone(), Some(name.clone()));
+                    true
+                }
+                hir::ModuleDef::Adt(hir::Adt::Enum(..))
+                | hir::ModuleDef::Variant(..)
+                | hir::ModuleDef::Const(..)
+                | hir::ModuleDef::Module(..) => !ctx.is_irrefutable_pat_binding,
+                _ => false,
+            },
            hir::ScopeDef::MacroDef(_) => true,
            _ => false,
        };
@@ -42,13 +43,21 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 mod tests {
    use expect_test::{expect, Expect};
-    use crate::{test_utils::completion_list, CompletionKind};
+    use crate::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
    fn check(ra_fixture: &str, expect: Expect) {
        let actual = completion_list(ra_fixture, CompletionKind::Reference);
        expect.assert_eq(&actual)
    }
+    fn check_snippet(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Snippet);
+        expect.assert_eq(&actual)
+    }
    #[test]
    fn completes_enum_variants_and_modules() {
        check(
@@ -69,7 +78,7 @@ fn foo() {
                en E
                ct Z
                st Bar
-                ev X   ()
+                ev X
                md m
            "#]],
        );
@@ -114,4 +123,139 @@ fn foo() {
            "#]],
        );
    }
+    #[test]
+    fn completes_in_param() {
+        check(
+            r#"
+enum E { X }
+static FOO: E = E::X;
+struct Bar { f: u32 }
+fn foo(<|>) {
+}
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
+        );
+    }
+    #[test]
+    fn completes_pat_in_let() {
+        check_snippet(
+            r#"
+struct Bar { f: u32 }
+fn foo() {
+   let <|>
+}
+"#,
+            expect![[r#"
+                bn Bar Bar { f$1 }$0
+            "#]],
+        );
+    }
+    #[test]
+    fn completes_param_pattern() {
+        check_snippet(
+            r#"
+struct Foo { bar: String, baz: String }
+struct Bar(String, String);
+struct Baz;
+fn outer(<|>) {}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, baz$2 }: Foo$0
+                bn Bar Bar($1, $2): Bar$0
+            "#]],
+        )
+    }
+    #[test]
+    fn completes_let_pattern() {
+        check_snippet(
+            r#"
+struct Foo { bar: String, baz: String }
+struct Bar(String, String);
+struct Baz;
+fn outer() {
+    let <|>
+}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, baz$2 }$0
+                bn Bar Bar($1, $2)$0
+            "#]],
+        )
+    }
+    #[test]
+    fn completes_refutable_pattern() {
+        check_snippet(
+            r#"
+struct Foo { bar: i32, baz: i32 }
+struct Bar(String, String);
+struct Baz;
+fn outer() {
+    match () {
+        <|>
+    }
+}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, baz$2 }$0
+                bn Bar Bar($1, $2)$0
+            "#]],
+        )
+    }
+    #[test]
+    fn omits_private_fields_pat() {
+        check_snippet(
+            r#"
+mod foo {
+    pub struct Foo { pub bar: i32, baz: i32 }
+    pub struct Bar(pub String, String);
+    pub struct Invisible(String, String);
+}
+use foo::*;
+fn outer() {
+    match () {
+        <|>
+    }
+}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, .. }$0
+                bn Bar Bar($1, ..)$0
+            "#]],
+        )
+    }
+    #[test]
+    fn only_shows_ident_completion() {
+        check_edit(
+            "Foo",
+            r#"
+struct Foo(i32);
+fn main() {
+    match Foo(92) {
+        <|>(92) => (),
+    }
+}
+"#,
+            r#"
+struct Foo(i32);
+fn main() {
+    match Foo(92) {
+        Foo(92) => (),
+    }
+}
+"#,
+        );
+    }
 }
diff --git a/crates/completion/src/context.rs b/crates/completion/src/context.rs
index 5cd11cf77..41de324d8 100644
--- a/crates/completion/src/context.rs
+++ b/crates/completion/src/context.rs
@@ -51,7 +51,7 @@ pub(crate) struct CompletionContext<'a> {
    /// If a name-binding or reference to a const in a pattern.
    /// Irrefutable patterns (like let) are excluded.
    pub(super) is_pat_binding_or_const: bool,
-    pub(super) is_irrefutable_let_pat_binding: bool,
+    pub(super) is_irrefutable_pat_binding: bool,
    /// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
    pub(super) is_trivial_path: bool,
    /// If not a trivial path, the prefix (qualifier).
@@ -147,7 +147,7 @@ impl<'a> CompletionContext<'a> {
            active_parameter: ActiveParameter::at(db, position),
            is_param: false,
            is_pat_binding_or_const: false,
-            is_irrefutable_let_pat_binding: false,
+            is_irrefutable_pat_binding: false,
            is_trivial_path: false,
            path_qual: None,
            after_if: false,
@@ -327,14 +327,19 @@ impl<'a> CompletionContext<'a> {
                if bind_pat.syntax().parent().and_then(ast::RecordPatFieldList::cast).is_some() {
                    self.is_pat_binding_or_const = false;
                }
-                if let Some(let_stmt) = bind_pat.syntax().ancestors().find_map(ast::LetStmt::cast) {
+                if let Some(Some(pat)) = bind_pat.syntax().ancestors().find_map(|node| {
-                    if let Some(pat) = let_stmt.pat() {
+                    match_ast! {
-                        if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range())
+                        match node {
-                        {
+                            ast::LetStmt(it) => Some(it.pat()),
-                            self.is_pat_binding_or_const = false;
+                            ast::Param(it) => Some(it.pat()),
-                            self.is_irrefutable_let_pat_binding = true;
+                            _ => None,
                        }
                    }
+                }) {
+                    if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range()) {
+                        self.is_pat_binding_or_const = false;
+                        self.is_irrefutable_pat_binding = true;
+                    }
                }
            }
            if is_node::<ast::Param>(name.syntax()) {
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index 1092a4825..1ba7201a1 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -5,6 +5,7 @@ pub(crate) mod macro_;
 pub(crate) mod function;
 pub(crate) mod enum_variant;
 pub(crate) mod const_;
+pub(crate) mod pattern;
 pub(crate) mod type_alias;
 mod builder_ext;
@@ -159,6 +160,12 @@ impl<'a> Render<'a> {
                let item = render_fn(self.ctx, import_to_add, Some(local_name), *func);
                return Some(item);
            }
+            ScopeDef::ModuleDef(Variant(_))
+                if self.ctx.completion.is_pat_binding_or_const
+                    | self.ctx.completion.is_irrefutable_pat_binding =>
+            {
+                CompletionItemKind::EnumVariant
+            }
            ScopeDef::ModuleDef(Variant(var)) => {
                let item = render_variant(self.ctx, import_to_add, Some(local_name), *var, None);
                return Some(item);
diff --git a/crates/completion/src/render/builder_ext.rs b/crates/completion/src/render/builder_ext.rs
index ce8718bd5..d053a988b 100644
--- a/crates/completion/src/render/builder_ext.rs
+++ b/crates/completion/src/render/builder_ext.rs
@@ -34,7 +34,6 @@ impl Builder {
            return false;
        }
        if ctx.is_pattern_call {
-            mark::hit!(dont_duplicate_pattern_parens);
            return false;
        }
        if ctx.is_call {
diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs
index 7176fd9b3..732e139ec 100644
--- a/crates/completion/src/render/enum_variant.rs
+++ b/crates/completion/src/render/enum_variant.rs
@@ -126,50 +126,5 @@ fn main() -> Option<i32> {
 }
 "#,
        );
-        check_edit(
-            "Some",
-            r#"
-enum Option<T> { Some(T), None }
-use Option::*;
-fn main(value: Option<i32>) {
-    match value {
-        Som<|>
-    }
-}
-"#,
-            r#"
-enum Option<T> { Some(T), None }
-use Option::*;
-fn main(value: Option<i32>) {
-    match value {
-        Some($0)
-    }
-}
-"#,
-        );
-    }
-    #[test]
-    fn dont_duplicate_pattern_parens() {
-        mark::check!(dont_duplicate_pattern_parens);
-        check_edit(
-            "Var",
-            r#"
-enum E { Var(i32) }
-fn main() {
-    match E::Var(92) {
-        E::<|>(92) => (),
-    }
-}
-"#,
-            r#"
-enum E { Var(i32) }
-fn main() {
-    match E::Var(92) {
-        E::Var(92) => (),
-    }
-}
-"#,
-        );
    }
 }
diff --git a/crates/completion/src/render/pattern.rs b/crates/completion/src/render/pattern.rs
new file mode 100644
index 000000000..a3b6a3cac
--- /dev/null
+++ b/crates/completion/src/render/pattern.rs
@@ -0,0 +1,148 @@
+//! Renderer for patterns.
+use hir::{db::HirDatabase, HasAttrs, HasVisibility, Name, StructKind};
+use itertools::Itertools;
+use crate::{
+    config::SnippetCap, item::CompletionKind, render::RenderContext, CompletionItem,
+    CompletionItemKind,
+};
+fn visible_fields(
+    ctx: &RenderContext<'_>,
+    fields: &[hir::Field],
+    item: impl HasAttrs,
+) -> Option<(Vec<hir::Field>, bool)> {
+    let module = ctx.completion.scope.module()?;
+    let n_fields = fields.len();
+    let fields = fields
+        .into_iter()
+        .filter(|field| field.is_visible_from(ctx.db(), module))
+        .copied()
+        .collect::<Vec<_>>();
+    let fields_omitted =
+        n_fields - fields.len() > 0 || item.attrs(ctx.db()).by_key("non_exhaustive").exists();
+    Some((fields, fields_omitted))
+}
+pub(crate) fn render_struct_pat(
+    ctx: RenderContext<'_>,
+    strukt: hir::Struct,
+    local_name: Option<Name>,
+) -> Option<CompletionItem> {
+    let _p = profile::span("render_struct_pat");
+    let fields = strukt.fields(ctx.db());
+    let (visible_fields, fields_omitted) = visible_fields(&ctx, &fields, strukt)?;
+    if visible_fields.is_empty() {
+        // Matching a struct without matching its fields is pointless, unlike matching a Variant without its fields
+        return None;
+    }
+    let name = local_name.unwrap_or_else(|| strukt.name(ctx.db())).to_string();
+    let pat = render_pat(&ctx, &name, strukt.kind(ctx.db()), &visible_fields, fields_omitted)?;
+    Some(build_completion(ctx, name, pat, strukt))
+}
+pub(crate) fn render_variant_pat(
+    ctx: RenderContext<'_>,
+    variant: hir::Variant,
+    local_name: Option<Name>,
+) -> Option<CompletionItem> {
+    let _p = profile::span("render_variant_pat");
+    let fields = variant.fields(ctx.db());
+    let (visible_fields, fields_omitted) = visible_fields(&ctx, &fields, variant)?;
+    let name = local_name.unwrap_or_else(|| variant.name(ctx.db())).to_string();
+    let pat = render_pat(&ctx, &name, variant.kind(ctx.db()), &visible_fields, fields_omitted)?;
+    Some(build_completion(ctx, name, pat, variant))
+}
+fn build_completion(
+    ctx: RenderContext<'_>,
+    name: String,
+    pat: String,
+    item: impl HasAttrs + Copy,
+) -> CompletionItem {
+    let completion = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name)
+        .kind(CompletionItemKind::Binding)
+        .set_documentation(ctx.docs(item))
+        .set_deprecated(ctx.is_deprecated(item))
+        .detail(&pat);
+    let completion = if let Some(snippet_cap) = ctx.snippet_cap() {
+        completion.insert_snippet(snippet_cap, pat)
+    } else {
+        completion.insert_text(pat)
+    };
+    completion.build()
+}
+fn render_pat(
+    ctx: &RenderContext<'_>,
+    name: &str,
+    kind: StructKind,
+    fields: &[hir::Field],
+    fields_omitted: bool,
+) -> Option<String> {
+    let mut pat = match kind {
+        StructKind::Tuple if ctx.snippet_cap().is_some() => {
+            render_tuple_as_pat(&fields, &name, fields_omitted)
+        }
+        StructKind::Record => {
+            render_record_as_pat(ctx.db(), ctx.snippet_cap(), &fields, &name, fields_omitted)
+        }
+        _ => return None,
+    };
+    if ctx.completion.is_param {
+        pat.push(':');
+        pat.push(' ');
+        pat.push_str(&name);
+    }
+    if ctx.snippet_cap().is_some() {
+        pat.push_str("$0");
+    }
+    Some(pat)
+}
+fn render_record_as_pat(
+    db: &dyn HirDatabase,
+    snippet_cap: Option<SnippetCap>,
+    fields: &[hir::Field],
+    name: &str,
+    fields_omitted: bool,
+) -> String {
+    let fields = fields.iter();
+    if snippet_cap.is_some() {
+        format!(
+            "{name} {{ {}{} }}",
+            fields
+                .enumerate()
+                .map(|(idx, field)| format!("{}${}", field.name(db), idx + 1))
+                .format(", "),
+            if fields_omitted { ", .." } else { "" },
+            name = name
+        )
+    } else {
+        format!(
+            "{name} {{ {}{} }}",
+            fields.map(|field| field.name(db)).format(", "),
+            if fields_omitted { ", .." } else { "" },
+            name = name
+        )
+    }
+}
+fn render_tuple_as_pat(fields: &[hir::Field], name: &str, fields_omitted: bool) -> String {
+    format!(
+        "{name}({}{})",
+        fields.iter().enumerate().map(|(idx, _)| format!("${}", idx + 1)).format(", "),
+        if fields_omitted { ", .." } else { "" },
+        name = name
+    )
+}
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index d6c7e71ea..1d7e5ddd7 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -511,6 +511,10 @@ impl Struct {
        db.struct_data(self.id).repr.clone()
    }
+    pub fn kind(self, db: &dyn HirDatabase) -> StructKind {
+        self.variant_data(db).kind()
+    }
    fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {
        db.struct_data(self.id).variant_data.clone()
    }
@@ -1268,7 +1272,6 @@ impl LifetimeParam {
    }
 }
-// FIXME: rename from `ImplDef` to `Impl`
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Impl {
    pub(crate) id: ImplId,
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index 41134d23b..bb8fca009 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -62,6 +62,7 @@ pub struct GenericParams {
 pub enum WherePredicate {
    TypeBound { target: WherePredicateTypeTarget, bound: TypeBound },
    Lifetime { target: LifetimeRef, bound: LifetimeRef },
+    ForLifetime { lifetimes: Box<[Name]>, target: WherePredicateTypeTarget, bound: TypeBound },
 }
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -69,7 +70,6 @@ pub enum WherePredicateTypeTarget {
    TypeRef(TypeRef),
    /// For desugared where predicates that can directly refer to a type param.
    TypeParam(LocalTypeParamId),
-    // FIXME: ForLifetime(Vec<LifetimeParamId>, TypeRef)
 }
 #[derive(Default)]
@@ -234,7 +234,7 @@ impl GenericParams {
        for bound in
            node.type_bound_list().iter().flat_map(|type_bound_list| type_bound_list.bounds())
        {
-            self.add_where_predicate_from_bound(lower_ctx, bound, target.clone());
+            self.add_where_predicate_from_bound(lower_ctx, bound, None, target.clone());
        }
    }
@@ -279,8 +279,25 @@ impl GenericParams {
            } else {
                continue;
            };
+            let lifetimes: Option<Box<_>> = pred.generic_param_list().map(|param_list| {
+                // Higher-Ranked Trait Bounds
+                param_list
+                    .lifetime_params()
+                    .map(|lifetime_param| {
+                        lifetime_param
+                            .lifetime()
+                            .map_or_else(Name::missing, |lt| Name::new_lifetime(&lt))
+                    })
+                    .collect()
+            });
            for bound in pred.type_bound_list().iter().flat_map(|l| l.bounds()) {
-                self.add_where_predicate_from_bound(lower_ctx, bound, target.clone());
+                self.add_where_predicate_from_bound(
+                    lower_ctx,
+                    bound,
+                    lifetimes.as_ref(),
+                    target.clone(),
+                );
            }
        }
    }
@@ -289,6 +306,7 @@ impl GenericParams {
        &mut self,
        lower_ctx: &LowerCtx,
        bound: ast::TypeBound,
+        hrtb_lifetimes: Option<&Box<[Name]>>,
        target: Either<TypeRef, LifetimeRef>,
    ) {
        if bound.question_mark_token().is_some() {
@@ -297,9 +315,16 @@ impl GenericParams {
        }
        let bound = TypeBound::from_ast(lower_ctx, bound);
        let predicate = match (target, bound) {
-            (Either::Left(type_ref), bound) => WherePredicate::TypeBound {
+            (Either::Left(type_ref), bound) => match hrtb_lifetimes {
-                target: WherePredicateTypeTarget::TypeRef(type_ref),
+                Some(hrtb_lifetimes) => WherePredicate::ForLifetime {
-                bound,
+                    lifetimes: hrtb_lifetimes.clone(),
+                    target: WherePredicateTypeTarget::TypeRef(type_ref),
+                    bound,
+                },
+                None => WherePredicate::TypeBound {
+                    target: WherePredicateTypeTarget::TypeRef(type_ref),
+                    bound,
+                },
            },
            (Either::Right(lifetime), TypeBound::Lifetime(bound)) => {
                WherePredicate::Lifetime { target: lifetime, bound }
diff --git a/crates/hir_def/src/nameres/mod_resolution.rs b/crates/hir_def/src/nameres/mod_resolution.rs
index b4ccd4488..af3262439 100644
--- a/crates/hir_def/src/nameres/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/mod_resolution.rs
@@ -79,7 +79,7 @@ impl ModDir {
        for candidate in candidate_files.iter() {
            let path = AnchoredPath { anchor: file_id, path: candidate.as_str() };
            if let Some(file_id) = db.resolve_path(path) {
-                let is_mod_rs = candidate.ends_with("mod.rs");
+                let is_mod_rs = candidate.ends_with("/mod.rs");
                let (dir_path, root_non_dir_owner) = if is_mod_rs || attr_path.is_some() {
                    (DirPath::empty(), false)
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index dddbbcdac..6382521fb 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -563,6 +563,7 @@ mod tests {
                let args = macro_call.token_tree().unwrap();
                let parsed_args = mbe::ast_to_token_tree(&args).unwrap().0;
+                let call_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call));
                let arg_id = db.intern_eager_expansion({
                    EagerCallLoc {
@@ -570,7 +571,7 @@ mod tests {
                        fragment: FragmentKind::Expr,
                        subtree: Arc::new(parsed_args.clone()),
                        krate,
-                        file_id: file_id.into(),
+                        call: call_id,
                    }
                });
@@ -580,7 +581,7 @@ mod tests {
                    fragment,
                    subtree: Arc::new(subtree),
                    krate,
-                    file_id: file_id.into(),
+                    call: call_id,
                };
                let id: MacroCallId = db.intern_eager_expansion(eager).into();
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 4477d867f..077de3727 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 use base_db::{salsa, SourceDatabase};
 use mbe::{ExpandError, ExpandResult, MacroRules};
 use parser::FragmentKind;
-use syntax::{algo::diff, AstNode, GreenNode, Parse, SyntaxKind::*, SyntaxNode};
+use syntax::{algo::diff, ast::NameOwner, AstNode, GreenNode, Parse, SyntaxKind::*, SyntaxNode};
 use crate::{
    ast_id_map::AstIdMap, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerCallLoc, EagerMacroId,
@@ -129,11 +129,11 @@ fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
    match id.kind {
        MacroDefKind::Declarative => {
-            let macro_call = match id.ast_id?.to_node(db) {
+            let macro_rules = match id.ast_id?.to_node(db) {
                syntax::ast::Macro::MacroRules(mac) => mac,
                syntax::ast::Macro::MacroDef(_) => return None,
            };
-            let arg = macro_call.token_tree()?;
+            let arg = macro_rules.token_tree()?;
            let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
                log::warn!("fail on macro_def to token tree: {:#?}", arg);
                None
@@ -141,7 +141,8 @@ fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander,
            let rules = match MacroRules::parse(&tt) {
                Ok(it) => it,
                Err(err) => {
-                    log::warn!("fail on macro_def parse: error: {:#?} {:#?}", err, tt);
+                    let name = macro_rules.name().map(|n| n.to_string()).unwrap_or_default();
+                    log::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
                    return None;
                }
            };
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 0229a836e..6354b090d 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -110,6 +110,9 @@ pub fn expand_eager_macro(
        || err("malformed macro invocation"),
    )?;
+    let ast_map = db.ast_id_map(macro_call.file_id);
+    let call_id = InFile::new(macro_call.file_id, ast_map.ast_id(&macro_call.value));
    // Note:
    // When `lazy_expand` is called, its *parent* file must be already exists.
    // Here we store an eager macro id for the argument expanded subtree here
@@ -120,7 +123,7 @@ pub fn expand_eager_macro(
            fragment: FragmentKind::Expr,
            subtree: Arc::new(parsed_args.clone()),
            krate,
-            file_id: macro_call.file_id,
+            call: call_id,
        }
    });
    let arg_file_id: MacroCallId = arg_id.into();
@@ -141,13 +144,8 @@ pub fn expand_eager_macro(
        let res = eager.expand(db, arg_id, &subtree);
        let (subtree, fragment) = diagnostic_sink.expand_result_option(res)?;
-        let eager = EagerCallLoc {
+        let eager =
-            def,
+            EagerCallLoc { def, fragment, subtree: Arc::new(subtree), krate, call: call_id };
-            fragment,
-            subtree: Arc::new(subtree),
-            krate,
-            file_id: macro_call.file_id,
-        };
        Ok(db.intern_eager_expansion(eager))
    } else {
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index d486186e5..3fa1b1d77 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -83,7 +83,7 @@ impl HirFileId {
                    }
                    MacroCallId::EagerMacro(id) => {
                        let loc = db.lookup_intern_eager_expansion(id);
-                        loc.file_id
+                        loc.call.file_id
                    }
                };
                file_id.original_file(db)
@@ -103,7 +103,7 @@ impl HirFileId {
                }
                MacroCallId::EagerMacro(id) => {
                    let loc = db.lookup_intern_eager_expansion(id);
-                    loc.file_id
+                    loc.call.file_id
                }
            };
        }
@@ -114,17 +114,16 @@ impl HirFileId {
    pub fn call_node(self, db: &dyn db::AstDatabase) -> Option<InFile<SyntaxNode>> {
        match self.0 {
            HirFileIdRepr::FileId(_) => None,
-            HirFileIdRepr::MacroFile(macro_file) => {
+            HirFileIdRepr::MacroFile(macro_file) => match macro_file.macro_call_id {
-                let lazy_id = match macro_file.macro_call_id {
+                MacroCallId::LazyMacro(lazy_id) => {
-                    MacroCallId::LazyMacro(id) => id,
+                    let loc: MacroCallLoc = db.lookup_intern_macro(lazy_id);
-                    MacroCallId::EagerMacro(_id) => {
+                    Some(loc.kind.node(db))
-                        // FIXME: handle call node for eager macro
+                }
-                        return None;
+                MacroCallId::EagerMacro(id) => {
-                    }
+                    let loc: EagerCallLoc = db.lookup_intern_eager_expansion(id);
-                };
+                    Some(loc.call.with_value(loc.call.to_node(db).syntax().clone()))
-                let loc = db.lookup_intern_macro(lazy_id);
+                }
-                Some(loc.kind.node(db))
+            },
-            }
        }
    }
@@ -304,7 +303,7 @@ pub struct EagerCallLoc {
    pub(crate) fragment: FragmentKind,
    pub(crate) subtree: Arc<tt::Subtree>,
    pub(crate) krate: CrateId,
-    pub(crate) file_id: HirFileId,
+    pub(crate) call: AstId<ast::MacroCall>,
 }
 /// ExpansionInfo mainly describes how to map text range between src and expanded macro
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 8392cb770..8da56cd11 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -675,7 +675,8 @@ impl GenericPredicate {
        where_predicate: &'a WherePredicate,
    ) -> impl Iterator<Item = GenericPredicate> + 'a {
        match where_predicate {
-            WherePredicate::TypeBound { target, bound } => {
+            WherePredicate::ForLifetime { target, bound, .. }
+            | WherePredicate::TypeBound { target, bound } => {
                let self_ty = match target {
                    WherePredicateTypeTarget::TypeRef(type_ref) => Ty::from_hir(ctx, type_ref),
                    WherePredicateTypeTarget::TypeParam(param_id) => {
@@ -888,14 +889,13 @@ pub(crate) fn generic_predicates_for_param_query(
        .where_predicates_in_scope()
        // we have to filter out all other predicates *first*, before attempting to lower them
        .filter(|pred| match pred {
-            WherePredicate::TypeBound {
+            WherePredicate::ForLifetime { target, .. }
-                target: WherePredicateTypeTarget::TypeRef(type_ref),
+            | WherePredicate::TypeBound { target, .. } => match target {
-                ..
+                WherePredicateTypeTarget::TypeRef(type_ref) => {
-            } => Ty::from_hir_only_param(&ctx, type_ref) == Some(param_id),
+                    Ty::from_hir_only_param(&ctx, type_ref) == Some(param_id)
-            WherePredicate::TypeBound {
+                }
-                target: WherePredicateTypeTarget::TypeParam(local_id),
+                WherePredicateTypeTarget::TypeParam(local_id) => *local_id == param_id.local_id,
-                ..
+            },
-            } => *local_id == param_id.local_id,
            WherePredicate::Lifetime { .. } => false,
        })
        .flat_map(|pred| {
diff --git a/crates/hir_ty/src/utils.rs b/crates/hir_ty/src/utils.rs
index af880c065..65b79df0d 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -5,7 +5,9 @@ use std::sync::Arc;
 use hir_def::{
    adt::VariantData,
    db::DefDatabase,
-    generics::{GenericParams, TypeParamData, TypeParamProvenance, WherePredicateTypeTarget},
+    generics::{
+        GenericParams, TypeParamData, TypeParamProvenance, WherePredicate, WherePredicateTypeTarget,
+    },
    path::Path,
    resolver::{HasResolver, TypeNs},
    type_ref::TypeRef,
@@ -27,7 +29,8 @@ fn direct_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
        .where_predicates
        .iter()
        .filter_map(|pred| match pred {
-            hir_def::generics::WherePredicate::TypeBound { target, bound } => match target {
+            WherePredicate::ForLifetime { target, bound, .. }
+            | WherePredicate::TypeBound { target, bound } => match target {
                WherePredicateTypeTarget::TypeRef(TypeRef::Path(p))
                    if p == &Path::from(name![Self]) =>
                {
@@ -38,7 +41,7 @@ fn direct_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> Vec<TraitId> {
                }
                _ => None,
            },
-            hir_def::generics::WherePredicate::Lifetime { .. } => None,
+            WherePredicate::Lifetime { .. } => None,
        })
        .filter_map(|path| match resolver.resolve_path_in_type_ns_fully(db, path.mod_path()) {
            Some(TypeNs::TraitId(t)) => Some(t),
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 049f808dc..3ad30f0c9 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -619,6 +619,7 @@ fn test_fn() {
                                                ),
                                                path: "foo.rs",
                                            },
+                                            initial_contents: "",
                                        },
                                    ],
                                    is_snippet: false,
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index e8b896623..d79f5c170 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -40,6 +40,7 @@ impl DiagnosticWithFix for UnresolvedModule {
                    anchor: self.file.original_file(sema.db),
                    path: self.candidate.clone(),
                },
+                initial_contents: "".to_string(),
            }
            .into(),
            unresolved_module.syntax().text_range(),
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 7a12e9965..47dd85ceb 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -750,6 +750,31 @@ fn test() {
    }
    #[test]
+    fn goto_through_included_file() {
+        check(
+            r#"
+//- /main.rs
+#[rustc_builtin_macro]
+macro_rules! include {}
+  include!("foo.rs");
+//^^^^^^^^^^^^^^^^^^^
+fn f() {
+    foo<|>();
+}
+mod confuse_index {
+    pub fn foo() {}
+}
+//- /foo.rs
+fn foo() {}
+        "#,
+        );
+    }
+    #[test]
    fn goto_for_type_param() {
        check(
            r#"
@@ -1077,4 +1102,32 @@ fn foo<'foobar>(_: &'foobar ()) {
 }"#,
        )
    }
+    #[test]
+    #[ignore] // requires the HIR to somehow track these hrtb lifetimes
+    fn goto_lifetime_hrtb() {
+        check(
+            r#"trait Foo<T> {}
+fn foo<T>() where for<'a> T: Foo<&'a<|> (u8, u16)>, {}
+                    //^^
+"#,
+        );
+        check(
+            r#"trait Foo<T> {}
+fn foo<T>() where for<'a<|>> T: Foo<&'a (u8, u16)>, {}
+                    //^^
+"#,
+        );
+    }
+    #[test]
+    #[ignore] // requires ForTypes to be implemented
+    fn goto_lifetime_hrtb_for_type() {
+        check(
+            r#"trait Foo<T> {}
+fn foo<T>() where T: for<'a> Foo<&'a<|> (u8, u16)>, {}
+                       //^^
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 18ea19305..33b7358f7 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -147,20 +147,20 @@ fn find_name(
 ) -> Option<RangeInfo<Definition>> {
    if let Some(name) = opt_name {
        let def = NameClass::classify(sema, &name)?.referenced_or_defined(sema.db);
-        let range = name.syntax().text_range();
+        let FileRange { range, .. } = sema.original_range(name.syntax());
        return Some(RangeInfo::new(range, def));
    }
-    let (text_range, def) = if let Some(lifetime) =
+    let (FileRange { range, .. }, def) = if let Some(lifetime) =
        sema.find_node_at_offset_with_descend::<ast::Lifetime>(&syntax, position.offset)
    {
        if let Some(def) = NameRefClass::classify_lifetime(sema, &lifetime)
            .map(|class| NameRefClass::referenced(class, sema.db))
        {
-            (lifetime.syntax().text_range(), def)
+            (sema.original_range(lifetime.syntax()), def)
        } else {
            (
-                lifetime.syntax().text_range(),
+                sema.original_range(lifetime.syntax()),
                NameClass::classify_lifetime(sema, &lifetime)?.referenced_or_defined(sema.db),
            )
        }
@@ -168,11 +168,11 @@ fn find_name(
        let name_ref =
            sema.find_node_at_offset_with_descend::<ast::NameRef>(&syntax, position.offset)?;
        (
-            name_ref.syntax().text_range(),
+            sema.original_range(name_ref.syntax()),
            NameRefClass::classify(sema, &name_ref)?.referenced(sema.db),
        )
    };
-    Some(RangeInfo::new(text_range, def))
+    Some(RangeInfo::new(range, def))
 }
 fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Option<ReferenceAccess> {
@@ -1086,4 +1086,40 @@ impl<'a> Foo<'a> for &'a () {
            "#]],
        );
    }
+    #[test]
+    fn test_map_range_to_original() {
+        check(
+            r#"
+macro_rules! foo {($i:ident) => {$i} }
+fn main() {
+    let a<|> = "test";
+    foo!(a);
+}
+"#,
+            expect![[r#"
+                a Local FileId(0) 59..60 Other
+                FileId(0) 80..81 Other Read
+            "#]],
+        );
+    }
+    #[test]
+    fn test_map_range_to_original_ref() {
+        check(
+            r#"
+macro_rules! foo {($i:ident) => {$i} }
+fn main() {
+    let a = "test";
+    foo!(a<|>);
+}
+"#,
+            expect![[r#"
+                a Local FileId(0) 59..60 Other
+                FileId(0) 80..81 Other Read
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_db/src/source_change.rs b/crates/ide_db/src/source_change.rs
index e87d98dad..10c0abdac 100644
--- a/crates/ide_db/src/source_change.rs
+++ b/crates/ide_db/src/source_change.rs
@@ -44,7 +44,7 @@ impl From<Vec<SourceFileEdit>> for SourceChange {
 #[derive(Debug, Clone)]
 pub enum FileSystemEdit {
-    CreateFile { dst: AnchoredPathBuf },
+    CreateFile { dst: AnchoredPathBuf, initial_contents: String },
    MoveFile { src: FileId, dst: AnchoredPathBuf },
 }
diff --git a/crates/mbe/src/tests.rs b/crates/mbe/src/tests.rs
index f10e7a9b6..451fa1456 100644
--- a/crates/mbe/src/tests.rs
+++ b/crates/mbe/src/tests.rs
@@ -1004,6 +1004,18 @@ fn test_underscore() {
 }
 #[test]
+fn test_vertical_bar_with_pat() {
+    parse_macro(
+        r#"
+            macro_rules! foo {
+                 (| $pat:pat | ) => { 0 }
+            }
+    "#,
+    )
+    .assert_expand_items(r#"foo! { | x | }"#, r#"0"#);
+}
+#[test]
 fn test_lifetime() {
    parse_macro(
        r#"
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index 1a078f6b4..f08c8bab7 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -55,7 +55,7 @@ pub(crate) mod fragments {
    use super::*;
    pub(crate) use super::{
-        expressions::block_expr, paths::type_path as path, patterns::pattern, types::type_,
+        expressions::block_expr, paths::type_path as path, patterns::pattern_single, types::type_,
    };
    pub(crate) fn expr(p: &mut Parser) {
diff --git a/crates/parser/src/grammar/expressions/atom.rs b/crates/parser/src/grammar/expressions/atom.rs
index 18b63feb7..e897d5a52 100644
--- a/crates/parser/src/grammar/expressions/atom.rs
+++ b/crates/parser/src/grammar/expressions/atom.rs
@@ -156,11 +156,13 @@ fn tuple_expr(p: &mut Parser) -> CompletedMarker {
    let mut saw_expr = false;
    while !p.at(EOF) && !p.at(T![')']) {
        saw_expr = true;
-        if !p.at_ts(EXPR_FIRST) {
-            p.error("expected expression");
+        // test tuple_attrs
+        // const A: (i64, i64) = (1, #[cfg(test)] 2);
+        if !expr_with_attrs(p) {
            break;
        }
-        expr(p);
        if !p.at(T![')']) {
            saw_comma = true;
            p.expect(T![,]);
diff --git a/crates/parser/src/grammar/params.rs b/crates/parser/src/grammar/params.rs
index 3ee4e4fca..2d006a1d5 100644
--- a/crates/parser/src/grammar/params.rs
+++ b/crates/parser/src/grammar/params.rs
@@ -47,20 +47,23 @@ fn list_(p: &mut Parser, flavor: Flavor) {
    if let FnDef = flavor {
        // test self_param_outer_attr
        // fn f(#[must_use] self) {}
+        let m = p.start();
        attributes::outer_attrs(p);
-        opt_self_param(p);
+        opt_self_param(p, m);
    }
    while !p.at(EOF) && !p.at(ket) {
        // test param_outer_arg
        // fn f(#[attr1] pat: Type) {}
+        let m = p.start();
        attributes::outer_attrs(p);
        if !p.at_ts(PARAM_FIRST) {
            p.error("expected value parameter");
+            m.abandon(p);
            break;
        }
-        let param = param(p, flavor);
+        let param = param(p, m, flavor);
        if !p.at(ket) {
            p.expect(T![,]);
        }
@@ -77,9 +80,8 @@ const PARAM_FIRST: TokenSet = patterns::PATTERN_FIRST.union(types::TYPE_FIRST);
 struct Variadic(bool);
-fn param(p: &mut Parser, flavor: Flavor) -> Variadic {
+fn param(p: &mut Parser, m: Marker, flavor: Flavor) -> Variadic {
    let mut res = Variadic(false);
-    let m = p.start();
    match flavor {
        // test param_list_vararg
        // extern "C" { fn printf(format: *const i8, ...) -> i32; }
@@ -151,10 +153,8 @@ fn variadic_param(p: &mut Parser) -> bool {
 //     fn d(&'a mut self, x: i32) {}
 //     fn e(mut self) {}
 // }
-fn opt_self_param(p: &mut Parser) {
+fn opt_self_param(p: &mut Parser, m: Marker) {
-    let m;
    if p.at(T![self]) || p.at(T![mut]) && p.nth(1) == T![self] {
-        m = p.start();
        p.eat(T![mut]);
        p.eat(T![self]);
        // test arb_self_types
@@ -174,9 +174,8 @@ fn opt_self_param(p: &mut Parser) {
            (T![&], T![mut], T![self], _) => 3,
            (T![&], LIFETIME_IDENT, T![self], _) => 3,
            (T![&], LIFETIME_IDENT, T![mut], T![self]) => 4,
-            _ => return,
+            _ => return m.abandon(p),
        };
-        m = p.start();
        p.bump_any();
        if p.at(LIFETIME_IDENT) {
            lifetime(p);
diff --git a/crates/parser/src/grammar/type_params.rs b/crates/parser/src/grammar/type_params.rs
index 9c3f7c28a..4aeccd193 100644
--- a/crates/parser/src/grammar/type_params.rs
+++ b/crates/parser/src/grammar/type_params.rs
@@ -113,7 +113,7 @@ fn type_bound(p: &mut Parser) -> bool {
    p.eat(T![?]);
    match p.current() {
        LIFETIME_IDENT => lifetime(p),
-        T![for] => types::for_type(p),
+        T![for] => types::for_type(p, false),
        _ if paths::is_use_path_start(p) => types::path_type_(p, false),
        _ => {
            m.abandon(p);
diff --git a/crates/parser/src/grammar/types.rs b/crates/parser/src/grammar/types.rs
index 36a15eace..94cbf7d85 100644
--- a/crates/parser/src/grammar/types.rs
+++ b/crates/parser/src/grammar/types.rs
@@ -44,7 +44,7 @@ fn type_with_bounds_cond(p: &mut Parser, allow_bounds: bool) {
        T![&] => ref_type(p),
        T![_] => infer_type(p),
        T![fn] | T![unsafe] | T![extern] => fn_ptr_type(p),
-        T![for] => for_type(p),
+        T![for] => for_type(p, allow_bounds),
        T![impl] => impl_trait_type(p),
        T![dyn] => dyn_trait_type(p),
        // Some path types are not allowed to have bounds (no plus)
@@ -227,7 +227,7 @@ pub(super) fn for_binder(p: &mut Parser) {
 // type A = for<'a> fn() -> ();
 // type B = for<'a> unsafe extern "C" fn(&'a ()) -> ();
 // type Obj = for<'a> PartialEq<&'a i32>;
-pub(super) fn for_type(p: &mut Parser) {
+pub(super) fn for_type(p: &mut Parser, allow_bounds: bool) {
    assert!(p.at(T![for]));
    let m = p.start();
    for_binder(p);
@@ -240,7 +240,13 @@ pub(super) fn for_type(p: &mut Parser) {
        }
    }
    type_no_bounds(p);
-    m.complete(p, FOR_TYPE);
+    let completed = m.complete(p, FOR_TYPE);
+    // test no_dyn_trait_leading_for
+    // type A = for<'a> Test<'a> + Send;
+    if allow_bounds {
+        opt_type_bounds_as_dyn_trait_type(p, completed);
+    }
 }
 // test impl_trait_type
@@ -290,7 +296,7 @@ fn path_or_macro_type_(p: &mut Parser, allow_bounds: bool) {
    let path = m.complete(p, kind);
    if allow_bounds {
-        opt_path_type_bounds_as_dyn_trait_type(p, path);
+        opt_type_bounds_as_dyn_trait_type(p, path);
    }
 }
@@ -304,19 +310,23 @@ pub(super) fn path_type_(p: &mut Parser, allow_bounds: bool) {
    // fn foo() -> Box<dyn T + 'f> {}
    let path = m.complete(p, PATH_TYPE);
    if allow_bounds {
-        opt_path_type_bounds_as_dyn_trait_type(p, path);
+        opt_type_bounds_as_dyn_trait_type(p, path);
    }
 }
-/// This turns a parsed PATH_TYPE optionally into a DYN_TRAIT_TYPE
+/// This turns a parsed PATH_TYPE or FOR_TYPE optionally into a DYN_TRAIT_TYPE
 /// with a TYPE_BOUND_LIST
-fn opt_path_type_bounds_as_dyn_trait_type(p: &mut Parser, path_type_marker: CompletedMarker) {
+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
+    ));
    if !p.at(T![+]) {
        return;
    }
    // First create a TYPE_BOUND from the completed PATH_TYPE
-    let m = path_type_marker.precede(p).complete(p, TYPE_BOUND);
+    let m = type_marker.precede(p).complete(p, TYPE_BOUND);
    // Next setup a marker for the TYPE_BOUND_LIST
    let m = m.precede(p);
diff --git a/crates/parser/src/lib.rs b/crates/parser/src/lib.rs
index ab8e4c70e..811e740f9 100644
--- a/crates/parser/src/lib.rs
+++ b/crates/parser/src/lib.rs
@@ -112,7 +112,7 @@ pub fn parse_fragment(
        FragmentKind::Path => grammar::fragments::path,
        FragmentKind::Expr => grammar::fragments::expr,
        FragmentKind::Type => grammar::fragments::type_,
-        FragmentKind::Pattern => grammar::fragments::pattern,
+        FragmentKind::Pattern => grammar::fragments::pattern_single,
        FragmentKind::Item => grammar::fragments::item,
        FragmentKind::Block => grammar::fragments::block_expr,
        FragmentKind::Visibility => grammar::fragments::opt_visibility,
diff --git a/crates/proc_macro_srv/Cargo.toml b/crates/proc_macro_srv/Cargo.toml
index 1bfa6c3fc..df9a55c10 100644
--- a/crates/proc_macro_srv/Cargo.toml
+++ b/crates/proc_macro_srv/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 [dependencies]
-object = { version = "0.23", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
+object = { version = "0.23", default-features = false, features = ["std", "read_core", "elf", "macho", "pe"] }
 libloading = "0.6.0"
 memmap = "0.7"
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 1f4b5c24c..1db5b4e7d 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -33,7 +33,7 @@ config_data! {
        callInfo_full: bool = "true",
        /// Automatically refresh project info via `cargo metadata` on
-        /// Cargo.toml changes.
+        /// `Cargo.toml` changes.
        cargo_autoreload: bool           = "true",
        /// Activate all available features.
        cargo_allFeatures: bool          = "false",
@@ -52,7 +52,7 @@ config_data! {
        /// Run specified `cargo check` command for diagnostics on save.
        checkOnSave_enable: bool                         = "true",
        /// Check with all features (will be passed as `--all-features`).
-        /// Defaults to `rust-analyzer.cargo.allFeatures`.
+        /// Defaults to `#rust-analyzer.cargo.allFeatures#`.
        checkOnSave_allFeatures: Option<bool>            = "null",
        /// Check all targets and tests (will be passed as `--all-targets`).
        checkOnSave_allTargets: bool                     = "true",
@@ -61,12 +61,12 @@ config_data! {
        /// Do not activate the `default` feature.
        checkOnSave_noDefaultFeatures: Option<bool>      = "null",
        /// Check for a specific target. Defaults to
-        /// `rust-analyzer.cargo.target`.
+        /// `#rust-analyzer.cargo.target#`.
        checkOnSave_target: Option<String>               = "null",
        /// Extra arguments for `cargo check`.
        checkOnSave_extraArgs: Vec<String>               = "[]",
        /// List of features to activate. Defaults to
-        /// `rust-analyzer.cargo.features`.
+        /// `#rust-analyzer.cargo.features#`.
        checkOnSave_features: Option<Vec<String>>        = "null",
        /// Advanced option, fully override the command rust-analyzer uses for
        /// checking. The command should include `--message-format=json` or
@@ -80,7 +80,7 @@ config_data! {
        /// Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
        completion_postfix_enable: bool          = "true",
        /// Toggles the additional completions that automatically add imports when completed.
-        /// Note that your client have to specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
+        /// Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
        completion_autoimport_enable: bool       = "true",
        /// Whether to show native rust-analyzer diagnostics.
@@ -90,13 +90,13 @@ config_data! {
        diagnostics_enableExperimental: bool    = "true",
        /// List of rust-analyzer diagnostics to disable.
        diagnostics_disabled: FxHashSet<String> = "[]",
-        /// List of warnings that should be displayed with info severity.\nThe
+        /// List of warnings that should be displayed with info severity.\n\nThe
        /// warnings will be indicated by a blue squiggly underline in code and
-        /// a blue icon in the problems panel.
+        /// a blue icon in the `Problems Panel`.
        diagnostics_warningsAsHint: Vec<String> = "[]",
-        /// List of warnings that should be displayed with hint severity.\nThe
+        /// List of warnings that should be displayed with hint severity.\n\nThe
        /// warnings will be indicated by faded text or three dots in code and
-        /// will not show up in the problems panel.
+        /// will not show up in the `Problems Panel`.
        diagnostics_warningsAsInfo: Vec<String> = "[]",
        /// Controls file watching implementation.
@@ -121,7 +121,7 @@ config_data! {
        /// Whether to show inlay type hints for method chains.
        inlayHints_chainingHints: bool      = "true",
-        /// Maximum length for inlay hints.
+        /// Maximum length for inlay hints. Default is unlimited.
        inlayHints_maxLength: Option<usize> = "null",
        /// Whether to show function parameter name inlay hints at the call
        /// site.
@@ -145,27 +145,27 @@ config_data! {
        lens_methodReferences: bool = "false",
        /// Disable project auto-discovery in favor of explicitly specified set
-        /// of projects.  \nElements must be paths pointing to Cargo.toml,
+        /// of projects.\n\nElements must be paths pointing to `Cargo.toml`,
-        /// rust-project.json, or JSON objects in rust-project.json format.
+        /// `rust-project.json`, or JSON objects in `rust-project.json` format.
        linkedProjects: Vec<ManifestOrProjectJson> = "[]",
-        /// Number of syntax trees rust-analyzer keeps in memory.
+        /// Number of syntax trees rust-analyzer keeps in memory.  Defaults to 128.
        lruCapacity: Option<usize>                 = "null",
        /// Whether to show `can't find Cargo.toml` error message.
        notifications_cargoTomlNotFound: bool      = "true",
-        /// Enable Proc macro support, cargo.loadOutDirsFromCheck must be
+        /// Enable Proc macro support, `#rust-analyzer.cargo.loadOutDirsFromCheck#` must be
        /// enabled.
        procMacro_enable: bool                     = "false",
        /// Command to be executed instead of 'cargo' for runnables.
        runnables_overrideCargo: Option<String> = "null",
        /// Additional arguments to be passed to cargo for runnables such as
-        /// tests or binaries.\nFor example, it may be '--release'.
+        /// tests or binaries.\nFor example, it may be `--release`.
        runnables_cargoExtraArgs: Vec<String>   = "[]",
        /// Path to the rust compiler sources, for usage in rustc_private projects.
        rustcSource : Option<String> = "null",
-        /// Additional arguments to rustfmt.
+        /// Additional arguments to `rustfmt`.
        rustfmt_extraArgs: Vec<String>               = "[]",
        /// Advanced option, fully override the command rust-analyzer uses for
        /// formatting.
@@ -349,12 +349,12 @@ impl Config {
        res
    }
    pub fn update(&mut self, json: serde_json::Value) {
-        log::info!("Config::update({:#})", json);
+        log::info!("updating config from JSON: {:#}", json);
        if json.is_null() || json.as_object().map_or(false, |it| it.is_empty()) {
            return;
        }
        self.do_update(json);
-        log::info!("Config::update() = {:#?}", self);
+        log::info!("updated config: {:#?}", self);
    }
    fn do_update(&mut self, json: serde_json::Value) {
        let data = ConfigData::from_json(json);
@@ -758,7 +758,7 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json
            ],
            "enumDescriptions": [
                "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
-                "Prefix all import paths with `self` if they don't begin with `self`, `super`, `crate` or a crate name",
+                "Prefix all import paths with `self` if they don't begin with `self`, `super`, `crate` or a crate name.",
                "Force import paths to be absolute by always starting them with `crate` or the crate name they refer to."
            ],
        },
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index f16f97131..540759198 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -319,6 +319,10 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
                message: "original diagnostic".to_string(),
            };
            for info in &related_information {
+                // Filter out empty/non-existent messages, as they greatly confuse VS Code.
+                if info.message.is_empty() {
+                    continue;
+                }
                diagnostics.push(MappedRustDiagnostic {
                    url: info.location.uri.clone(),
                    fixes: fixes.clone(), // share fixes to make them easier to apply
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index e0561b5a7..5a1ae96aa 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -634,30 +634,47 @@ pub(crate) fn snippet_text_document_edit(
    Ok(lsp_ext::SnippetTextDocumentEdit { text_document, edits })
 }
-pub(crate) fn resource_op(
+pub(crate) fn snippet_text_document_ops(
    snap: &GlobalStateSnapshot,
    file_system_edit: FileSystemEdit,
-) -> lsp_types::ResourceOp {
+) -> Vec<lsp_ext::SnippetDocumentChangeOperation> {
+    let mut ops = Vec::new();
    match file_system_edit {
-        FileSystemEdit::CreateFile { dst } => {
+        FileSystemEdit::CreateFile { dst, initial_contents } => {
            let uri = snap.anchored_path(&dst);
-            lsp_types::ResourceOp::Create(lsp_types::CreateFile {
+            let create_file = lsp_types::ResourceOp::Create(lsp_types::CreateFile {
-                uri,
+                uri: uri.clone(),
                options: None,
                annotation_id: None,
-            })
+            });
+            ops.push(lsp_ext::SnippetDocumentChangeOperation::Op(create_file));
+            if !initial_contents.is_empty() {
+                let text_document =
+                    lsp_types::OptionalVersionedTextDocumentIdentifier { uri, version: None };
+                let range = range(&LineIndex::new(""), TextRange::empty(TextSize::from(0)));
+                let text_edit = lsp_ext::SnippetTextEdit {
+                    range,
+                    new_text: initial_contents,
+                    insert_text_format: Some(lsp_types::InsertTextFormat::PlainText),
+                };
+                let edit_file =
+                    lsp_ext::SnippetTextDocumentEdit { text_document, edits: vec![text_edit] };
+                ops.push(lsp_ext::SnippetDocumentChangeOperation::Edit(edit_file));
+            }
        }
        FileSystemEdit::MoveFile { src, dst } => {
            let old_uri = snap.file_id_to_url(src);
            let new_uri = snap.anchored_path(&dst);
-            lsp_types::ResourceOp::Rename(lsp_types::RenameFile {
+            let rename_file = lsp_types::ResourceOp::Rename(lsp_types::RenameFile {
                old_uri,
                new_uri,
                options: None,
                annotation_id: None,
-            })
+            });
+            ops.push(lsp_ext::SnippetDocumentChangeOperation::Op(rename_file))
        }
    }
+    ops
 }
 pub(crate) fn snippet_workspace_edit(
@@ -666,8 +683,8 @@ pub(crate) fn snippet_workspace_edit(
 ) -> Result<lsp_ext::SnippetWorkspaceEdit> {
    let mut document_changes: Vec<lsp_ext::SnippetDocumentChangeOperation> = Vec::new();
    for op in source_change.file_system_edits {
-        let op = resource_op(&snap, op);
+        let ops = snippet_text_document_ops(snap, op);
-        document_changes.push(lsp_ext::SnippetDocumentChangeOperation::Op(op));
+        document_changes.extend_from_slice(&ops);
    }
    for edit in source_change.source_file_edits {
        let edit = snippet_text_document_edit(&snap, source_change.is_snippet, edit)?;
diff --git a/crates/syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rast b/crates/syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rast
index 6403ff8d5..d3219f0b2 100644
--- a/crates/syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rast
@@ -6,16 +6,16 @@ [email protected]
      [email protected] "f"
    [email protected]
      [email protected] "("
-      ATT[email protected]6
+      SELF_PARAM@5..21
-        POUND@5..6 "#"
+        ATTR@5..16
-        L_BRACK@6..7 "["
+          POUND@5..6 "#"
-        PATH@7..15
+          L_BRACK@6..7 "["
-          PATH_SEGMENT@7..15
+          [email protected]
-            NAME_REF@7..15
+            PATH_SEGMENT@7..15
-              IDENT@7..15 "must_use"
+              NAME_REF@7..15
-        R_BRACK@15..16 "]"
+                IDENT@7..15 "must_use"
-      WHITESPACE@16..17 " "
+          R_BRACK@15..16 "]"
-      SELF_PARAM@17..21
+        WHITESPACE@16..17 " "
        [email protected] "self"
      [email protected] ")"
    [email protected] " "
diff --git a/crates/syntax/test_data/parser/inline/ok/0154_no_dyn_trait_leading_for.rast b/crates/syntax/test_data/parser/inline/ok/0154_no_dyn_trait_leading_for.rast
new file mode 100644
index 000000000..edfcb288c
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0154_no_dyn_trait_leading_for.rast
@@ -0,0 +1,43 @@
+[email protected]
+  [email protected]
+    [email protected] "type"
+    [email protected] " "
+    [email protected]
+      [email protected] "A"
+    [email protected] " "
+    [email protected] "="
+    [email protected] " "
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected] "for"
+            [email protected]
+              [email protected] "<"
+              [email protected]
+                [email protected]
+                  [email protected] "\'a"
+              [email protected] ">"
+            [email protected] " "
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected] "Test"
+                  [email protected]
+                    [email protected] "<"
+                    [email protected]
+                      [email protected]
+                        [email protected] "\'a"
+                    [email protected] ">"
+        [email protected] " "
+        [email protected] "+"
+        [email protected] " "
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected] "Send"
+    [email protected] ";"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0154_no_dyn_trait_leading_for.rs b/crates/syntax/test_data/parser/inline/ok/0154_no_dyn_trait_leading_for.rs
new file mode 100644
index 000000000..47a71fd19
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0154_no_dyn_trait_leading_for.rs
@@ -0,0 +1 @@
+type A = for<'a> Test<'a> + Send;
diff --git a/crates/syntax/test_data/parser/inline/ok/0154_tuple_attrs.rast b/crates/syntax/test_data/parser/inline/ok/0154_tuple_attrs.rast
new file mode 100644
index 000000000..d34b21abe
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0154_tuple_attrs.rast
@@ -0,0 +1,50 @@
+[email protected]
+  [email protected]
+    [email protected] "const"
+    [email protected] " "
+    [email protected]
+      [email protected] "A"
+    [email protected] ":"
+    [email protected] " "
+    [email protected]
+      [email protected] "("
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected] "i64"
+      [email protected] ","
+      [email protected] " "
+      [email protected]
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected] "i64"
+      [email protected] ")"
+    [email protected] " "
+    [email protected] "="
+    [email protected] " "
+    [email protected]
+      [email protected] "("
+      [email protected]
+        [email protected] "1"
+      [email protected] ","
+      [email protected] " "
+      [email protected]
+        [email protected]
+          [email protected] "#"
+          [email protected] "["
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected] "cfg"
+          [email protected]
+            [email protected] "("
+            [email protected] "test"
+            [email protected] ")"
+          [email protected] "]"
+        [email protected] " "
+        [email protected] "2"
+      [email protected] ")"
+    [email protected] ";"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0154_tuple_attrs.rs b/crates/syntax/test_data/parser/inline/ok/0154_tuple_attrs.rs
new file mode 100644
index 000000000..f84b7ab31
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0154_tuple_attrs.rs
@@ -0,0 +1 @@
+const A: (i64, i64) = (1, #[cfg(test)] 2);
diff --git a/crates/syntax/test_data/parser/ok/0051_parameter_attrs.rast b/crates/syntax/test_data/parser/ok/0051_parameter_attrs.rast
index 8974f9e40..3fed11838 100644
--- a/crates/syntax/test_data/parser/ok/0051_parameter_attrs.rast
+++ b/crates/syntax/test_data/parser/ok/0051_parameter_attrs.rast
@@ -107,16 +107,16 @@ [email protected]
                      [email protected] "i8"
          [email protected] ","
          [email protected] " "
-          ATT[email protected]3
+          PARAM@106..117
-            POUND@106..107 "#"
+            ATTR@106..113
-            L_BRACK@107..108 "["
+              POUND@106..107 "#"
-            PATH@108..112
+              L_BRACK@107..108 "["
-              PATH_SEGMENT@108..112
+              [email protected]
-                NAME_REF@108..112
+                PATH_SEGMENT@108..112
-                  IDENT@108..112 "attr"
+                  NAME_REF@108..112
-            R_BRACK@112..113 "]"
+                    IDENT@108..112 "attr"
-          WHITESPACE@113..114 " "
+              R_BRACK@112..113 "]"
-          PARAM@114..117
+            WHITESPACE@113..114 " "
            [email protected] "..."
          [email protected] ")"
        [email protected] " "
@@ -153,16 +153,16 @@ [email protected]
                    [email protected] "FnMut"
                  [email protected]
                    [email protected] "("
-                    ATT[email protected]53
+                    PARAM@146..166
-                      POUND@146..147 "#"
+                      ATTR@146..153
-                      L_BRACK@147..148 "["
+                        POUND@146..147 "#"
-                      PATH@148..152
+                        L_BRACK@147..148 "["
-                        PATH_SEGMENT@148..152
+                        [email protected]
-                          NAME_REF@148..152
+                          PATH_SEGMENT@148..152
-                            IDENT@148..152 "attr"
+                            NAME_REF@148..152
-                      R_BRACK@152..153 "]"
+                              IDENT@148..152 "attr"
-                    WHITESPACE@153..154 " "
+                        R_BRACK@152..153 "]"
-                    PARAM@154..166
+                      WHITESPACE@153..154 " "
                      [email protected]
                        [email protected] "&"
                        [email protected] "mut"
@@ -224,17 +224,17 @@ [email protected]
                    [email protected] "u64"
          [email protected] ","
          [email protected] " "
-          ATT[email protected]1
+          PARAM@213..232
-            POUND@213..214 "#"
+            ATTR@213..221
-            WHITESPACE@214..215 " "
+              POUND@213..214 "#"
-            L_BRACK@215..216 "["
+              WHITESPACE@214..215 " "
-            PATH@216..220
+              L_BRACK@215..216 "["
-              PATH_SEGMENT@216..220
+              [email protected]
-                NAME_REF@216..220
+                PATH_SEGMENT@216..220
-                  IDENT@216..220 "attr"
+                  NAME_REF@216..220
-            R_BRACK@220..221 "]"
+                    IDENT@216..220 "attr"
-          WHITESPACE@221..222 " "
+              R_BRACK@220..221 "]"
-          PARAM@222..232
+            WHITESPACE@221..222 " "
            [email protected]
              [email protected] "mut"
              [email protected] " "
@@ -271,16 +271,16 @@ [email protected]
          [email protected] "f"
        [email protected]
          [email protected] "("
-          ATT[email protected]68
+          SELF_PARAM@257..273
-            POUND@257..258 "#"
+            ATTR@257..268
-            L_BRACK@258..259 "["
+              POUND@257..258 "#"
-            PATH@259..267
+              L_BRACK@258..259 "["
-              PATH_SEGMENT@259..267
+              [email protected]
-                NAME_REF@259..267
+                PATH_SEGMENT@259..267
-                  IDENT@259..267 "must_use"
+                  NAME_REF@259..267
-            R_BRACK@267..268 "]"
+                    IDENT@259..267 "must_use"
-          WHITESPACE@268..269 " "
+              R_BRACK@267..268 "]"
-          SELF_PARAM@269..273
+            WHITESPACE@268..269 " "
            [email protected] "self"
          [email protected] ")"
        [email protected] " "
@@ -295,16 +295,16 @@ [email protected]
          [email protected] "g1"
        [email protected]
          [email protected] "("
-          ATTR@289..296
+          SELF_PARAM@289..301
-            POUND@289..290 "#"
+            ATTR@289..296
-            L_BRACK@290..291 "["
+              POUND@289..290 "#"
-            PATH@291..295
+              L_BRACK@290..291 "["
-              PATH_SEGMENT@291..295
+              [email protected]
-                NAME_REF@291..295
+                PATH_SEGMENT@291..295
-                  IDENT@291..295 "attr"
+                  NAME_REF@291..295
-            R_BRACK@295..296 "]"
+                    IDENT@291..295 "attr"
-          WHITESPACE@296..297 " "
+              R_BRACK@295..296 "]"
-          SELF_PARAM@297..301
+            WHITESPACE@296..297 " "
            [email protected] "self"
          [email protected] ")"
        [email protected] " "
@@ -319,16 +319,16 @@ [email protected]
          [email protected] "g2"
        [email protected]
          [email protected] "("
-          ATT[email protected]24
+          SELF_PARAM@317..330
-            POUND@317..318 "#"
+            ATTR@317..324
-            L_BRACK@318..319 "["
+              POUND@317..318 "#"
-            PATH@319..323
+              L_BRACK@318..319 "["
-              PATH_SEGMENT@319..323
+              [email protected]
-                NAME_REF@319..323
+                PATH_SEGMENT@319..323
-                  IDENT@319..323 "attr"
+                  NAME_REF@319..323
-            R_BRACK@323..324 "]"
+                    IDENT@319..323 "attr"
-          WHITESPACE@324..325 " "
+              R_BRACK@323..324 "]"
-          SELF_PARAM@325..330
+            WHITESPACE@324..325 " "
            [email protected] "&"
            [email protected] "self"
          [email protected] ")"
@@ -350,16 +350,16 @@ [email protected]
          [email protected] ">"
        [email protected]
          [email protected] "("
-          ATT[email protected]57
+          SELF_PARAM@350..367
-            POUND@350..351 "#"
+            ATTR@350..357
-            L_BRACK@351..352 "["
+              POUND@350..351 "#"
-            PATH@352..356
+              L_BRACK@351..352 "["
-              PATH_SEGMENT@352..356
+              [email protected]
-                NAME_REF@352..356
+                PATH_SEGMENT@352..356
-                  IDENT@352..356 "attr"
+                  NAME_REF@352..356
-            R_BRACK@356..357 "]"
+                    IDENT@352..356 "attr"
-          WHITESPACE@357..358 " "
+              R_BRACK@356..357 "]"
-          SELF_PARAM@358..367
+            WHITESPACE@357..358 " "
            [email protected] "&"
            [email protected] "mut"
            [email protected] " "
@@ -383,16 +383,16 @@ [email protected]
          [email protected] ">"
        [email protected]
          [email protected] "("
-          ATTR@387..394
+          SELF_PARAM@387..403
-            POUND@387..388 "#"
+            ATTR@387..394
-            L_BRACK@388..389 "["
+              POUND@387..388 "#"
-            PATH@389..393
+              L_BRACK@388..389 "["
-              PATH_SEGMENT@389..393
+              [email protected]
-                NAME_REF@389..393
+                PATH_SEGMENT@389..393
-                  IDENT@389..393 "attr"
+                  NAME_REF@389..393
-            R_BRACK@393..394 "]"
+                    IDENT@389..393 "attr"
-          WHITESPACE@394..395 " "
+              R_BRACK@393..394 "]"
-          SELF_PARAM@395..403
+            WHITESPACE@394..395 " "
            [email protected] "&"
            [email protected]
              [email protected] "\'a"
@@ -417,16 +417,16 @@ [email protected]
          [email protected] ">"
        [email protected]
          [email protected] "("
-          ATT[email protected]0
+          SELF_PARAM@423..443
-            POUND@423..424 "#"
+            ATTR@423..430
-            L_BRACK@424..425 "["
+              POUND@423..424 "#"
-            PATH@425..429
+              L_BRACK@424..425 "["
-              PATH_SEGMENT@425..429
+              [email protected]
-                NAME_REF@425..429
+                PATH_SEGMENT@425..429
-                  IDENT@425..429 "attr"
+                  NAME_REF@425..429
-            R_BRACK@429..430 "]"
+                    IDENT@425..429 "attr"
-          WHITESPACE@430..431 " "
+              R_BRACK@429..430 "]"
-          SELF_PARAM@431..443
+            WHITESPACE@430..431 " "
            [email protected] "&"
            [email protected]
              [email protected] "\'a"
@@ -447,16 +447,16 @@ [email protected]
          [email protected] "c"
        [email protected]
          [email protected] "("
-          ATT[email protected]5
+          SELF_PARAM@458..476
-            POUND@458..459 "#"
+            ATTR@458..465
-            L_BRACK@459..460 "["
+              POUND@458..459 "#"
-            PATH@460..464
+              L_BRACK@459..460 "["
-              PATH_SEGMENT@460..464
+              [email protected]
-                NAME_REF@460..464
+                PATH_SEGMENT@460..464
-                  IDENT@460..464 "attr"
+                  NAME_REF@460..464
-            R_BRACK@464..465 "]"
+                    IDENT@460..464 "attr"
-          WHITESPACE@465..466 " "
+              R_BRACK@464..465 "]"
-          SELF_PARAM@466..476
+            WHITESPACE@465..466 " "
            [email protected] "self"
            [email protected] ":"
            [email protected] " "
@@ -478,16 +478,16 @@ [email protected]
          [email protected] "d"
        [email protected]
          [email protected] "("
-          ATTR@491..498
+          SELF_PARAM@491..513
-            POUND@491..492 "#"
+            ATTR@491..498
-            L_BRACK@492..493 "["
+              POUND@491..492 "#"
-            PATH@493..497
+              L_BRACK@492..493 "["
-              PATH_SEGMENT@493..497
+              [email protected]
-                NAME_REF@493..497
+                PATH_SEGMENT@493..497
-                  IDENT@493..497 "attr"
+                  NAME_REF@493..497
-            R_BRACK@497..498 "]"
+                    IDENT@493..497 "attr"
-          WHITESPACE@498..499 " "
+              R_BRACK@497..498 "]"
-          SELF_PARAM@499..513
+            WHITESPACE@498..499 " "
            [email protected] "self"
            [email protected] ":"
            [email protected] " "
diff --git a/crates/syntax/test_data/parser/ok/0063_variadic_fun.rast b/crates/syntax/test_data/parser/ok/0063_variadic_fun.rast
index 4009b3ff8..f7c094898 100644
--- a/crates/syntax/test_data/parser/ok/0063_variadic_fun.rast
+++ b/crates/syntax/test_data/parser/ok/0063_variadic_fun.rast
@@ -92,20 +92,20 @@ [email protected]
                      [email protected] "u8"
          [email protected] ","
          [email protected] " "
-          ATT[email protected]5
+          PARAM@92..120
-            POUND@92..93 "#"
+            ATTR@92..105
-            L_BRACK@93..94 "["
+              POUND@92..93 "#"
-            PATH@94..97
+              L_BRACK@93..94 "["
-              PATH_SEGMENT@94..97
+              [email protected]
-                NAME_REF@94..97
+                PATH_SEGMENT@94..97
-                  IDENT@94..97 "cfg"
+                  NAME_REF@94..97
-            TOKEN_TREE@97..104
+                    IDENT@94..97 "cfg"
-              L_PAREN@97..98 "("
+              TOKEN_TREE@97..104
-              IDENT@98..103 "never"
+                L_PAREN@97..98 "("
-              R_PAREN@103..104 ")"
+                IDENT@98..103 "never"
-            R_BRACK@104..105 "]"
+                R_PAREN@103..104 ")"
-          WHITESPACE@105..106 " "
+              R_BRACK@104..105 "]"
-          PARAM@106..120
+            WHITESPACE@105..106 " "
            [email protected]
              [email protected] "["
              [email protected]