9 files changed, 191 insertions, 130 deletions

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index fd22ea88a..ece1fd364 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -146,7 +146,7 @@ jobs:
 
   dist-aarch64-apple-darwin:
     name: dist (aarch64-apple-darwin)
-    runs-on: macos-11.0
+    runs-on: macos-latest
     env:
       RA_TARGET: aarch64-apple-darwin
 
@@ -163,7 +163,7 @@ jobs:
         override: true
 
     - name: Dist
-      run: cargo xtask dist
+      run: SDKROOT=$(xcrun -sdk macosx11.0 --show-sdk-path) MACOSX_DEPLOYMENT_TARGET=$(xcrun -sdk macosx11.0 --show-sdk-platform-version) cargo xtask dist
 
     - name: Upload artifacts
       uses: actions/upload-artifact@v1
diff --git a/Cargo.lock b/Cargo.lock
index c625564dc..f87c590a4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -132,7 +132,7 @@ version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d5a5f7b42f606b7f23674f6f4d877628350682bc40687d3fae65679a58d55345"
 dependencies = [
- "semver 0.11.0",
+ "semver",
  "serde",
  "serde_json",
 ]
@@ -488,19 +488,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
 
 [[package]]
-name = "generator"
-version = "0.6.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cdc09201b2e8ca1b19290cf7e65de2246b8e91fb6874279722189c4de7b94dc"
-dependencies = [
- "cc",
- "libc",
- "log",
- "rustc_version",
- "winapi 0.3.9",
-]
-
-[[package]]
 name = "gimli"
 version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -834,19 +821,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "loom"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0e8460f2f2121162705187214720353c517b97bdfb3494c0b1e33d83ebe4bed"
-dependencies = [
- "cfg-if 0.1.10",
- "generator",
- "scoped-tls",
- "serde",
- "serde_json",
-]
-
-[[package]]
 name = "lsp-server"
 version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1414,15 +1388,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
-name = "rustc_version"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-dependencies = [
- "semver 0.9.0",
-]
-
-[[package]]
 name = "ryu"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1480,31 +1445,16 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "semver"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-dependencies = [
- "semver-parser 0.7.0",
-]
-
-[[package]]
-name = "semver"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
 dependencies = [
- "semver-parser 0.10.1",
+ "semver-parser",
  "serde",
 ]
 
 [[package]]
 name = "semver-parser"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-
-[[package]]
-name = "semver-parser"
 version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42ef146c2ad5e5f4b037cd6ce2ebb775401729b19a82040c1beac9d36c7d1428"
@@ -1566,12 +1516,11 @@ dependencies = [
 
 [[package]]
 name = "sharded-slab"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4921be914e16899a80adefb821f8ddb7974e3f1250223575a44ed994882127"
+checksum = "79c719719ee05df97490f80a45acfc99e5a30ce98a1e4fb67aee422745ae14e3"
 dependencies = [
  "lazy_static",
- "loom",
 ]
 
 [[package]]
@@ -1826,15 +1775,16 @@ dependencies = [
 
 [[package]]
 name = "tracing-tree"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43aac8afb493b08e1e1904956f7407c1e671b9c83b26a17e1bd83d6a3520e350"
+checksum = "023e80cdb7c8468b7aade1d756afa2acbe2ae0a6142a25ec664b5239d6ef2794"
 dependencies = [
  "ansi_term",
  "atty",
  "chrono",
  "termcolor",
  "tracing",
+ "tracing-log",
  "tracing-subscriber",
 ]
 
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 071e553a8..1a4aa78fb 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -743,6 +743,18 @@ impl Function {
         db.function_data(self.id).name.clone()
     }
 
+    /// Get this function's return type
+    pub fn ret_type(self, db: &dyn HirDatabase) -> Type {
+        let resolver = self.id.resolver(db.upcast());
+        let ret_type = &db.function_data(self.id).ret_type;
+        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
+        let environment = TraitEnvironment::lower(db, &resolver);
+        Type {
+            krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate,
+            ty: InEnvironment { value: Ty::from_hir_ext(&ctx, ret_type).0, environment },
+        }
+    }
+
     pub fn self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {
         if !db.function_data(self.id).has_self_param {
             return None;
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 6b79e7bad..9e6426b31 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -2,6 +2,7 @@
 
 use std::{ops, sync::Arc};
 
+use arena::map::ArenaMap;
 use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
@@ -21,7 +22,8 @@ use crate::{
     nameres::ModuleSource,
     path::{ModPath, PathKind},
     src::HasChildSource,
-    AdtId, AttrDefId, GenericParamId, Lookup,
+    AdtId, AttrDefId, EnumId, GenericParamId, HasModule, LocalEnumVariantId, LocalFieldId, Lookup,
+    VariantId,
 };
 
 /// Holds documentation
@@ -210,16 +212,10 @@ impl Attrs {
                 }
             }
             AttrDefId::FieldId(it) => {
-                let src = it.parent.child_source(db);
-                match &src.value[it.local_id] {
-                    Either::Left(_tuple) => RawAttrs::default(),
-                    Either::Right(record) => RawAttrs::from_attrs_owner(db, src.with_value(record)),
-                }
+                return db.fields_attrs(it.parent)[it.local_id].clone();
             }
-            AttrDefId::EnumVariantId(var_id) => {
-                let src = var_id.parent.child_source(db);
-                let src = src.as_ref().map(|it| &it[var_id.local_id]);
-                RawAttrs::from_attrs_owner(db, src.map(|it| it as &dyn AttrsOwner))
+            AttrDefId::EnumVariantId(it) => {
+                return db.variants_attrs(it.parent)[it.local_id].clone();
             }
             AttrDefId::AdtId(it) => match it {
                 AdtId::StructId(it) => attrs_from_item_tree(it.lookup(db).id, db),
@@ -259,6 +255,46 @@ impl Attrs {
         raw_attrs.filter(db, def.krate(db))
     }
 
+    pub(crate) fn variants_attrs_query(
+        db: &dyn DefDatabase,
+        e: EnumId,
+    ) -> Arc<ArenaMap<LocalEnumVariantId, Attrs>> {
+        let krate = e.lookup(db).container.module(db).krate;
+        let src = e.child_source(db);
+        let mut res = ArenaMap::default();
+
+        for (id, var) in src.value.iter() {
+            let attrs = RawAttrs::from_attrs_owner(db, src.with_value(var as &dyn AttrsOwner))
+                .filter(db, krate);
+
+            res.insert(id, attrs)
+        }
+
+        Arc::new(res)
+    }
+
+    pub(crate) fn fields_attrs_query(
+        db: &dyn DefDatabase,
+        v: VariantId,
+    ) -> Arc<ArenaMap<LocalFieldId, Attrs>> {
+        let krate = v.module(db).krate;
+        let src = v.child_source(db);
+        let mut res = ArenaMap::default();
+
+        for (id, fld) in src.value.iter() {
+            let attrs = match fld {
+                Either::Left(_tuple) => Attrs::default(),
+                Either::Right(record) => {
+                    RawAttrs::from_attrs_owner(db, src.with_value(record)).filter(db, krate)
+                }
+            };
+
+            res.insert(id, attrs);
+        }
+
+        Arc::new(res)
+    }
+
     pub fn by_key(&self, key: &'static str) -> AttrQuery<'_> {
         AttrQuery { attrs: self, key }
     }
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index d1a459066..d3bf5b34c 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -1,6 +1,7 @@
 //! Defines database & queries for name resolution.
 use std::sync::Arc;
 
+use arena::map::ArenaMap;
 use base_db::{salsa, CrateId, SourceDatabase, Upcast};
 use hir_expand::{db::AstDatabase, HirFileId};
 use syntax::SmolStr;
@@ -16,8 +17,8 @@ use crate::{
     lang_item::{LangItemTarget, LangItems},
     nameres::CrateDefMap,
     AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
-    GenericDefId, ImplId, ImplLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc,
-    TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
+    GenericDefId, ImplId, ImplLoc, LocalEnumVariantId, LocalFieldId, StaticId, StaticLoc, StructId,
+    StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, VariantId,
 };
 
 #[salsa::query_group(InternDatabaseStorage)]
@@ -92,6 +93,12 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     #[salsa::invoke(GenericParams::generic_params_query)]
     fn generic_params(&self, def: GenericDefId) -> Arc<GenericParams>;
 
+    #[salsa::invoke(Attrs::variants_attrs_query)]
+    fn variants_attrs(&self, def: EnumId) -> Arc<ArenaMap<LocalEnumVariantId, Attrs>>;
+
+    #[salsa::invoke(Attrs::fields_attrs_query)]
+    fn fields_attrs(&self, def: VariantId) -> Arc<ArenaMap<LocalFieldId, Attrs>>;
+
     #[salsa::invoke(Attrs::attrs_query)]
     fn attrs(&self, def: AttrDefId) -> Attrs;
 
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 685a9fdf0..a5b1d90b1 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -777,9 +777,8 @@ fn manual(fields: &[(&'static str, &'static str, &[&str], &str)]) -> String {
     fields
         .iter()
         .map(|(field, _ty, doc, default)| {
-            let name = field.replace("_", ".");
-            let name = format!("rust-analyzer.{} (default: `{}`)", name, default);
-            format!("{}::\n{}\n", name, doc.join(" "))
+            let name = format!("rust-analyzer.{}", field.replace("_", "."));
+            format!("[[{}]]{} (default: `{}`)::\n{}\n", name, name, default, doc.join(" "))
         })
         .collect::<String>()
 }
diff --git a/crates/ssr/src/parsing.rs b/crates/ssr/src/parsing.rs
index 289affe90..3d5e4feb7 100644
--- a/crates/ssr/src/parsing.rs
+++ b/crates/ssr/src/parsing.rs
@@ -73,12 +73,18 @@ impl ParsedRule {
             placeholders_by_stand_in: pattern.placeholders_by_stand_in(),
             rules: Vec::new(),
         };
-        builder.try_add(ast::Expr::parse(&raw_pattern), raw_template.map(ast::Expr::parse));
+
+        let raw_template_stmt = raw_template.map(ast::Stmt::parse);
+        if let raw_template_expr @ Some(Ok(_)) = raw_template.map(ast::Expr::parse) {
+            builder.try_add(ast::Expr::parse(&raw_pattern), raw_template_expr);
+        } else {
+            builder.try_add(ast::Expr::parse(&raw_pattern), raw_template_stmt.clone());
+        }
         builder.try_add(ast::Type::parse(&raw_pattern), raw_template.map(ast::Type::parse));
         builder.try_add(ast::Item::parse(&raw_pattern), raw_template.map(ast::Item::parse));
         builder.try_add(ast::Path::parse(&raw_pattern), raw_template.map(ast::Path::parse));
         builder.try_add(ast::Pat::parse(&raw_pattern), raw_template.map(ast::Pat::parse));
-        builder.try_add(ast::Stmt::parse(&raw_pattern), raw_template.map(ast::Stmt::parse));
+        builder.try_add(ast::Stmt::parse(&raw_pattern), raw_template_stmt);
         builder.build()
     }
 }
@@ -89,7 +95,11 @@ struct RuleBuilder {
 }
 
 impl RuleBuilder {
-    fn try_add<T: AstNode>(&mut self, pattern: Result<T, ()>, template: Option<Result<T, ()>>) {
+    fn try_add<T: AstNode, T2: AstNode>(
+        &mut self,
+        pattern: Result<T, ()>,
+        template: Option<Result<T2, ()>>,
+    ) {
         match (pattern, template) {
             (Ok(pattern), Some(Ok(template))) => self.rules.push(ParsedRule {
                 placeholders_by_stand_in: self.placeholders_by_stand_in.clone(),
diff --git a/crates/ssr/src/tests.rs b/crates/ssr/src/tests.rs
index c4149a849..db9cb8ca1 100644
--- a/crates/ssr/src/tests.rs
+++ b/crates/ssr/src/tests.rs
@@ -204,6 +204,53 @@ fn ssr_let_stmt_replace_expr() {
 }
 
 #[test]
+fn ssr_blockexpr_replace_stmt_with_stmt() {
+    assert_ssr_transform(
+        "if $a() {$b;} ==>> $b;",
+        "{
+    if foo() {
+        bar();
+    }
+    Ok(())
+}",
+        expect![[r#"{
+    bar();
+    Ok(())
+}"#]],
+    );
+}
+
+#[test]
+fn ssr_blockexpr_match_trailing_expr() {
+    assert_matches(
+        "if $a() {$b;}",
+        "{
+    if foo() {
+        bar();
+    }
+}",
+        &["if foo() {
+        bar();
+    }"],
+    );
+}
+
+#[test]
+fn ssr_blockexpr_replace_trailing_expr_with_stmt() {
+    assert_ssr_transform(
+        "if $a() {$b;} ==>> $b;",
+        "{
+    if foo() {
+        bar();
+    }
+}",
+        expect![["{
+    bar();
+}"]],
+    );
+}
+
+#[test]
 fn ssr_function_to_method() {
     assert_ssr_transform(
         "my_function($a, $b) ==>> ($a).my_method($b)",
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index 3025dc8d6..e109f2b01 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -1,106 +1,106 @@
-rust-analyzer.assist.importMergeBehaviour (default: `"full"`)::
+[[rust-analyzer.assist.importMergeBehaviour]]rust-analyzer.assist.importMergeBehaviour (default: `"full"`)::
  The strategy to use when inserting new imports or merging imports.
-rust-analyzer.assist.importPrefix (default: `"plain"`)::
+[[rust-analyzer.assist.importPrefix]]rust-analyzer.assist.importPrefix (default: `"plain"`)::
  The path structure for newly inserted paths to use.
-rust-analyzer.callInfo.full (default: `true`)::
+[[rust-analyzer.callInfo.full]]rust-analyzer.callInfo.full (default: `true`)::
  Show function name and docs in parameter hints.
-rust-analyzer.cargo.autoreload (default: `true`)::
+[[rust-analyzer.cargo.autoreload]]rust-analyzer.cargo.autoreload (default: `true`)::
  Automatically refresh project info via `cargo metadata` on  `Cargo.toml` changes.
-rust-analyzer.cargo.allFeatures (default: `false`)::
+[[rust-analyzer.cargo.allFeatures]]rust-analyzer.cargo.allFeatures (default: `false`)::
  Activate all available features.
-rust-analyzer.cargo.features (default: `[]`)::
+[[rust-analyzer.cargo.features]]rust-analyzer.cargo.features (default: `[]`)::
  List of features to activate.
-rust-analyzer.cargo.loadOutDirsFromCheck (default: `false`)::
+[[rust-analyzer.cargo.loadOutDirsFromCheck]]rust-analyzer.cargo.loadOutDirsFromCheck (default: `false`)::
  Run `cargo check` on startup to get the correct value for package  OUT_DIRs.
-rust-analyzer.cargo.noDefaultFeatures (default: `false`)::
+[[rust-analyzer.cargo.noDefaultFeatures]]rust-analyzer.cargo.noDefaultFeatures (default: `false`)::
  Do not activate the `default` feature.
-rust-analyzer.cargo.target (default: `null`)::
+[[rust-analyzer.cargo.target]]rust-analyzer.cargo.target (default: `null`)::
  Compilation target (target triple).
-rust-analyzer.cargo.noSysroot (default: `false`)::
+[[rust-analyzer.cargo.noSysroot]]rust-analyzer.cargo.noSysroot (default: `false`)::
  Internal config for debugging, disables loading of sysroot crates.
-rust-analyzer.checkOnSave.enable (default: `true`)::
+[[rust-analyzer.checkOnSave.enable]]rust-analyzer.checkOnSave.enable (default: `true`)::
  Run specified `cargo check` command for diagnostics on save.
-rust-analyzer.checkOnSave.allFeatures (default: `null`)::
+[[rust-analyzer.checkOnSave.allFeatures]]rust-analyzer.checkOnSave.allFeatures (default: `null`)::
  Check with all features (will be passed as `--all-features`).  Defaults to `#rust-analyzer.cargo.allFeatures#`.
-rust-analyzer.checkOnSave.allTargets (default: `true`)::
+[[rust-analyzer.checkOnSave.allTargets]]rust-analyzer.checkOnSave.allTargets (default: `true`)::
  Check all targets and tests (will be passed as `--all-targets`).
-rust-analyzer.checkOnSave.command (default: `"check"`)::
+[[rust-analyzer.checkOnSave.command]]rust-analyzer.checkOnSave.command (default: `"check"`)::
  Cargo command to use for `cargo check`.
-rust-analyzer.checkOnSave.noDefaultFeatures (default: `null`)::
+[[rust-analyzer.checkOnSave.noDefaultFeatures]]rust-analyzer.checkOnSave.noDefaultFeatures (default: `null`)::
  Do not activate the `default` feature.
-rust-analyzer.checkOnSave.target (default: `null`)::
+[[rust-analyzer.checkOnSave.target]]rust-analyzer.checkOnSave.target (default: `null`)::
  Check for a specific target. Defaults to  `#rust-analyzer.cargo.target#`.
-rust-analyzer.checkOnSave.extraArgs (default: `[]`)::
+[[rust-analyzer.checkOnSave.extraArgs]]rust-analyzer.checkOnSave.extraArgs (default: `[]`)::
  Extra arguments for `cargo check`.
-rust-analyzer.checkOnSave.features (default: `null`)::
+[[rust-analyzer.checkOnSave.features]]rust-analyzer.checkOnSave.features (default: `null`)::
  List of features to activate. Defaults to  `#rust-analyzer.cargo.features#`.
-rust-analyzer.checkOnSave.overrideCommand (default: `null`)::
+[[rust-analyzer.checkOnSave.overrideCommand]]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`)::
+[[rust-analyzer.completion.addCallArgumentSnippets]]rust-analyzer.completion.addCallArgumentSnippets (default: `true`)::
  Whether to add argument snippets when completing functions.
-rust-analyzer.completion.addCallParenthesis (default: `true`)::
+[[rust-analyzer.completion.addCallParenthesis]]rust-analyzer.completion.addCallParenthesis (default: `true`)::
  Whether to add parenthesis when completing functions.
-rust-analyzer.completion.postfix.enable (default: `true`)::
+[[rust-analyzer.completion.postfix.enable]]rust-analyzer.completion.postfix.enable (default: `true`)::
  Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
-rust-analyzer.completion.autoimport.enable (default: `true`)::
+[[rust-analyzer.completion.autoimport.enable]]rust-analyzer.completion.autoimport.enable (default: `true`)::
  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`)::
+[[rust-analyzer.diagnostics.enable]]rust-analyzer.diagnostics.enable (default: `true`)::
  Whether to show native rust-analyzer diagnostics.
-rust-analyzer.diagnostics.enableExperimental (default: `true`)::
+[[rust-analyzer.diagnostics.enableExperimental]]rust-analyzer.diagnostics.enableExperimental (default: `true`)::
  Whether to show experimental rust-analyzer diagnostics that might  have more false positives than usual.
-rust-analyzer.diagnostics.disabled (default: `[]`)::
+[[rust-analyzer.diagnostics.disabled]]rust-analyzer.diagnostics.disabled (default: `[]`)::
  List of rust-analyzer diagnostics to disable.
-rust-analyzer.diagnostics.warningsAsHint (default: `[]`)::
+[[rust-analyzer.diagnostics.warningsAsHint]]rust-analyzer.diagnostics.warningsAsHint (default: `[]`)::
  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: `[]`)::
+[[rust-analyzer.diagnostics.warningsAsInfo]]rust-analyzer.diagnostics.warningsAsInfo (default: `[]`)::
  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"`)::
+[[rust-analyzer.files.watcher]]rust-analyzer.files.watcher (default: `"client"`)::
  Controls file watching implementation.
-rust-analyzer.hoverActions.debug (default: `true`)::
+[[rust-analyzer.hoverActions.debug]]rust-analyzer.hoverActions.debug (default: `true`)::
  Whether to show `Debug` action. Only applies when  `#rust-analyzer.hoverActions.enable#` is set.
-rust-analyzer.hoverActions.enable (default: `true`)::
+[[rust-analyzer.hoverActions.enable]]rust-analyzer.hoverActions.enable (default: `true`)::
  Whether to show HoverActions in Rust files.
-rust-analyzer.hoverActions.gotoTypeDef (default: `true`)::
+[[rust-analyzer.hoverActions.gotoTypeDef]]rust-analyzer.hoverActions.gotoTypeDef (default: `true`)::
  Whether to show `Go to Type Definition` action. Only applies when  `#rust-analyzer.hoverActions.enable#` is set.
-rust-analyzer.hoverActions.implementations (default: `true`)::
+[[rust-analyzer.hoverActions.implementations]]rust-analyzer.hoverActions.implementations (default: `true`)::
  Whether to show `Implementations` action. Only applies when  `#rust-analyzer.hoverActions.enable#` is set.
-rust-analyzer.hoverActions.run (default: `true`)::
+[[rust-analyzer.hoverActions.run]]rust-analyzer.hoverActions.run (default: `true`)::
  Whether to show `Run` action. Only applies when  `#rust-analyzer.hoverActions.enable#` is set.
-rust-analyzer.hoverActions.linksInHover (default: `true`)::
+[[rust-analyzer.hoverActions.linksInHover]]rust-analyzer.hoverActions.linksInHover (default: `true`)::
  Use markdown syntax for links in hover.
-rust-analyzer.inlayHints.chainingHints (default: `true`)::
+[[rust-analyzer.inlayHints.chainingHints]]rust-analyzer.inlayHints.chainingHints (default: `true`)::
  Whether to show inlay type hints for method chains.
-rust-analyzer.inlayHints.maxLength (default: `null`)::
+[[rust-analyzer.inlayHints.maxLength]]rust-analyzer.inlayHints.maxLength (default: `null`)::
  Maximum length for inlay hints. Default is unlimited.
-rust-analyzer.inlayHints.parameterHints (default: `true`)::
+[[rust-analyzer.inlayHints.parameterHints]]rust-analyzer.inlayHints.parameterHints (default: `true`)::
  Whether to show function parameter name inlay hints at the call  site.
-rust-analyzer.inlayHints.typeHints (default: `true`)::
+[[rust-analyzer.inlayHints.typeHints]]rust-analyzer.inlayHints.typeHints (default: `true`)::
  Whether to show inlay type hints for variables.
-rust-analyzer.lens.debug (default: `true`)::
+[[rust-analyzer.lens.debug]]rust-analyzer.lens.debug (default: `true`)::
  Whether to show `Debug` lens. Only applies when  `#rust-analyzer.lens.enable#` is set.
-rust-analyzer.lens.enable (default: `true`)::
+[[rust-analyzer.lens.enable]]rust-analyzer.lens.enable (default: `true`)::
  Whether to show CodeLens in Rust files.
-rust-analyzer.lens.implementations (default: `true`)::
+[[rust-analyzer.lens.implementations]]rust-analyzer.lens.implementations (default: `true`)::
  Whether to show `Implementations` lens. Only applies when  `#rust-analyzer.lens.enable#` is set.
-rust-analyzer.lens.run (default: `true`)::
+[[rust-analyzer.lens.run]]rust-analyzer.lens.run (default: `true`)::
  Whether to show `Run` lens. Only applies when  `#rust-analyzer.lens.enable#` is set.
-rust-analyzer.lens.methodReferences (default: `false`)::
+[[rust-analyzer.lens.methodReferences]]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: `[]`)::
+[[rust-analyzer.linkedProjects]]rust-analyzer.linkedProjects (default: `[]`)::
  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`)::
+[[rust-analyzer.lruCapacity]]rust-analyzer.lruCapacity (default: `null`)::
  Number of syntax trees rust-analyzer keeps in memory.  Defaults to 128.
-rust-analyzer.notifications.cargoTomlNotFound (default: `true`)::
+[[rust-analyzer.notifications.cargoTomlNotFound]]rust-analyzer.notifications.cargoTomlNotFound (default: `true`)::
  Whether to show `can't find Cargo.toml` error message.
-rust-analyzer.procMacro.enable (default: `false`)::
+[[rust-analyzer.procMacro.enable]]rust-analyzer.procMacro.enable (default: `false`)::
  Enable Proc macro support, `#rust-analyzer.cargo.loadOutDirsFromCheck#` must be  enabled.
-rust-analyzer.runnables.overrideCargo (default: `null`)::
+[[rust-analyzer.runnables.overrideCargo]]rust-analyzer.runnables.overrideCargo (default: `null`)::
  Command to be executed instead of 'cargo' for runnables.
-rust-analyzer.runnables.cargoExtraArgs (default: `[]`)::
+[[rust-analyzer.runnables.cargoExtraArgs]]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`.
-rust-analyzer.rustcSource (default: `null`)::
+[[rust-analyzer.rustcSource]]rust-analyzer.rustcSource (default: `null`)::
  Path to the rust compiler sources, for usage in rustc_private projects.
-rust-analyzer.rustfmt.extraArgs (default: `[]`)::
+[[rust-analyzer.rustfmt.extraArgs]]rust-analyzer.rustfmt.extraArgs (default: `[]`)::
  Additional arguments to `rustfmt`.
-rust-analyzer.rustfmt.overrideCommand (default: `null`)::
+[[rust-analyzer.rustfmt.overrideCommand]]rust-analyzer.rustfmt.overrideCommand (default: `null`)::
  Advanced option, fully override the command rust-analyzer uses for  formatting.