44 files changed, 977 insertions, 1476 deletions
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 919d58925..09752b817 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -15,12 +15,9 @@ env:
  RUSTUP_MAX_RETRIES: 10
 jobs:
-  dist:
+  dist-windows:
-    name: dist
+    name: dist (Windows)
-    runs-on: ${{ matrix.os }}
+    runs-on: windows-latest
-    strategy:
-      matrix:
-        os: [ubuntu-16.04, windows-latest, macos-latest]
    steps:
    - name: Checkout repository
@@ -30,8 +27,7 @@ jobs:
    # which takes a long time. The fastest way to do this is to rename the
    # existing folder, as deleting it takes about as much time as not doing
    # anything and just updating rust-docs.
-    - name: Rename existing rust toolchain (Windows)
+    - name: Rename existing rust toolchain
-      if: matrix.os == 'windows-latest'
      run: Rename-Item C:\Users\runneradmin\.rustup\toolchains\stable-x86_64-pc-windows-msvc C:\Users\runneradmin\.rustup\toolchains\stable-x86_64-pc-windows-msvc.old
    - name: Install Rust toolchain
@@ -41,38 +37,116 @@ jobs:
        profile: minimal
        override: true
+    - name: Dist
+      run: cargo xtask dist
+      env:
+        RA_TARGET: x86_64-pc-windows-msvc
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: dist-windows-latest
+        path: ./dist
+  dist-ubuntu:
+    name: dist (Ubuntu 16.04)
+    runs-on: ubuntu-16.04
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+    - name: Install Rust toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        profile: minimal
+        override: true
    - name: Install Nodejs
-      if: matrix.os == 'ubuntu-16.04'
      uses: actions/setup-node@v1
      with:
        node-version: 12.x
    - name: Dist
-      if: matrix.os == 'ubuntu-16.04' && github.ref == 'refs/heads/release'
+      if: github.ref == 'refs/heads/release'
      run: cargo xtask dist --client 0.2.$GITHUB_RUN_NUMBER
+      env:
+        RA_TARGET: x86_64-unknown-linux-gnu
    - name: Dist
-      if: matrix.os == 'ubuntu-16.04' && github.ref != 'refs/heads/release'
+      if: github.ref != 'refs/heads/release'
      run: cargo xtask dist --nightly --client 0.3.$GITHUB_RUN_NUMBER-nightly
+      env:
+        RA_TARGET: x86_64-unknown-linux-gnu
+    - name: Nightly analysis-stats check
+      if: github.ref != 'refs/heads/release'
+      run: ./dist/rust-analyzer-x86_64-unknown-linux-gnu analysis-stats .
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: dist-ubuntu-16.04
+        path: ./dist
+  dist-macos-latest:
+    name: dist (MacOS latest)
+    runs-on: macos-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+    - name: Install Rust toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        profile: minimal
+        override: true
    - name: Dist
-      if: matrix.os != 'ubuntu-16.04'
      run: cargo xtask dist
+      env:
+        RA_TARGET: x86_64-apple-darwin
-    - name: Nightly analysis-stats check
+    - name: Upload artifacts
-      if: matrix.os == 'ubuntu-16.04' && github.ref != 'refs/heads/release'
+      uses: actions/upload-artifact@v1
-      run: ./dist/rust-analyzer-linux analysis-stats .
+      with:
+        name: dist-macos-latest
+        path: ./dist
+  dist-macos-11:
+    name: dist (MacOS 11.0)
+    runs-on: macos-11.0
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+    - name: Install Rust toolchain (beta)
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: beta
+        target: aarch64-apple-darwin
+        profile: minimal
+        override: true
+    - name: Dist
+      run: cargo xtask dist
+      env:
+        RA_TARGET: aarch64-apple-darwin
    - name: Upload artifacts
      uses: actions/upload-artifact@v1
      with:
-        name: dist-${{ matrix.os }}
+        name: dist-macos-11.0
        path: ./dist
  publish:
    name: publish
    runs-on: ubuntu-16.04
-    needs: ['dist']
+    needs: ['dist-windows', 'dist-ubuntu', 'dist-macos-latest', 'dist-macos-11']
    steps:
    - name: Install Nodejs
      uses: actions/setup-node@v1
@@ -93,6 +167,10 @@ jobs:
    - uses: actions/download-artifact@v1
      with:
+        name: dist-macos-11.0
+        path: dist
+    - uses: actions/download-artifact@v1
+      with:
        name: dist-macos-latest
        path: dist
    - uses: actions/download-artifact@v1
@@ -103,7 +181,7 @@ jobs:
      with:
        name: dist-windows-latest
        path: dist
-    - run: ls -all ./dist
+    - run: ls -al ./dist
    - name: Publish Release
      uses: ./.github/actions/github-release
diff --git a/Cargo.lock b/Cargo.lock
index 1051c4ec6..fbb79e01f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1251,9 +1251,9 @@ dependencies = [
 [[package]]
 name = "quote"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
+checksum = "991431c3519a3f36861882da93630ce66b52918dcf1b8e2fd66b397fc96f28df"
 dependencies = [
 "proc-macro2",
 ]
@@ -1588,9 +1588,9 @@ version = "0.0.0"
 [[package]]
 name = "syn"
-version = "1.0.54"
+version = "1.0.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2af957a63d6bd42255c359c93d9bfdb97076bd3b820897ce55ffbfbf107f44"
+checksum = "a571a711dddd09019ccc628e1b17fe87c59b09d513c06c026877aa708334f37a"
 dependencies = [
 "proc-macro2",
 "quote",
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..3e67fdca2
--- /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 submodule;
+//- /submodule.rs
+mod inner<|> {
+    fn f() {}
+}
+fn g() {}
+"#,
+            r#"
+//- /submodule.rs
+mod inner;
+fn g() {}
+//- /submodule/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/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index dbc937e4f..1d7e5ddd7 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -1272,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_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..431da5d9c 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1077,4 +1077,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/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 1f4b5c24c..11cdae57f 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.
@@ -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]
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index cb2ae6fc1..3025dc8d6 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -5,7 +5,7 @@ rust-analyzer.assist.importPrefix (default: `"plain"`)::
 rust-analyzer.callInfo.full (default: `true`)::
 Show function name and docs in parameter hints.
 rust-analyzer.cargo.autoreload (default: `true`)::
- Automatically refresh project info via `cargo metadata` on  Cargo.toml changes.
+ Automatically refresh project info via `cargo metadata` on  `Cargo.toml` changes.
 rust-analyzer.cargo.allFeatures (default: `false`)::
 Activate all available features.
 rust-analyzer.cargo.features (default: `[]`)::
@@ -21,7 +21,7 @@ rust-analyzer.cargo.noSysroot (default: `false`)::
 rust-analyzer.checkOnSave.enable (default: `true`)::
 Run specified `cargo check` command for diagnostics on save.
 rust-analyzer.checkOnSave.allFeatures (default: `null`)::
- Check with all features (will be passed as `--all-features`).  Defaults to `rust-analyzer.cargo.allFeatures`.
+ Check with all features (will be passed as `--all-features`).  Defaults to `#rust-analyzer.cargo.allFeatures#`.
 rust-analyzer.checkOnSave.allTargets (default: `true`)::
 Check all targets and tests (will be passed as `--all-targets`).
 rust-analyzer.checkOnSave.command (default: `"check"`)::
@@ -29,11 +29,11 @@ rust-analyzer.checkOnSave.command (default: `"check"`)::
 rust-analyzer.checkOnSave.noDefaultFeatures (default: `null`)::
 Do not activate the `default` feature.
 rust-analyzer.checkOnSave.target (default: `null`)::
- Check for a specific target. Defaults to  `rust-analyzer.cargo.target`.
+ Check for a specific target. Defaults to  `#rust-analyzer.cargo.target#`.
 rust-analyzer.checkOnSave.extraArgs (default: `[]`)::
 Extra arguments for `cargo check`.
 rust-analyzer.checkOnSave.features (default: `null`)::
- List of features to activate. Defaults to  `rust-analyzer.cargo.features`.
+ List of features to activate. Defaults to  `#rust-analyzer.cargo.features#`.
 rust-analyzer.checkOnSave.overrideCommand (default: `null`)::
 Advanced option, fully override the command rust-analyzer uses for  checking. The command should include `--message-format=json` or  similar option.
 rust-analyzer.completion.addCallArgumentSnippets (default: `true`)::
@@ -43,7 +43,7 @@ rust-analyzer.completion.addCallParenthesis (default: `true`)::
 rust-analyzer.completion.postfix.enable (default: `true`)::
 Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
 rust-analyzer.completion.autoimport.enable (default: `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.
+ Toggles the additional completions that automatically add imports when completed.  Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
 rust-analyzer.diagnostics.enable (default: `true`)::
 Whether to show native rust-analyzer diagnostics.
 rust-analyzer.diagnostics.enableExperimental (default: `true`)::
@@ -51,9 +51,9 @@ rust-analyzer.diagnostics.enableExperimental (default: `true`)::
 rust-analyzer.diagnostics.disabled (default: `[]`)::
 List of rust-analyzer diagnostics to disable.
 rust-analyzer.diagnostics.warningsAsHint (default: `[]`)::
- List of warnings that should be displayed with info severity.\nThe  warnings will be indicated by a blue squiggly underline in code and  a blue icon in the problems panel.
+ 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`.
 rust-analyzer.diagnostics.warningsAsInfo (default: `[]`)::
- List of warnings that should be displayed with hint severity.\nThe  warnings will be indicated by faded text or three dots in code and  will not show up in the problems panel.
+ 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`.
 rust-analyzer.files.watcher (default: `"client"`)::
 Controls file watching implementation.
 rust-analyzer.hoverActions.debug (default: `true`)::
@@ -71,7 +71,7 @@ rust-analyzer.hoverActions.linksInHover (default: `true`)::
 rust-analyzer.inlayHints.chainingHints (default: `true`)::
 Whether to show inlay type hints for method chains.
 rust-analyzer.inlayHints.maxLength (default: `null`)::
- Maximum length for inlay hints.
+ Maximum length for inlay hints. Default is unlimited.
 rust-analyzer.inlayHints.parameterHints (default: `true`)::
 Whether to show function parameter name inlay hints at the call  site.
 rust-analyzer.inlayHints.typeHints (default: `true`)::
@@ -87,20 +87,20 @@ rust-analyzer.lens.run (default: `true`)::
 rust-analyzer.lens.methodReferences (default: `false`)::
 Whether to show `Method References` lens. Only applies when  `#rust-analyzer.lens.enable#` is set.
 rust-analyzer.linkedProjects (default: `[]`)::
- Disable project auto-discovery in favor of explicitly specified set  of projects.  \nElements must be paths pointing to Cargo.toml,  rust-project.json, or JSON objects in rust-project.json format.
+ Disable project auto-discovery in favor of explicitly specified set  of projects.\n\nElements must be paths pointing to `Cargo.toml`,  `rust-project.json`, or JSON objects in `rust-project.json` format.
 rust-analyzer.lruCapacity (default: `null`)::
- Number of syntax trees rust-analyzer keeps in memory.
+ Number of syntax trees rust-analyzer keeps in memory.  Defaults to 128.
 rust-analyzer.notifications.cargoTomlNotFound (default: `true`)::
 Whether to show `can't find Cargo.toml` error message.
 rust-analyzer.procMacro.enable (default: `false`)::
- Enable Proc macro support, cargo.loadOutDirsFromCheck must be  enabled.
+ Enable Proc macro support, `#rust-analyzer.cargo.loadOutDirsFromCheck#` must be  enabled.
 rust-analyzer.runnables.overrideCargo (default: `null`)::
 Command to be executed instead of 'cargo' for runnables.
 rust-analyzer.runnables.cargoExtraArgs (default: `[]`)::
- Additional arguments to be passed to cargo for runnables such as  tests or binaries.\nFor example, it may be '--release'.
+ Additional arguments to be passed to cargo for runnables such as  tests or binaries.\nFor example, it may be `--release`.
 rust-analyzer.rustcSource (default: `null`)::
 Path to the rust compiler sources, for usage in rustc_private projects.
 rust-analyzer.rustfmt.extraArgs (default: `[]`)::
- Additional arguments to rustfmt.
+ Additional arguments to `rustfmt`.
 rust-analyzer.rustfmt.overrideCommand (default: `null`)::
 Advanced option, fully override the command rust-analyzer uses for  formatting.
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index 1ec6e81bb..40f10972f 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -46,8 +46,8 @@ You can install the latest release of the plugin from
 https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer[the marketplace].
 Note that the plugin may cause conflicts with the
-https://marketplace.visualstudio.com/items?itemName=rust-lang.rust[official Rust plugin]. It is
+https://marketplace.visualstudio.com/items?itemName=rust-lang.rust[official Rust plugin].
-recommended to disable the Rust plugin when using the rust-analyzer extension.
+It is recommended to disable the Rust plugin when using the rust-analyzer extension.
 By default, the plugin will prompt you to download the matching version of the server as well:
@@ -74,18 +74,21 @@ Note that we only support two most recent versions of VS Code.
 ==== Updates
-The extension will be updated automatically as new versions become available. It will ask your permission to download the matching language server version binary if needed.
+The extension will be updated automatically as new versions become available.
+It will ask your permission to download the matching language server version binary if needed.
 ===== Nightly
-We ship nightly releases for VS Code. To help us out with testing the newest code and follow the bleeding edge of our `master`, please use the following config:
+We ship nightly releases for VS Code.
+To help us out with testing the newest code and follow the bleeding edge of our `master`, please use the following config:
 [source,json]
 ----
 { "rust-analyzer.updates.channel": "nightly" }
 ----
-You will be prompted to install the `nightly` extension version. Just click `Download now` and from that moment you will get automatic updates every 24 hours.
+You will be prompted to install the `nightly` extension version.
+Just click `Download now` and from that moment you will get automatic updates every 24 hours.
 If you don't want to be asked for `Download now` every day when the new nightly version is released add the following to your `settings.json`:
 [source,json]
@@ -160,7 +163,8 @@ $ chmod +x ~/.local/bin/rust-analyzer
 Ensure `~/.local/bin` is listed in the `$PATH` variable.
-Alternatively, you can install it from source using the following command:
+Alternatively, you can install it from source using the command below.
+You'll need the latest stable version of the Rust toolchain.
 [source,bash]
 ----
@@ -198,7 +202,8 @@ Emacs support is maintained as part of the https://github.com/emacs-lsp/lsp-mode
 === Vim/NeoVim
-Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>. Not needed if the extension can install/update it on its own, coc-rust-analyzer is one example.
+Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
+Not needed if the extension can install/update it on its own, coc-rust-analyzer is one example.
 The are several LSP client implementations for vim or neovim:
@@ -270,14 +275,16 @@ Once `neovim/nvim-lspconfig` is installed, use `+lua require'nvim_lsp'.rust_anal
 Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
-You also need the `LSP` package. To install it:
+You also need the `LSP` package.
+To install it:
 1. If you've never installed a Sublime Text package, install Package Control:
   * Open the command palette (Win/Linux: `ctrl+shift+p`, Mac: `cmd+shift+p`)
   * Type `Install Package Control`, press enter
 2. In the command palette, run `Package control: Install package`, and in the list that pops up, type `LSP` and press enter.
-Finally, with your Rust project open, in the command palette, run `LSP: Enable Language Server In Project` or `LSP: Enable Language Server Globally`, then select `rust-analyzer` in the list that pops up to enable the rust-analyzer LSP. The latter means that rust-analyzer is enabled by default in Rust projects.
+Finally, with your Rust project open, in the command palette, run `LSP: Enable Language Server In Project` or `LSP: Enable Language Server Globally`, then select `rust-analyzer` in the list that pops up to enable the rust-analyzer LSP.
+The latter means that rust-analyzer is enabled by default in Rust projects.
 If it worked, you should see "rust-analyzer, Line X, Column Y" on the left side of the bottom bar, and after waiting a bit, functionality like tooltips on hovering over variables should become available.
@@ -285,7 +292,8 @@ If you get an error saying `No such file or directory: 'rust-analyzer'`, see the
 === GNOME Builder
-GNOME Builder 3.37.1 and newer has native `rust-analyzer` support. If the LSP binary is not available, GNOME Builder can install it when opening a Rust file.
+GNOME Builder 3.37.1 and newer has native `rust-analyzer` support.
+If the LSP binary is not available, GNOME Builder can install it when opening a Rust file.
 == Configuration
@@ -413,8 +421,8 @@ include::./generated_diagnostic.adoc[]
 ==== Color configurations
-It is possible to change the foreground/background color of inlay hints. Just add this to your
+It is possible to change the foreground/background color of inlay hints.
-`settings.json`:
+Just add this to your `settings.json`:
 [source,jsonc]
 ----
@@ -436,7 +444,8 @@ It is possible to change the foreground/background color of inlay hints. Just ad
 ==== Semantic style customizations
-You can customize the look of different semantic elements in the source code. For example, mutable bindings are underlined by default and you can override this behavior by adding the following section to your `settings.json`:
+You can customize the look of different semantic elements in the source code.
+For example, mutable bindings are underlined by default and you can override this behavior by adding the following section to your `settings.json`:
 [source,jsonc]
 ----
@@ -452,7 +461,9 @@ You can customize the look of different semantic elements in the source code. Fo
 ----
 ==== Special `when` clause context for keybindings.
-You may use `inRustProject` context to configure keybindings for rust projects only. For example:
+You may use `inRustProject` context to configure keybindings for rust projects only.
+For example:
 [source,json]
 ----
 {
@@ -491,7 +502,8 @@ Or it is possible to specify vars more granularly:
 ]
 ```
-You can use any valid RegExp as a mask. Also note that a full runnable name is something like *run bin_or_example_name*, *test some::mod::test_name* or *test-mod some::mod*, so it is possible to distinguish binaries, single tests, and test modules with this masks: `"^run"`, `"^test "` (the trailing space matters!), and `"^test-mod"` respectively.
+You can use any valid regular expression as a mask.
+Also note that a full runnable name is something like *run bin_or_example_name*, *test some::mod::test_name* or *test-mod some::mod*, so it is possible to distinguish binaries, single tests, and test modules with this masks: `"^run"`, `"^test "` (the trailing space matters!), and `"^test-mod"` respectively.
 ==== Compiler feedback from external commands
diff --git a/editors/code/.vscodeignore b/editors/code/.vscodeignore
index 5096ce4da..c1cf00fa0 100644
--- a/editors/code/.vscodeignore
+++ b/editors/code/.vscodeignore
@@ -4,6 +4,5 @@
 !package.json
 !package-lock.json
 !ra_syntax_tree.tmGrammar.json
-!rust.tmGrammar.json
 !icon.png
 !README.md
diff --git a/editors/code/package.json b/editors/code/package.json
index ad01fea7b..13749a084 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -250,12 +250,12 @@
                        }
                    ],
                    "default": null,
-                    "description": "Environment variables passed to the runnable launched using `Test ` or `Debug` lens or `rust-analyzer.run` command."
+                    "markdownDescription": "Environment variables passed to the runnable launched using `Test` or `Debug` lens or `rust-analyzer.run` command."
                },
                "rust-analyzer.inlayHints.enable": {
                    "type": "boolean",
                    "default": true,
-                    "description": "Whether to show inlay hints"
+                    "description": "Whether to show inlay hints."
                },
                "rust-analyzer.updates.channel": {
                    "type": "string",
@@ -265,15 +265,15 @@
                    ],
                    "default": "stable",
                    "markdownEnumDescriptions": [
-                        "`\"stable\"` updates are shipped weekly, they don't contain cutting-edge features from VSCode proposed APIs but have less bugs in general",
+                        "`stable` updates are shipped weekly, they don't contain cutting-edge features from VSCode proposed APIs but have less bugs in general.",
-                        "`\"nightly\"` updates are shipped daily (extension updates automatically by downloading artifacts directly from GitHub), they contain cutting-edge features and latest bug fixes. These releases help us get your feedback very quickly and speed up rust-analyzer development **drastically**"
+                        "`nightly` updates are shipped daily (extension updates automatically by downloading artifacts directly from GitHub), they contain cutting-edge features and latest bug fixes. These releases help us get your feedback very quickly and speed up rust-analyzer development **drastically**."
                    ],
-                    "markdownDescription": "Choose `\"nightly\"` updates to get the latest features and bug fixes every day. While `\"stable\"` releases occur weekly and don't contain cutting-edge features from VSCode proposed APIs"
+                    "markdownDescription": "Choose `nightly` updates to get the latest features and bug fixes every day. While `stable` releases occur weekly and don't contain cutting-edge features from VSCode proposed APIs."
                },
                "rust-analyzer.updates.askBeforeDownload": {
                    "type": "boolean",
                    "default": true,
-                    "description": "Whether to ask for permission before downloading any files from the Internet"
+                    "description": "Whether to ask for permission before downloading any files from the Internet."
                },
                "rust-analyzer.serverPath": {
                    "type": [
@@ -281,7 +281,7 @@
                        "string"
                    ],
                    "default": null,
-                    "description": "Path to rust-analyzer executable (points to bundled binary by default). If this is set, then \"rust-analyzer.updates.channel\" setting is not used"
+                    "markdownDescription": "Path to rust-analyzer executable (points to bundled binary by default). If this is set, then `#rust-analyzer.updates.channel#` setting is not used"
                },
                "rust-analyzer.trace.server": {
                    "type": "string",
@@ -297,10 +297,10 @@
                        "Full log"
                    ],
                    "default": "off",
-                    "description": "Trace requests to the rust-analyzer (this is usually overly verbose and not recommended for regular users)"
+                    "description": "Trace requests to the rust-analyzer (this is usually overly verbose and not recommended for regular users)."
                },
                "rust-analyzer.trace.extension": {
-                    "description": "Enable logging of VS Code extensions itself",
+                    "description": "Enable logging of VS Code extensions itself.",
                    "type": "boolean",
                    "default": false
                },
@@ -327,14 +327,14 @@
                    }
                },
                "rust-analyzer.debug.openDebugPane": {
-                    "description": "Whether to open up the Debug Pane on debugging start.",
+                    "markdownDescription": "Whether to open up the `Debug Panel` on debugging start.",
                    "type": "boolean",
                    "default": false
                },
                "rust-analyzer.debug.engineSettings": {
                    "type": "object",
                    "default": {},
-                    "description": "Optional settings passed to the debug engine. Example:\n{ \"lldb\": { \"terminal\":\"external\"} }"
+                    "markdownDescription": "Optional settings passed to the debug engine. Example: `{ \"lldb\": { \"terminal\":\"external\"} }`"
                },
                "rust-analyzer.assist.importMergeBehaviour": {
                    "markdownDescription": "The strategy to use when inserting new imports or merging imports.",
@@ -362,7 +362,7 @@
                    ],
                    "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."
                    ]
                },
@@ -372,7 +372,7 @@
                    "type": "boolean"
                },
                "rust-analyzer.cargo.autoreload": {
-                    "markdownDescription": "Automatically refresh project info via `cargo metadata` on Cargo.toml changes.",
+                    "markdownDescription": "Automatically refresh project info via `cargo metadata` on `Cargo.toml` changes.",
                    "default": true,
                    "type": "boolean"
                },
@@ -418,7 +418,7 @@
                    "type": "boolean"
                },
                "rust-analyzer.checkOnSave.allFeatures": {
-                    "markdownDescription": "Check with all features (will be passed as `--all-features`). Defaults to `rust-analyzer.cargo.allFeatures`.",
+                    "markdownDescription": "Check with all features (will be passed as `--all-features`). Defaults to `#rust-analyzer.cargo.allFeatures#`.",
                    "default": null,
                    "type": [
                        "null",
@@ -444,7 +444,7 @@
                    ]
                },
                "rust-analyzer.checkOnSave.target": {
-                    "markdownDescription": "Check for a specific target. Defaults to `rust-analyzer.cargo.target`.",
+                    "markdownDescription": "Check for a specific target. Defaults to `#rust-analyzer.cargo.target#`.",
                    "default": null,
                    "type": [
                        "null",
@@ -460,7 +460,7 @@
                    }
                },
                "rust-analyzer.checkOnSave.features": {
-                    "markdownDescription": "List of features to activate. Defaults to `rust-analyzer.cargo.features`.",
+                    "markdownDescription": "List of features to activate. Defaults to `#rust-analyzer.cargo.features#`.",
                    "default": null,
                    "type": [
                        "null",
@@ -497,7 +497,7 @@
                    "type": "boolean"
                },
                "rust-analyzer.completion.autoimport.enable": {
-                    "markdownDescription": "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.",
+                    "markdownDescription": "Toggles the additional completions that automatically add imports when completed. Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.",
                    "default": true,
                    "type": "boolean"
                },
@@ -521,7 +521,7 @@
                    "uniqueItems": true
                },
                "rust-analyzer.diagnostics.warningsAsHint": {
-                    "markdownDescription": "List of warnings that should be displayed with info severity.\\nThe warnings will be indicated by a blue squiggly underline in code and a blue icon in the problems panel.",
+                    "markdownDescription": "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`.",
                    "default": [],
                    "type": "array",
                    "items": {
@@ -529,7 +529,7 @@
                    }
                },
                "rust-analyzer.diagnostics.warningsAsInfo": {
-                    "markdownDescription": "List of warnings that should be displayed with hint severity.\\nThe warnings will be indicated by faded text or three dots in code and will not show up in the problems panel.",
+                    "markdownDescription": "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`.",
                    "default": [],
                    "type": "array",
                    "items": {
@@ -577,7 +577,7 @@
                    "type": "boolean"
                },
                "rust-analyzer.inlayHints.maxLength": {
-                    "markdownDescription": "Maximum length for inlay hints.",
+                    "markdownDescription": "Maximum length for inlay hints. Default is unlimited.",
                    "default": null,
                    "type": [
                        "null",
@@ -621,7 +621,7 @@
                    "type": "boolean"
                },
                "rust-analyzer.linkedProjects": {
-                    "markdownDescription": "Disable project auto-discovery in favor of explicitly specified set of projects.  \\nElements must be paths pointing to Cargo.toml, rust-project.json, or JSON objects in rust-project.json format.",
+                    "markdownDescription": "Disable project auto-discovery in favor of explicitly specified set of projects.\\n\\nElements must be paths pointing to `Cargo.toml`, `rust-project.json`, or JSON objects in `rust-project.json` format.",
                    "default": [],
                    "type": "array",
                    "items": {
@@ -632,7 +632,7 @@
                    }
                },
                "rust-analyzer.lruCapacity": {
-                    "markdownDescription": "Number of syntax trees rust-analyzer keeps in memory.",
+                    "markdownDescription": "Number of syntax trees rust-analyzer keeps in memory.  Defaults to 128.",
                    "default": null,
                    "type": [
                        "null",
@@ -646,7 +646,7 @@
                    "type": "boolean"
                },
                "rust-analyzer.procMacro.enable": {
-                    "markdownDescription": "Enable Proc macro support, cargo.loadOutDirsFromCheck must be enabled.",
+                    "markdownDescription": "Enable Proc macro support, `#rust-analyzer.cargo.loadOutDirsFromCheck#` must be enabled.",
                    "default": false,
                    "type": "boolean"
                },
@@ -659,7 +659,7 @@
                    ]
                },
                "rust-analyzer.runnables.cargoExtraArgs": {
-                    "markdownDescription": "Additional arguments to be passed to cargo for runnables such as tests or binaries.\\nFor example, it may be '--release'.",
+                    "markdownDescription": "Additional arguments to be passed to cargo for runnables such as tests or binaries.\\nFor example, it may be `--release`.",
                    "default": [],
                    "type": "array",
                    "items": {
@@ -675,7 +675,7 @@
                    ]
                },
                "rust-analyzer.rustfmt.extraArgs": {
-                    "markdownDescription": "Additional arguments to rustfmt.",
+                    "markdownDescription": "Additional arguments to `rustfmt`.",
                    "default": [],
                    "type": "array",
                    "items": {
@@ -749,11 +749,6 @@
        ],
        "grammars": [
            {
-                "language": "rust",
-                "scopeName": "source.rust",
-                "path": "rust.tmGrammar.json"
-            },
-            {
                "language": "ra_syntax_tree",
                "scopeName": "source.ra_syntax_tree",
                "path": "ra_syntax_tree.tmGrammar.json"
diff --git a/editors/code/rust.tmGrammar.json b/editors/code/rust.tmGrammar.json
deleted file mode 100644
index 4759bb116..000000000
--- a/editors/code/rust.tmGrammar.json
+++ /dev/null
@@ -1,1140 +0,0 @@
-{
-    "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
-    "name": "Rust",
-    "fileTypes": [
-        "rs"
-    ],
-    "scopeName": "source.rust",
-    "patterns": [
-        {
-            "comment": "boxed slice literal",
-            "begin": "(<)(\\[)",
-            "beginCaptures": {
-                "1": {
-                    "name": "punctuation.brackets.angle.rust"
-                },
-                "2": {
-                    "name": "punctuation.brackets.square.rust"
-                }
-            },
-            "end": ">",
-            "endCaptures": {
-                "0": {
-                    "name": "punctuation.brackets.angle.rust"
-                }
-            },
-            "patterns": [
-                {
-                    "include": "#block-comments"
-                },
-                {
-                    "include": "#comments"
-                },
-                {
-                    "include": "#gtypes"
-                },
-                {
-                    "include": "#lvariables"
-                },
-                {
-                    "include": "#lifetimes"
-                },
-                {
-                    "include": "#punctuation"
-                },
-                {
-                    "include": "#types"
-                }
-            ]
-        },
-        {
-            "comment": "macro type metavariables",
-            "name": "meta.macro.metavariable.type.rust",
-            "match": "(\\$)((crate)|([A-Z][A-Za-z0-9_]*))((:)(block|expr|ident|item|lifetime|literal|meta|path?|stmt|tt|ty|vis))?",
-            "captures": {
-                "1": {
-                    "name": "keyword.operator.macro.dollar.rust"
-                },
-                "3": {
-                    "name": "keyword.other.crate.rust"
-                },
-                "4": {
-                    "name": "entity.name.type.metavariable.rust"
-                },
-                "6": {
-                    "name": "keyword.operator.key-value.rust"
-                },
-                "7": {
-                    "name": "variable.other.metavariable.specifier.rust"
-                }
-            },
-            "patterns": [
-                {
-                    "include": "#keywords"
-                }
-            ]
-        },
-        {
-            "comment": "macro metavariables",
-            "name": "meta.macro.metavariable.rust",
-            "match": "(\\$)([a-z][A-Za-z0-9_]*)((:)(block|expr|ident|item|lifetime|literal|meta|path?|stmt|tt|ty|vis))?",
-            "captures": {
-                "1": {
-                    "name": "keyword.operator.macro.dollar.rust"
-                },
-                "2": {
-                    "name": "variable.other.metavariable.name.rust"
-                },
-                "4": {
-                    "name": "keyword.operator.key-value.rust"
-                },
-                "5": {
-                    "name": "variable.other.metavariable.specifier.rust"
-                }
-            },
-            "patterns": [
-                {
-                    "include": "#keywords"
-                }
-            ]
-        },
-        {
-            "comment": "macro rules",
-            "name": "meta.macro.rules.rust",
-            "match": "\\b(macro_rules!)\\s+(([a-z0-9_]+)|([A-Z][a-z0-9_]*))\\s+(\\{)",
-            "captures": {
-                "1": {
-                    "name": "entity.name.function.macro.rules.rust"
-                },
-                "3": {
-                    "name": "entity.name.function.macro.rust"
-                },
-                "4": {
-                    "name": "entity.name.type.macro.rust"
-                },
-                "5": {
-                    "name": "punctuation.brackets.curly.rust"
-                }
-            }
-        },
-        {
-            "comment": "attributes",
-            "name": "meta.attribute.rust",
-            "begin": "(#)(\\!?)(\\[)",
-            "beginCaptures": {
-                "1": {
-                    "name": "punctuation.definition.attribute.rust"
-                },
-                "2": {
-                    "name": "keyword.operator.attribute.inner.rust"
-                },
-                "3": {
-                    "name": "punctuation.brackets.attribute.rust"
-                }
-            },
-            "end": "\\]",
-            "endCaptures": {
-                "0": {
-                    "name": "punctuation.brackets.attribute.rust"
-                }
-            },
-            "patterns": [
-                {
-                    "include": "#block-comments"
-                },
-                {
-                    "include": "#comments"
-                },
-                {
-                    "include": "#keywords"
-                },
-                {
-                    "include": "#punctuation"
-                },
-                {
-                    "include": "#strings"
-                },
-                {
-                    "include": "#gtypes"
-                },
-                {
-                    "include": "#types"
-                }
-            ]
-        },
-        {
-            "comment": "modules",
-            "match": "(mod)\\s+((?:r#(?!crate|[Ss]elf|super))?[a-z][A-Za-z0-9_]*)",
-            "captures": {
-                "1": {
-                    "name": "storage.type.rust"
-                },
-                "2": {
-                    "name": "entity.name.module.rust"
-                }
-            }
-        },
-        {
-            "comment": "external crate imports",
-            "name": "meta.import.rust",
-            "begin": "\\b(extern)\\s+(crate)",
-            "beginCaptures": {
-                "1": {
-                    "name": "storage.type.rust"
-                },
-                "2": {
-                    "name": "keyword.other.crate.rust"
-                }
-            },
-            "end": ";",
-            "endCaptures": {
-                "0": {
-                    "name": "punctuation.semi.rust"
-                }
-            },
-            "patterns": [
-                {
-                    "include": "#block-comments"
-                },
-                {
-                    "include": "#comments"
-                },
-                {
-                    "include": "#keywords"
-                },
-                {
-                    "include": "#punctuation"
-                }
-            ]
-        },
-        {
-            "comment": "use statements",
-            "name": "meta.use.rust",
-            "begin": "\\b(use)\\s",
-            "beginCaptures": {
-                "1": {
-                    "name": "keyword.other.rust"
-                }
-            },
-            "end": ";",
-            "endCaptures": {
-                "0": {
-                    "name": "punctuation.semi.rust"
-                }
-            },
-            "patterns": [
-                {
-                    "include": "#block-comments"
-                },
-                {
-                    "include": "#comments"
-                },
-                {
-                    "include": "#keywords"
-                },
-                {
-                    "include": "#namespaces"
-                },
-                {
-                    "include": "#punctuation"
-                },
-                {
-                    "include": "#types"
-                },
-                {
-                    "include": "#lvariables"
-                }
-            ]
-        },
-        {
-            "include": "#block-comments"
-        },
-        {
-            "include": "#comments"
-        },
-        {
-            "include": "#lvariables"
-        },
-        {
-            "include": "#constants"
-        },
-        {
-            "include": "#gtypes"
-        },
-        {
-            "include": "#functions"
-        },
-        {
-            "include": "#types"
-        },
-        {
-            "include": "#keywords"
-        },
-        {
-            "include": "#lifetimes"
-        },
-        {
-            "include": "#macros"
-        },
-        {
-            "include": "#namespaces"
-        },
-        {
-            "include": "#punctuation"
-        },
-        {
-            "include": "#strings"
-        },
-        {
-            "include": "#variables"
-        }
-    ],
-    "repository": {
-        "comments": {
-            "patterns": [
-                {
-                    "comment": "documentation comments",
-                    "name": "comment.line.documentation.rust",
-                    "match": "^\\s*///.*"
-                },
-                {
-                    "comment": "line comments",
-                    "name": "comment.line.double-slash.rust",
-                    "match": "\\s*//.*"
-                }
-            ]
-        },
-        "block-comments": {
-            "patterns": [
-                {
-                    "comment": "empty block comments",
-                    "name": "comment.block.rust",
-                    "match": "/\\*\\*/"
-                },
-                {
-                    "comment": "block documentation comments",
-                    "name": "comment.block.documentation.rust",
-                    "begin": "/\\*\\*",
-                    "end": "\\*/",
-                    "patterns": [
-                        {
-                            "include": "#block-comments"
-                        }
-                    ]
-                },
-                {
-                    "comment": "block comments",
-                    "name": "comment.block.rust",
-                    "begin": "/\\*(?!\\*)",
-                    "end": "\\*/",
-                    "patterns": [
-                        {
-                            "include": "#block-comments"
-                        }
-                    ]
-                }
-            ]
-        },
-        "constants": {
-            "patterns": [
-                {
-                    "comment": "ALL CAPS constants",
-                    "name": "constant.other.caps.rust",
-                    "match": "\\b[A-Z]{2}[A-Z0-9_]*\\b"
-                },
-                {
-                    "comment": "constant declarations",
-                    "match": "\\b(const)\\s+([A-Z][A-Za-z0-9_]*)\\b",
-                    "captures": {
-                        "1": {
-                            "name": "storage.type.rust"
-                        },
-                        "2": {
-                            "name": "constant.other.caps.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "decimal integers and floats",
-                    "name": "constant.numeric.decimal.rust",
-                    "match": "\\b\\d[\\d_]*(\\.?)[\\d_]*(?:(E)([+-])([\\d_]+))?(f32|f64|i128|i16|i32|i64|i8|isize|u128|u16|u32|u64|u8|usize)?\\b",
-                    "captures": {
-                        "1": {
-                            "name": "punctuation.separator.dot.decimal.rust"
-                        },
-                        "2": {
-                            "name": "keyword.operator.exponent.rust"
-                        },
-                        "3": {
-                            "name": "keyword.operator.exponent.sign.rust"
-                        },
-                        "4": {
-                            "name": "constant.numeric.decimal.exponent.mantissa.rust"
-                        },
-                        "5": {
-                            "name": "entity.name.type.numeric.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "hexadecimal integers",
-                    "name": "constant.numeric.hex.rust",
-                    "match": "\\b0x[\\da-fA-F_]+(i128|i16|i32|i64|i8|isize|u128|u16|u32|u64|u8|usize)?\\b",
-                    "captures": {
-                        "1": {
-                            "name": "entity.name.type.numeric.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "octal integers",
-                    "name": "constant.numeric.oct.rust",
-                    "match": "\\b0o[0-7_]+(i128|i16|i32|i64|i8|isize|u128|u16|u32|u64|u8|usize)?\\b",
-                    "captures": {
-                        "1": {
-                            "name": "entity.name.type.numeric.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "binary integers",
-                    "name": "constant.numeric.bin.rust",
-                    "match": "\\b0b[01_]+(i128|i16|i32|i64|i8|isize|u128|u16|u32|u64|u8|usize)?\\b",
-                    "captures": {
-                        "1": {
-                            "name": "entity.name.type.numeric.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "booleans",
-                    "name": "constant.language.bool.rust",
-                    "match": "\\b(true|false)\\b"
-                }
-            ]
-        },
-        "escapes": {
-            "comment": "escapes: ASCII, byte, Unicode, quote, regex",
-            "name": "constant.character.escape.rust",
-            "match": "(\\\\)(?:(?:(x[0-7][0-7a-fA-F])|(u(\\{)[\\da-fA-F]{4,6}(\\}))|.))",
-            "captures": {
-                "1": {
-                    "name": "constant.character.escape.backslash.rust"
-                },
-                "2": {
-                    "name": "constant.character.escape.bit.rust"
-                },
-                "3": {
-                    "name": "constant.character.escape.unicode.rust"
-                },
-                "4": {
-                    "name": "constant.character.escape.unicode.punctuation.rust"
-                },
-                "5": {
-                    "name": "constant.character.escape.unicode.punctuation.rust"
-                }
-            }
-        },
-        "functions": {
-            "patterns": [
-                {
-                    "comment": "pub as a function",
-                    "match": "\\b(pub)(\\()",
-                    "captures": {
-                        "1": {
-                            "name": "keyword.other.rust"
-                        },
-                        "2": {
-                            "name": "punctuation.brackets.round.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "function definition",
-                    "name": "meta.function.definition.rust",
-                    "begin": "\\b(fn)\\s+((?:r#(?!crate|[Ss]elf|super))?[A-Za-z0-9_]+)((\\()|(<))",
-                    "beginCaptures": {
-                        "1": {
-                            "name": "keyword.other.fn.rust"
-                        },
-                        "2": {
-                            "name": "entity.name.function.rust"
-                        },
-                        "4": {
-                            "name": "punctuation.brackets.round.rust"
-                        },
-                        "5": {
-                            "name": "punctuation.brackets.angle.rust"
-                        }
-                    },
-                    "end": "\\{|;",
-                    "endCaptures": {
-                        "0": {
-                            "name": "punctuation.brackets.curly.rust"
-                        }
-                    },
-                    "patterns": [
-                        {
-                            "include": "#block-comments"
-                        },
-                        {
-                            "include": "#comments"
-                        },
-                        {
-                            "include": "#keywords"
-                        },
-                        {
-                            "include": "#lvariables"
-                        },
-                        {
-                            "include": "#constants"
-                        },
-                        {
-                            "include": "#gtypes"
-                        },
-                        {
-                            "include": "#functions"
-                        },
-                        {
-                            "include": "#lifetimes"
-                        },
-                        {
-                            "include": "#macros"
-                        },
-                        {
-                            "include": "#namespaces"
-                        },
-                        {
-                            "include": "#punctuation"
-                        },
-                        {
-                            "include": "#strings"
-                        },
-                        {
-                            "include": "#types"
-                        },
-                        {
-                            "include": "#variables"
-                        }
-                    ]
-                },
-                {
-                    "comment": "function/method calls, chaining",
-                    "name": "meta.function.call.rust",
-                    "begin": "((?:r#(?!crate|[Ss]elf|super))?[A-Za-z0-9_]+)(\\()",
-                    "beginCaptures": {
-                        "1": {
-                            "name": "entity.name.function.rust"
-                        },
-                        "2": {
-                            "name": "punctuation.brackets.round.rust"
-                        }
-                    },
-                    "end": "\\)",
-                    "endCaptures": {
-                        "0": {
-                            "name": "punctuation.brackets.round.rust"
-                        }
-                    },
-                    "patterns": [
-                        {
-                            "include": "#block-comments"
-                        },
-                        {
-                            "include": "#comments"
-                        },
-                        {
-                            "include": "#keywords"
-                        },
-                        {
-                            "include": "#lvariables"
-                        },
-                        {
-                            "include": "#constants"
-                        },
-                        {
-                            "include": "#gtypes"
-                        },
-                        {
-                            "include": "#functions"
-                        },
-                        {
-                            "include": "#lifetimes"
-                        },
-                        {
-                            "include": "#macros"
-                        },
-                        {
-                            "include": "#namespaces"
-                        },
-                        {
-                            "include": "#punctuation"
-                        },
-                        {
-                            "include": "#strings"
-                        },
-                        {
-                            "include": "#types"
-                        },
-                        {
-                            "include": "#variables"
-                        }
-                    ]
-                },
-                {
-                    "comment": "function/method calls with turbofish",
-                    "name": "meta.function.call.rust",
-                    "begin": "((?:r#(?!crate|[Ss]elf|super))?[A-Za-z0-9_]+)(?=::<.*>\\()",
-                    "beginCaptures": {
-                        "1": {
-                            "name": "entity.name.function.rust"
-                        }
-                    },
-                    "end": "\\)",
-                    "endCaptures": {
-                        "0": {
-                            "name": "punctuation.brackets.round.rust"
-                        }
-                    },
-                    "patterns": [
-                        {
-                            "include": "#block-comments"
-                        },
-                        {
-                            "include": "#comments"
-                        },
-                        {
-                            "include": "#keywords"
-                        },
-                        {
-                            "include": "#lvariables"
-                        },
-                        {
-                            "include": "#constants"
-                        },
-                        {
-                            "include": "#gtypes"
-                        },
-                        {
-                            "include": "#functions"
-                        },
-                        {
-                            "include": "#lifetimes"
-                        },
-                        {
-                            "include": "#macros"
-                        },
-                        {
-                            "include": "#namespaces"
-                        },
-                        {
-                            "include": "#punctuation"
-                        },
-                        {
-                            "include": "#strings"
-                        },
-                        {
-                            "include": "#types"
-                        },
-                        {
-                            "include": "#variables"
-                        }
-                    ]
-                }
-            ]
-        },
-        "keywords": {
-            "patterns": [
-                {
-                    "comment": "control flow keywords",
-                    "name": "keyword.control.rust",
-                    "match": "\\b(await|break|continue|do|else|for|if|loop|match|return|try|while|yield)\\b"
-                },
-                {
-                    "comment": "storage keywords",
-                    "name": "storage.type.rust",
-                    "match": "\\b(const|enum|extern|let|macro|mod|struct|trait|type)\\b"
-                },
-                {
-                    "comment": "storage modifiers",
-                    "name": "storage.modifier.rust",
-                    "match": "\\b(abstract|static)\\b"
-                },
-                {
-                    "comment": "other keywords",
-                    "name": "keyword.other.rust",
-                    "match": "\\b(as|async|become|box|dyn|move|final|impl|in|override|priv|pub|ref|typeof|union|unsafe|unsized|use|virtual|where)\\b"
-                },
-                {
-                    "comment": "fn",
-                    "name": "keyword.other.fn.rust",
-                    "match": "\\bfn\\b"
-                },
-                {
-                    "comment": "crate",
-                    "name": "keyword.other.crate.rust",
-                    "match": "\\bcrate\\b"
-                },
-                {
-                    "comment": "mut",
-                    "name": "storage.modifier.mut.rust",
-                    "match": "\\bmut\\b"
-                },
-                {
-                    "comment": "logical operators",
-                    "name": "keyword.operator.logical.rust",
-                    "match": "(\\^|\\||\\|\\||&&|<<|>>|!)(?!=)"
-                },
-                {
-                    "comment": "logical AND, borrow references",
-                    "name": "keyword.operator.borrow.and.rust",
-                    "match": "&(?![&=])"
-                },
-                {
-                    "comment": "assignment operators",
-                    "name": "keyword.operator.assignment.rust",
-                    "match": "(\\+=|-=|\\*=|/=|%=|\\^=|&=|\\|=|<<=|>>=)"
-                },
-                {
-                    "comment": "single equal",
-                    "name": "keyword.operator.assignment.equal.rust",
-                    "match": "(?<![<>])=(?!=|>)"
-                },
-                {
-                    "comment": "comparison operators",
-                    "name": "keyword.operator.comparison.rust",
-                    "match": "(=(=)?(?!>)|!=|<=|(?<!=)>=)"
-                },
-                {
-                    "comment": "math operators",
-                    "name": "keyword.operator.math.rust",
-                    "match": "(([+%]|(\\*(?!\\w)))(?!=))|(-(?!>))|(/(?!/))"
-                },
-                {
-                    "comment": "less than, greater than (special case)",
-                    "match": "(?:\\b|(?:(\\))|(\\])|(\\})))[ \\t]+([<>])[ \\t]+(?:\\b|(?:(\\()|(\\[)|(\\{)))",
-                    "captures": {
-                        "1": {
-                            "name": "punctuation.brackets.round.rust"
-                        },
-                        "2": {
-                            "name": "punctuation.brackets.square.rust"
-                        },
-                        "3": {
-                            "name": "punctuation.brackets.curly.rust"
-                        },
-                        "4": {
-                            "name": "keyword.operator.comparison.rust"
-                        },
-                        "5": {
-                            "name": "punctuation.brackets.round.rust"
-                        },
-                        "6": {
-                            "name": "punctuation.brackets.square.rust"
-                        },
-                        "7": {
-                            "name": "punctuation.brackets.curly.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "namespace operator",
-                    "name": "keyword.operator.namespace.rust",
-                    "match": "::"
-                },
-                {
-                    "comment": "dereference asterisk",
-                    "match": "(\\*)(?=\\w+)",
-                    "captures": {
-                        "1": {
-                            "name": "keyword.operator.dereference.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "subpattern binding",
-                    "name": "keyword.operator.subpattern.rust",
-                    "match": "@"
-                },
-                {
-                    "comment": "dot access",
-                    "name": "keyword.operator.access.dot.rust",
-                    "match": "\\.(?!\\.)"
-                },
-                {
-                    "comment": "ranges, range patterns",
-                    "name": "keyword.operator.range.rust",
-                    "match": "\\.{2}(=|\\.)?"
-                },
-                {
-                    "comment": "colon",
-                    "name": "keyword.operator.key-value.rust",
-                    "match": ":(?!:)"
-                },
-                {
-                    "comment": "dashrocket, skinny arrow",
-                    "name": "keyword.operator.arrow.skinny.rust",
-                    "match": "->"
-                },
-                {
-                    "comment": "hashrocket, fat arrow",
-                    "name": "keyword.operator.arrow.fat.rust",
-                    "match": "=>"
-                },
-                {
-                    "comment": "dollar macros",
-                    "name": "keyword.operator.macro.dollar.rust",
-                    "match": "\\$"
-                },
-                {
-                    "comment": "question mark operator, questionably sized, macro kleene matcher",
-                    "name": "keyword.operator.question.rust",
-                    "match": "\\?"
-                }
-            ]
-        },
-        "interpolations": {
-            "comment": "curly brace interpolations",
-            "name": "meta.interpolation.rust",
-            "match": "({)[^\"{}]*(})",
-            "captures": {
-                "1": {
-                    "name": "punctuation.definition.interpolation.rust"
-                },
-                "2": {
-                    "name": "punctuation.definition.interpolation.rust"
-                }
-            }
-        },
-        "lifetimes": {
-            "patterns": [
-                {
-                    "comment": "named lifetime parameters",
-                    "match": "(['])([a-zA-Z_][0-9a-zA-Z_]*)(?!['])\\b",
-                    "captures": {
-                        "1": {
-                            "name": "punctuation.definition.lifetime.rust"
-                        },
-                        "2": {
-                            "name": "entity.name.type.lifetime.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "borrowing references to named lifetimes",
-                    "match": "(\\&)(['])([a-zA-Z_][0-9a-zA-Z_]*)(?!['])\\b",
-                    "captures": {
-                        "1": {
-                            "name": "keyword.operator.borrow.rust"
-                        },
-                        "2": {
-                            "name": "punctuation.definition.lifetime.rust"
-                        },
-                        "3": {
-                            "name": "entity.name.type.lifetime.rust"
-                        }
-                    }
-                }
-            ]
-        },
-        "macros": {
-            "patterns": [
-                {
-                    "comment": "macros",
-                    "name": "meta.macro.rust",
-                    "match": "(([a-z_][A-Za-z0-9_]*!)|([A-Z_][A-Za-z0-9_]*!))",
-                    "captures": {
-                        "2": {
-                            "name": "entity.name.function.macro.rust"
-                        },
-                        "3": {
-                            "name": "entity.name.type.macro.rust"
-                        }
-                    }
-                }
-            ]
-        },
-        "namespaces": {
-            "patterns": [
-                {
-                    "comment": "namespace (non-type, non-function path segment)",
-                    "match": "(?<![A-Za-z0-9_])([a-z0-9_]+)((?<!super|self)::)",
-                    "captures": {
-                        "1": {
-                            "name": "entity.name.namespace.rust"
-                        },
-                        "2": {
-                            "name": "keyword.operator.namespace.rust"
-                        }
-                    }
-                }
-            ]
-        },
-        "types": {
-            "patterns": [
-                {
-                    "comment": "numeric types",
-                    "match": "(?<![A-Za-z])(f32|f64|i128|i16|i32|i64|i8|isize|u128|u16|u32|u64|u8|usize)\\b",
-                    "captures": {
-                        "1": {
-                            "name": "entity.name.type.numeric.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "parameterized types",
-                    "begin": "\\b([A-Z][A-Za-z0-9]*)(<)",
-                    "beginCaptures": {
-                        "1": {
-                            "name": "entity.name.type.rust"
-                        },
-                        "2": {
-                            "name": "punctuation.brackets.angle.rust"
-                        }
-                    },
-                    "end": ">",
-                    "endCaptures": {
-                        "0": {
-                            "name": "punctuation.brackets.angle.rust"
-                        }
-                    },
-                    "patterns": [
-                        {
-                            "include": "#block-comments"
-                        },
-                        {
-                            "include": "#comments"
-                        },
-                        {
-                            "include": "#keywords"
-                        },
-                        {
-                            "include": "#lvariables"
-                        },
-                        {
-                            "include": "#lifetimes"
-                        },
-                        {
-                            "include": "#punctuation"
-                        },
-                        {
-                            "include": "#types"
-                        },
-                        {
-                            "include": "#variables"
-                        }
-                    ]
-                },
-                {
-                    "comment": "primitive types",
-                    "name": "entity.name.type.primitive.rust",
-                    "match": "\\b(bool|char|str)\\b"
-                },
-                {
-                    "comment": "trait declarations",
-                    "match": "\\b(trait)\\s+([A-Z][A-Za-z0-9]*)\\b",
-                    "captures": {
-                        "1": {
-                            "name": "storage.type.rust"
-                        },
-                        "2": {
-                            "name": "entity.name.type.trait.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "struct declarations",
-                    "match": "\\b(struct)\\s+([A-Z][A-Za-z0-9]*)\\b",
-                    "captures": {
-                        "1": {
-                            "name": "storage.type.rust"
-                        },
-                        "2": {
-                            "name": "entity.name.type.struct.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "enum declarations",
-                    "match": "\\b(enum)\\s+([A-Z][A-Za-z0-9_]*)\\b",
-                    "captures": {
-                        "1": {
-                            "name": "storage.type.rust"
-                        },
-                        "2": {
-                            "name": "entity.name.type.enum.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "type declarations",
-                    "match": "\\b(type)\\s+([A-Z][A-Za-z0-9_]*)\\b",
-                    "captures": {
-                        "1": {
-                            "name": "storage.type.rust"
-                        },
-                        "2": {
-                            "name": "entity.name.type.declaration.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "types",
-                    "name": "entity.name.type.rust",
-                    "match": "\\b[A-Z][A-Za-z0-9]*\\b(?!!)"
-                }
-            ]
-        },
-        "gtypes": {
-            "patterns": [
-                {
-                    "comment": "option types",
-                    "name": "entity.name.type.option.rust",
-                    "match": "\\b(Some|None)\\b"
-                },
-                {
-                    "comment": "result types",
-                    "name": "entity.name.type.result.rust",
-                    "match": "\\b(Ok|Err)\\b"
-                }
-            ]
-        },
-        "punctuation": {
-            "patterns": [
-                {
-                    "comment": "comma",
-                    "name": "punctuation.comma.rust",
-                    "match": ","
-                },
-                {
-                    "comment": "curly braces",
-                    "name": "punctuation.brackets.curly.rust",
-                    "match": "[{}]"
-                },
-                {
-                    "comment": "parentheses, round brackets",
-                    "name": "punctuation.brackets.round.rust",
-                    "match": "[()]"
-                },
-                {
-                    "comment": "semicolon",
-                    "name": "punctuation.semi.rust",
-                    "match": ";"
-                },
-                {
-                    "comment": "square brackets",
-                    "name": "punctuation.brackets.square.rust",
-                    "match": "[\\[\\]]"
-                },
-                {
-                    "comment": "angle brackets",
-                    "name": "punctuation.brackets.angle.rust",
-                    "match": "(?<!=)[<>]"
-                }
-            ]
-        },
-        "strings": {
-            "patterns": [
-                {
-                    "comment": "double-quoted strings and byte strings",
-                    "name": "string.quoted.double.rust",
-                    "begin": "(b?)(\")",
-                    "beginCaptures": {
-                        "1": {
-                            "name": "string.quoted.byte.raw.rust"
-                        },
-                        "2": {
-                            "name": "punctuation.definition.string.rust"
-                        }
-                    },
-                    "end": "\"",
-                    "endCaptures": {
-                        "0": {
-                            "name": "punctuation.definition.string.rust"
-                        }
-                    },
-                    "patterns": [
-                        {
-                            "include": "#escapes"
-                        },
-                        {
-                            "include": "#interpolations"
-                        }
-                    ]
-                },
-                {
-                    "comment": "double-quoted raw strings and raw byte strings",
-                    "name": "string.quoted.double.rust",
-                    "begin": "(b?r)(#*)(\")",
-                    "beginCaptures": {
-                        "1": {
-                            "name": "string.quoted.byte.raw.rust"
-                        },
-                        "2": {
-                            "name": "punctuation.definition.string.raw.rust"
-                        },
-                        "3": {
-                            "name": "punctuation.definition.string.rust"
-                        }
-                    },
-                    "end": "(\")(\\2)",
-                    "endCaptures": {
-                        "1": {
-                            "name": "punctuation.definition.string.rust"
-                        },
-                        "2": {
-                            "name": "punctuation.definition.string.raw.rust"
-                        }
-                    }
-                },
-                {
-                    "comment": "characters and bytes",
-                    "name": "string.quoted.single.char.rust",
-                    "begin": "(b)?(')",
-                    "beginCaptures": {
-                        "1": {
-                            "name": "string.quoted.byte.raw.rust"
-                        },
-                        "2": {
-                            "name": "punctuation.definition.char.rust"
-                        }
-                    },
-                    "end": "'",
-                    "endCaptures": {
-                        "0": {
-                            "name": "punctuation.definition.char.rust"
-                        }
-                    },
-                    "patterns": [
-                        {
-                            "include": "#escapes"
-                        }
-                    ]
-                }
-            ]
-        },
-        "lvariables": {
-            "patterns": [
-                {
-                    "comment": "self",
-                    "name": "variable.language.self.rust",
-                    "match": "\\b[Ss]elf\\b"
-                },
-                {
-                    "comment": "super",
-                    "name": "variable.language.super.rust",
-                    "match": "\\bsuper\\b"
-                }
-            ]
-        },
-        "variables": {
-            "patterns": [
-                {
-                    "comment": "variables",
-                    "name": "variable.other.rust",
-                    "match": "\\b(?<!(?<!\\.)\\.)(?:r#(?!(crate|[Ss]elf|super)))?[a-z0-9_]+\\b"
-                }
-            ]
-        }
-    }
-}
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 92bc4d7f7..9d4823a34 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -470,7 +470,7 @@ export function resolveCodeAction(ctx: Ctx): Cmd {
            return;
        }
        const edit = client.protocol2CodeConverter.asWorkspaceEdit(item.edit);
-        await applySnippetWorkspaceEdit(edit);
+        await vscode.workspace.applyEdit(edit);
    };
 }
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 191960960..282240d84 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -19,9 +19,8 @@ let ctx: Ctx | undefined;
 const RUST_PROJECT_CONTEXT_NAME = "inRustProject";
 export async function activate(context: vscode.ExtensionContext) {
-    // For some reason vscode not always shows pop-up error notifications
+    // VS Code doesn't show a notification when an extension fails to activate
-    // when an extension fails to activate, so we do it explicitly by ourselves.
+    // so we do it ourselves.
-    // FIXME: remove this bit of code once vscode fixes this issue: https://github.com/microsoft/vscode/issues/101242
    await tryActivate(context).catch(err => {
        void vscode.window.showErrorMessage(`Cannot activate rust-analyzer: ${err.message}`);
        throw err;
@@ -132,7 +131,7 @@ async function tryActivate(context: vscode.ExtensionContext) {
    ctx.pushCleanup(activateTaskProvider(workspaceFolder, ctx.config));
    activateInlayHints(ctx);
-    warnAboutRustLangExtensionConflict();
+    warnAboutExtensionConflicts();
    vscode.workspace.onDidChangeConfiguration(
        _ => ctx?.client?.sendNotification('workspace/didChangeConfiguration', { settings: "" }),
@@ -288,10 +287,14 @@ async function getServer(config: Config, state: PersistentState): Promise<string
    if (config.package.releaseTag === null) return "rust-analyzer";
    let platform: string | undefined;
-    if (process.arch === "x64" || process.arch === "ia32") {
+    if ((process.arch === "x64" || process.arch === "ia32") && process.platform === "win32") {
-        if (process.platform === "linux") platform = "linux";
+        platform = "x86_64-pc-windows-msvc";
-        if (process.platform === "darwin") platform = "mac";
+    } else if (process.arch === "x64" && process.platform === "linux") {
-        if (process.platform === "win32") platform = "windows";
+        platform = "x86_64-unknown-linux-gnu";
+    } else if (process.arch === "x64" && process.platform === "darwin") {
+        platform = "x86_64-apple-darwin";
+    } else if (process.arch === "arm64" && process.platform === "darwin") {
+        platform = "aarch64-apple-darwin";
    }
    if (platform === undefined) {
        vscode.window.showErrorMessage(
@@ -304,7 +307,7 @@ async function getServer(config: Config, state: PersistentState): Promise<string
        );
        return undefined;
    }
-    const ext = platform === "windows" ? ".exe" : "";
+    const ext = platform.indexOf("-windows-") !== -1 ? ".exe" : "";
    const dest = path.join(config.globalStoragePath, `rust-analyzer-${platform}${ext}`);
    const exists = await fs.stat(dest).then(() => true, () => false);
    if (!exists) {
@@ -340,7 +343,7 @@ async function getServer(config: Config, state: PersistentState): Promise<string
    });
    // Patching executable if that's NixOS.
-    if (await fs.stat("/etc/nixos").then(_ => true).catch(_ => false)) {
+    if (await isNixOs()) {
        await patchelf(dest);
    }
@@ -348,6 +351,15 @@ async function getServer(config: Config, state: PersistentState): Promise<string
    return dest;
 }
+async function isNixOs(): Promise<boolean> {
+    try {
+        const contents = await fs.readFile("/etc/os-release");
+        return contents.indexOf("ID=nixos") !== -1;
+    } catch (e) {
+        return false;
+    }
+}
 async function downloadWithRetryDialog<T>(state: PersistentState, downloadFunc: () => Promise<T>): Promise<T> {
    while (true) {
        try {
@@ -401,11 +413,21 @@ async function queryForGithubToken(state: PersistentState): Promise<void> {
    }
 }
-function warnAboutRustLangExtensionConflict() {
+function warnAboutExtensionConflicts() {
-    const rustLangExt = vscode.extensions.getExtension("rust-lang.rust");
+    const conflicting = [
-    if (rustLangExt !== undefined) {
+        ["rust-analyzer", "matklad.rust-analyzer"],
+        ["Rust", "rust-lang.rust"],
+        ["Rust", "kalitaalexey.vscode-rust"],
+    ];
+    const found = conflicting.filter(
+        nameId => vscode.extensions.getExtension(nameId[1]) !== undefined);
+    if (found.length > 1) {
+        const fst = found[0];
+        const sec = found[1];
        vscode.window.showWarningMessage(
-            "You have both rust-analyzer (matklad.rust-analyzer) and Rust (rust-lang.rust) " +
+            `You have both the ${fst[0]} (${fst[1]}) and ${sec[0]} (${sec[1]}) ` +
            "plugins enabled. These are known to conflict and cause various functions of " +
            "both plugins to not work correctly. You should disable one of them.", "Got it");
    };
diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index 9e15a5a4c..d07ad9420 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -58,30 +58,74 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
 }
 fn dist_server() -> Result<()> {
-    if cfg!(target_os = "linux") {
+    let target = get_target();
+    if target.contains("-linux-gnu") {
        env::set_var("CC", "clang");
    }
-    cmd!("cargo build --manifest-path ./crates/rust-analyzer/Cargo.toml --bin rust-analyzer --release").run()?;
-    let (src, dst) = if cfg!(target_os = "linux") {
-        ("./target/release/rust-analyzer", "./dist/rust-analyzer-linux")
-    } else if cfg!(target_os = "windows") {
-        ("./target/release/rust-analyzer.exe", "./dist/rust-analyzer-windows.exe")
-    } else if cfg!(target_os = "macos") {
-        ("./target/release/rust-analyzer", "./dist/rust-analyzer-mac")
-    } else {
-        panic!("Unsupported OS")
-    };
-    let src = Path::new(src);
+    let toolchain = toolchain(&target);
-    let dst = Path::new(dst);
+    cmd!("cargo +{toolchain} build --manifest-path ./crates/rust-analyzer/Cargo.toml --bin rust-analyzer --target {target} --release").run()?;
+    let suffix = exe_suffix(&target);
+    let src =
+        Path::new("target").join(&target).join("release").join(format!("rust-analyzer{}", suffix));
+    let dst = Path::new("dist").join(format!("rust-analyzer-{}{}", target, suffix));
    cp(&src, &dst)?;
    gzip(&src, &dst.with_extension("gz"))?;
+    // FIXME: the old names are temporarily kept for client compatibility, but they should be removed
+    // Remove this block after a couple of releases
+    match target.as_ref() {
+        "x86_64-unknown-linux-gnu" => {
+            cp(&src, "dist/rust-analyzer-linux")?;
+            gzip(&src, Path::new("dist/rust-analyzer-linux.gz"))?;
+        }
+        "x86_64-pc-windows-msvc" => {
+            cp(&src, "dist/rust-analyzer-windows.exe")?;
+            gzip(&src, Path::new("dist/rust-analyzer-windows.gz"))?;
+        }
+        "x86_64-apple-darwin" => {
+            cp(&src, "dist/rust-analyzer-mac")?;
+            gzip(&src, Path::new("dist/rust-analyzer-mac.gz"))?;
+        }
+        _ => {}
+    }
    Ok(())
 }
+fn get_target() -> String {
+    match env::var("RA_TARGET") {
+        Ok(target) => target,
+        _ => {
+            if cfg!(target_os = "linux") {
+                "x86_64-unknown-linux-gnu".to_string()
+            } else if cfg!(target_os = "windows") {
+                "x86_64-pc-windows-msvc".to_string()
+            } else if cfg!(target_os = "macos") {
+                "x86_64-apple-darwin".to_string()
+            } else {
+                panic!("Unsupported OS, maybe try setting RA_TARGET")
+            }
+        }
+    }
+}
+fn exe_suffix(target: &str) -> String {
+    if target.contains("-windows-") {
+        ".exe".into()
+    } else {
+        "".into()
+    }
+}
+fn toolchain(target: &str) -> String {
+    match target {
+        "aarch64-apple-darwin" => "beta".to_string(),
+        _ => "stable".to_string(),
+    }
+}
 fn gzip(src_path: &Path, dest_path: &Path) -> Result<()> {
    let mut encoder = GzEncoder::new(File::create(dest_path)?, Compression::best());
    let mut input = io::BufReader::new(File::open(src_path)?);