Repository: rust-lang/rust-analyzer
Pull request #12202 (2022-05-10 12:27:39)

fix: don't panic at fully qualified call syntax in signature help
Closes  #12200 
Regressed from #12082 


Patch:
diff --git a/crates/hir-expand/src/builtin_fn_macro.rs b/crates/hir-expand/src/builtin_fn_macro.rs
index 2be6c78a6e..687c549748 100644
--- a/crates/hir-expand/src/builtin_fn_macro.rs
+++ b/crates/hir-expand/src/builtin_fn_macro.rs
@@ -635,7 +635,7 @@ fn env_expand(
         // unnecessary diagnostics for eg. `CARGO_PKG_NAME`.
         if key == "OUT_DIR" {
             err = Some(ExpandError::Other(
-                r#"`OUT_DIR` not set, enable "build scripts" to fix"#.into(),
+                r#"`OUT_DIR` not set, enable "run build scripts" to fix"#.into(),
             ));
         }
 
diff --git a/crates/ide-diagnostics/src/handlers/macro_error.rs b/crates/ide-diagnostics/src/handlers/macro_error.rs
index 53d0131e02..a5bfb302d5 100644
--- a/crates/ide-diagnostics/src/handlers/macro_error.rs
+++ b/crates/ide-diagnostics/src/handlers/macro_error.rs
@@ -111,7 +111,7 @@ macro_rules! env { () => {} }
 macro_rules! concat { () => {} }
 
   include!(concat!(env!("OUT_DIR"), "/out.rs"));
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: `OUT_DIR` not set, enable "build scripts" to fix
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: `OUT_DIR` not set, enable "run build scripts" to fix
 "#,
         );
     }
@@ -161,7 +161,7 @@ fn main() {
   //^^^^^^^^^^^^^ error: could not convert tokens
 
     env!("OUT_DIR");
-  //^^^^^^^^^^^^^^^ error: `OUT_DIR` not set, enable "build scripts" to fix
+  //^^^^^^^^^^^^^^^ error: `OUT_DIR` not set, enable "run build scripts" to fix
 
     compile_error!("compile_error works");
   //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: compile_error works
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index bd37ab8896..fa36241c8c 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -808,7 +808,6 @@ fn get_string_representation(expr: &ast::Expr) -> Option<String> {
         ast::Expr::PathExpr(path_expr) => Some(path_expr.path()?.segment()?.to_string()),
         ast::Expr::PrefixExpr(prefix_expr) => get_string_representation(&prefix_expr.expr()?),
         ast::Expr::RefExpr(ref_expr) => get_string_representation(&ref_expr.expr()?),
-        ast::Expr::CastExpr(cast_expr) => get_string_representation(&cast_expr.expr()?),
         _ => None,
     }
 }
@@ -1174,7 +1173,6 @@ fn main() {
 
     let param = 0;
     foo(param);
-    foo(param as _);
     let param_end = 0;
     foo(param_end);
     let start_param = 0;
diff --git a/crates/ide/src/signature_help.rs b/crates/ide/src/signature_help.rs
index 57b0305fb3..e603cb4862 100644
--- a/crates/ide/src/signature_help.rs
+++ b/crates/ide/src/signature_help.rs
@@ -129,7 +129,7 @@ fn signature_help_for_call(
         hir::CallableKind::Function(func) => {
             res.doc = func.docs(db).map(|it| it.into());
             format_to!(res.signature, "fn {}", func.name(db));
-            fn_params = Some(match func.self_param(db) {
+            fn_params = Some(match callable.receiver_param(db) {
                 Some(_self) => func.params_without_self(db),
                 None => func.assoc_fn_params(db),
             });
@@ -1142,4 +1142,20 @@ fn f() {
             "#]],
         );
     }
+
+    #[test]
+    fn fully_qualified_syntax() {
+        check(
+            r#"
+fn f() {
+    trait A { fn foo(&self, other: Self); }
+    A::foo(&self$0, other);
+}
+"#,
+            expect![[r#"
+                fn foo(self: &Self, other: Self)
+                       ^^^^^^^^^^^  -----------
+            "#]],
+        );
+    }
 }
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 119b94f060..1ee5fb7901 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -35,15 +35,6 @@ use crate::{
     lsp_ext::{self, supports_utf8, WorkspaceSymbolSearchKind, WorkspaceSymbolSearchScope},
 };
 
-mod patch_old_style;
-
-// Conventions for configuration keys to preserve maximal extendability without breakage:
-//  - Toggles (be it binary true/false or with more options in-between) should almost always suffix as `_enable`
-//    This has the benefit of namespaces being extensible, and if the suffix doesn't fit later it can be changed without breakage.
-//  - In general be wary of using the namespace of something verbatim, it prevents us from adding subkeys in the future
-//  - Don't use abbreviations unless really necessary
-//  - foo_command = overrides the subcommand, foo_overrideCommand allows full overwriting, extra args only applies for foo_command
-
 // Defines the server-side configuration of the rust-analyzer. We generate
 // *parts* of VS Code's `package.json` config from this.
 //
@@ -54,89 +45,85 @@ mod patch_old_style;
 // parsing the old name.
 config_data! {
     struct ConfigData {
-        /// Placeholder expression to use for missing expressions in assists.
-        assist_expressionFillDefault: ExprFillDefaultDef              = "\"todo\"",
+        /// Placeholder for missing expressions in assists.
+        assist_exprFillDefault: ExprFillDefaultDef              = "\"todo\"",
+        /// How imports should be grouped into use statements.
+        assist_importGranularity |
+        assist_importMergeBehavior |
+        assist_importMergeBehaviour: ImportGranularityDef  = "\"crate\"",
+        /// Whether to enforce the import granularity setting for all files. If set to false rust-analyzer will try to keep import styles consistent per file.
+        assist_importEnforceGranularity: bool              = "false",
+        /// The path structure for newly inserted paths to use.
+        assist_importPrefix: ImportPrefixDef               = "\"plain\"",
+        /// Group inserted imports by the https://rust-analyzer.github.io/manual.html#auto-import[following order]. Groups are separated by newlines.
+        assist_importGroup: bool                           = "true",
+        /// Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.
+        assist_allowMergingIntoGlobImports: bool           = "true",
+
+        /// Warm up caches on project load.
+        cache_warmup: bool = "true",
+
+        /// Show function name and docs in parameter hints.
+        callInfo_full: bool                                = "true",
 
         /// Automatically refresh project info via `cargo metadata` on
         /// `Cargo.toml` or `.cargo/config.toml` changes.
         cargo_autoreload: bool           = "true",
+        /// Activate all available features (`--all-features`).
+        cargo_allFeatures: bool          = "false",
+        /// Unsets `#[cfg(test)]` for the specified crates.
+        cargo_unsetTest: Vec<String>   = "[\"core\"]",
+        /// List of features to activate.
+        cargo_features: Vec<String>      = "[]",
         /// Run build scripts (`build.rs`) for more precise code analysis.
-        cargo_buildScripts_enable: bool  = "true",
-        /// Override the command rust-analyzer uses to run build scripts and
-        /// build procedural macros. The command is required to output json
-        /// and should therefor include `--message-format=json` or a similar
-        /// option.
-        ///
-        /// By default, a cargo invocation will be constructed for the configured
-        /// targets and features, with the following base command line:
-        ///
-        /// ```bash
-        /// cargo check --quiet --workspace --message-format=json --all-targets
-        /// ```
-        /// .
-        cargo_buildScripts_overrideCommand: Option<Vec<String>> = "null",
+        cargo_runBuildScripts |
+        cargo_loadOutDirsFromCheck: bool = "true",
+        /// Advanced option, fully override the command rust-analyzer uses to
+        /// run build scripts and build procedural macros. The command should
+        /// include `--message-format=json` or a similar option.
+        cargo_runBuildScriptsCommand: Option<Vec<String>> = "null",
         /// Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to
         /// avoid compiling unnecessary things.
-        cargo_buildScripts_useRustcWrapper: bool = "true",
-        /// List of features to activate.
-        ///
-        /// Set this to `"all"` to pass `--all-features` to cargo.
-        cargo_features: CargoFeatures      = "[]",
-        /// Whether to pass `--no-default-features` to cargo.
+        cargo_useRustcWrapperForBuildScripts: bool = "true",
+        /// Do not activate the `default` feature.
         cargo_noDefaultFeatures: bool    = "false",
+        /// Compilation target (target triple).
+        cargo_target: Option<String>     = "null",
         /// Internal config for debugging, disables loading of sysroot crates.
         cargo_noSysroot: bool            = "false",
-        /// Compilation target override (target triple).
-        cargo_target: Option<String>     = "null",
-        /// Unsets `#[cfg(test)]` for the specified crates.
-        cargo_unsetTest: Vec<String>   = "[\"core\"]",
 
+        /// Run specified `cargo check` command for diagnostics on save.
+        checkOnSave_enable: bool                         = "true",
+        /// Check with all features (`--all-features`).
+        /// Defaults to `#rust-analyzer.cargo.allFeatures#`.
+        checkOnSave_allFeatures: Option<bool>            = "null",
         /// Check all targets and tests (`--all-targets`).
         checkOnSave_allTargets: bool                     = "true",
         /// Cargo command to use for `cargo check`.
         checkOnSave_command: String                      = "\"check\"",
-        /// Run specified `cargo check` command for diagnostics on save.
-        checkOnSave_enable: bool                         = "true",
-        /// Extra arguments for `cargo check`.
-        checkOnSave_extraArgs: Vec<String>               = "[]",
-        /// List of features to activate. Defaults to
-        /// `#rust-analyzer.cargo.features#`.
-        ///
-        /// Set to `"all"` to pass `--all-features` to cargo.
-        checkOnSave_features: Option<CargoFeatures>      = "null",
         /// Do not activate the `default` feature.
         checkOnSave_noDefaultFeatures: Option<bool>      = "null",
-        /// Override the command rust-analyzer uses to  run build scripts and
-        /// build procedural macros. The command is required to output json
-        /// and should therefor include `--message-format=json` or a similar
-        /// option.
-        ///
-        /// An example command would be:
-        ///
-        /// ```bash
-        /// cargo check --workspace --message-format=json --all-targets
-        /// ```
-        /// .
-        checkOnSave_overrideCommand: Option<Vec<String>> = "null",
         /// Check for a specific target. Defaults to
         /// `#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#`.
+        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
+        /// similar option.
+        checkOnSave_overrideCommand: Option<Vec<String>> = "null",
 
-        /// 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.
-        completion_autoimport_enable: bool       = "true",
-        /// Toggles the additional completions that automatically show method calls and field accesses
-        /// with `self` prefixed to them when inside a method.
-        completion_autoself_enable: bool        = "true",
-        /// Whether to add parenthesis and argument snippets when completing function.
-        completion_callable_snippets: Option<CallableCompletionDef>  = "\"fill_arguments\"",
-        /// Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
-        completion_postfix_enable: bool         = "true",
-        /// Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.
-        completion_privateEditable_enable: bool = "false",
+        /// Whether to add argument snippets when completing functions.
+        /// Only applies when `#rust-analyzer.completion.addCallParenthesis#` is set.
+        completion_addCallArgumentSnippets: bool = "true",
+        /// Whether to add parenthesis when completing functions.
+        completion_addCallParenthesis: bool      = "true",
         /// Custom completion snippets.
         // NOTE: Keep this list in sync with the feature docs of user snippets.
-        completion_snippets_custom: FxHashMap<String, SnippetDef> = r#"{
+        completion_snippets: FxHashMap<String, SnippetDef> = r#"{
             "Arc::new": {
                 "postfix": "arc",
                 "body": "Arc::new(${receiver})",
@@ -177,14 +164,24 @@ config_data! {
                 "scope": "expr"
             }
         }"#,
+        /// 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 must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
+        completion_autoimport_enable: bool       = "true",
+        /// Toggles the additional completions that automatically show method calls and field accesses
+        /// with `self` prefixed to them when inside a method.
+        completion_autoself_enable: bool        = "true",
+        /// Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.
+        completion_privateEditable_enable: bool = "false",
 
-        /// List of rust-analyzer diagnostics to disable.
-        diagnostics_disabled: FxHashSet<String> = "[]",
         /// Whether to show native rust-analyzer diagnostics.
         diagnostics_enable: bool                = "true",
         /// Whether to show experimental rust-analyzer diagnostics that might
         /// have more false positives than usual.
-        diagnostics_experimental_enable: bool    = "false",
+        diagnostics_enableExperimental: bool    = "false",
+        /// List of rust-analyzer diagnostics to disable.
+        diagnostics_disabled: FxHashSet<String> = "[]",
         /// Map of prefixes to be substituted when parsing diagnostic file paths.
         /// This should be the reverse mapping of what is passed to `rustc` as `--remap-path-prefix`.
         diagnostics_remapPrefix: FxHashMap<String, String> = "{}",
@@ -199,113 +196,110 @@ config_data! {
         /// and a blue icon in the `Problems Panel`.
         diagnostics_warningsAsInfo: Vec<String> = "[]",
 
+        /// Expand attribute macros.
+        experimental_procAttrMacros: bool = "true",
+
+        /// Controls file watching implementation.
+        files_watcher: String = "\"client\"",
         /// These directories will be ignored by rust-analyzer. They are
         /// relative to the workspace root, and globs are not supported. You may
         /// also need to add the folders to Code's `files.watcherExclude`.
         files_excludeDirs: Vec<PathBuf> = "[]",
-        /// Controls file watching implementation.
-        files_watcher: String = "\"client\"",
 
-        /// Enables highlighting of related references while the cursor is on `break`, `loop`, `while`, or `for` keywords.
-        highlightRelated_breakPoints_enable: bool = "true",
-        /// Enables highlighting of all exit points while the cursor is on any `return`, `?`, `fn`, or return type arrow (`->`).
-        highlightRelated_exitPoints_enable: bool = "true",
-        /// Enables highlighting of related references while the cursor is on any identifier.
-        highlightRelated_references_enable: bool = "true",
-        /// Enables highlighting of all break points for a loop or block context while the cursor is on any `async` or `await` keywords.
-        highlightRelated_yieldPoints_enable: bool = "true",
+        /// Enables highlighting of related references while hovering your mouse above any identifier.
+        highlightRelated_references: bool = "true",
+        /// Enables highlighting of all exit points while hovering your mouse above any `return`, `?`, or return type arrow (`->`).
+        highlightRelated_exitPoints: bool = "true",
+        /// Enables highlighting of related references while hovering your mouse `break`, `loop`, `while`, or `for` keywords.
+        highlightRelated_breakPoints: bool = "true",
+        /// Enables highlighting of all break points for a loop or block context while hovering your mouse above any `async` or `await` keywords.
+        highlightRelated_yieldPoints: bool = "true",
+
+        /// Use semantic tokens for strings.
+        ///
+        /// In some editors (e.g. vscode) semantic tokens override other highlighting grammars.
+        /// By disabling semantic tokens for strings, other grammars can be used to highlight
+        /// their contents.
+        highlighting_strings: bool = "true",
+
+        /// Whether to show documentation on hover.
+        hover_documentation: bool       = "true",
+        /// Use markdown syntax for links in hover.
+        hover_linksInHover |
+        hoverActions_linksInHover: bool = "true",
 
         /// Whether to show `Debug` action. Only applies when
         /// `#rust-analyzer.hoverActions.enable#` is set.
-        hover_actions_debug_enable: bool           = "true",
+        hoverActions_debug: bool           = "true",
         /// Whether to show HoverActions in Rust files.
-        hover_actions_enable: bool          = "true",
+        hoverActions_enable: bool          = "true",
         /// Whether to show `Go to Type Definition` action. Only applies when
         /// `#rust-analyzer.hoverActions.enable#` is set.
-        hover_actions_gotoTypeDef_enable: bool     = "true",
+        hoverActions_gotoTypeDef: bool     = "true",
         /// Whether to show `Implementations` action. Only applies when
         /// `#rust-analyzer.hoverActions.enable#` is set.
-        hover_actions_implementations_enable: bool = "true",
+        hoverActions_implementations: bool = "true",
         /// Whether to show `References` action. Only applies when
         /// `#rust-analyzer.hoverActions.enable#` is set.
-        hover_actions_references_enable: bool      = "false",
+        hoverActions_references: bool      = "false",
         /// Whether to show `Run` action. Only applies when
         /// `#rust-analyzer.hoverActions.enable#` is set.
-        hover_actions_run_enable: bool             = "true",
-
-        /// Whether to show documentation on hover.
-        hover_documentation_enable: bool       = "true",
-        /// Use markdown syntax for links in hover.
-        hover_links_enable: bool = "true",
-
-        /// Whether to enforce the import granularity setting for all files. If set to false rust-analyzer will try to keep import styles consistent per file.
-        imports_granularity_enforce: bool              = "false",
-        /// How imports should be grouped into use statements.
-        imports_granularity_group: ImportGranularityDef  = "\"crate\"",
-        /// Group inserted imports by the https://rust-analyzer.github.io/manual.html#auto-import[following order]. Groups are separated by newlines.
-        imports_group_enable: bool                           = "true",
-        /// Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.
-        imports_merge_glob: bool           = "true",
-        /// The path structure for newly inserted paths to use.
-        imports_prefix: ImportPrefixDef               = "\"plain\"",
+        hoverActions_run: bool             = "true",
 
+        /// Whether to render trailing colons for parameter hints, and trailing colons for parameter hints.
+        inlayHints_renderColons: bool                      = "true",
+        /// Maximum length for inlay hints. Set to null to have an unlimited length.
+        inlayHints_maxLength: Option<usize>                = "25",
+        /// Whether to show function parameter name inlay hints at the call
+        /// site.
+        inlayHints_parameterHints: bool                     = "true",
+        /// Whether to show inlay type hints for variables.
+        inlayHints_typeHints: bool                          = "true",
         /// Whether to show inlay type hints for method chains.
-        inlayHints_chainingHints_enable: bool                      = "true",
+        inlayHints_chainingHints: bool                      = "true",
         /// Whether to show inlay type hints for return types of closures with blocks.
-        inlayHints_closureReturnTypeHints_enable: bool             = "false",
+        inlayHints_closureReturnTypeHints: bool             = "false",
+        /// Whether to show inlay type hints for compiler inserted reborrows.
+        inlayHints_reborrowHints: bool                      = "false",
         /// Whether to show inlay type hints for elided lifetimes in function signatures.
         inlayHints_lifetimeElisionHints_enable: LifetimeElisionDef = "\"never\"",
         /// Whether to prefer using parameter names as the name for elided lifetime hints if possible.
-        inlayHints_lifetimeElisionHints_useParameterNames: bool    = "false",
-        /// Maximum length for inlay hints. Set to null to have an unlimited length.
-        inlayHints_maxLength: Option<usize>                        = "25",
-        /// Whether to show function parameter name inlay hints at the call
-        /// site.
-        inlayHints_parameterHints_enable: bool                     = "true",
-        /// Whether to show inlay type hints for compiler inserted reborrows.
-        inlayHints_reborrowHints_enable: bool                      = "false",
-        /// Whether to render trailing colons for parameter hints, and trailing colons for parameter hints.
-        inlayHints_renderColons: bool                              = "true",
-        /// Whether to show inlay type hints for variables.
-        inlayHints_typeHints_enable: bool                          = "true",
-        /// Whether to hide inlay type hints for constructors.
-        inlayHints_typeHints_hideNamedConstructor: bool            = "false",
+        inlayHints_lifetimeElisionHints_useParameterNames: bool  = "false",
+        /// Whether to hide inlay hints for constructors.
+        inlayHints_hideNamedConstructorHints: bool          = "false",
 
-        /// Join lines merges consecutive declaration and initialization of an assignment.
-        joinLines_joinAssignments: bool = "true",
         /// Join lines inserts else between consecutive ifs.
         joinLines_joinElseIf: bool = "true",
         /// Join lines removes trailing commas.
         joinLines_removeTrailingComma: bool = "true",
         /// Join lines unwraps trivial blocks.
         joinLines_unwrapTrivialBlock: bool = "true",
+        /// Join lines merges consecutive declaration and initialization of an assignment.
+        joinLines_joinAssignments: bool = "true",
 
         /// Whether to show `Debug` lens. Only applies when
         /// `#rust-analyzer.lens.enable#` is set.
-        lens_debug_enable: bool            = "true",
+        lens_debug: bool            = "true",
         /// Whether to show CodeLens in Rust files.
         lens_enable: bool           = "true",
-        /// Internal config: use custom client-side commands even when the
-        /// client doesn't set the corresponding capability.
-        lens_forceCustomCommands: bool = "true",
         /// Whether to show `Implementations` lens. Only applies when
         /// `#rust-analyzer.lens.enable#` is set.
-        lens_implementations_enable: bool  = "true",
-        /// Whether to show `References` lens for Struct, Enum, and Union.
-        /// Only applies when `#rust-analyzer.lens.enable#` is set.
-        lens_references_adt_enable: bool = "false",
-        /// Whether to show `References` lens for Enum Variants.
-        /// Only applies when `#rust-analyzer.lens.enable#` is set.
-        lens_references_enumVariant_enable: bool = "false",
+        lens_implementations: bool  = "true",
+        /// Whether to show `Run` lens. Only applies when
+        /// `#rust-analyzer.lens.enable#` is set.
+        lens_run: bool              = "true",
         /// Whether to show `Method References` lens. Only applies when
         /// `#rust-analyzer.lens.enable#` is set.
-        lens_references_method_enable: bool = "false",
-        /// Whether to show `References` lens for Trait.
+        lens_methodReferences: bool = "false",
+        /// Whether to show `References` lens for Struct, Enum, Union and Trait.
         /// Only applies when `#rust-analyzer.lens.enable#` is set.
-        lens_references_trait_enable: bool = "false",
-        /// Whether to show `Run` lens. Only applies when
-        /// `#rust-analyzer.lens.enable#` is set.
-        lens_run_enable: bool              = "true",
+        lens_references: bool = "false",
+        /// Whether to show `References` lens for Enum Variants.
+        /// Only applies when `#rust-analyzer.lens.enable#` is set.
+        lens_enumVariantReferences: bool = "false",
+        /// Internal config: use custom client-side commands even when the
+        /// client doesn't set the corresponding capability.
+        lens_forceCustomCommands: bool = "true",
 
         /// Disable project auto-discovery in favor of explicitly specified set
         /// of projects.
@@ -315,33 +309,29 @@ config_data! {
         linkedProjects: Vec<ManifestOrProjectJson> = "[]",
 
         /// Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.
-        lru_capacity: Option<usize>                 = "null",
+        lruCapacity: Option<usize>                 = "null",
 
         /// Whether to show `can't find Cargo.toml` error message.
         notifications_cargoTomlNotFound: bool      = "true",
 
-        /// Warm up caches on project load.
-        primeCaches_enable: bool = "true",
         /// How many worker threads to to handle priming caches. The default `0` means to pick automatically.
         primeCaches_numThreads: ParallelPrimeCachesNumThreads = "0",
 
-        /// Expand attribute macros. Requires `#rust-analyzer.procMacro.enable#` to be set.
-        procMacro_attributes_enable: bool = "true",
-        /// Enable support for procedural macros, implies `#rust-analyzer.cargo.buildScripts.enable#`.
+        /// Enable support for procedural macros, implies `#rust-analyzer.cargo.runBuildScripts#`.
         procMacro_enable: bool                     = "true",
+        /// Internal config, path to proc-macro server executable (typically,
+        /// this is rust-analyzer itself, but we override this in tests).
+        procMacro_server: Option<PathBuf>          = "null",
         /// These proc-macros will be ignored when trying to expand them.
         ///
         /// This config takes a map of crate names with the exported proc-macro names to ignore as values.
         procMacro_ignored: FxHashMap<Box<str>, Box<[Box<str>]>>          = "{}",
-        /// Internal config, path to proc-macro server executable (typically,
-        /// this is rust-analyzer itself, but we override this in tests).
-        procMacro_server: Option<PathBuf>          = "null",
 
         /// Command to be executed instead of 'cargo' for runnables.
-        runnables_command: Option<String> = "null",
+        runnables_overrideCargo: Option<String> = "null",
         /// Additional arguments to be passed to cargo for runnables such as
         /// tests or binaries. For example, it may be `--release`.
-        runnables_extraArgs: Vec<String>   = "[]",
+        runnables_cargoExtraArgs: Vec<String>   = "[]",
 
         /// Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private
         /// projects, or "discover" to try to automatically find it if the `rustc-dev` component
@@ -351,7 +341,7 @@ config_data! {
         /// crates must set `[package.metadata.rust-analyzer] rustc_private=true` to use it.
         ///
         /// This option does not take effect until rust-analyzer is restarted.
-        rustc_source: Option<String> = "null",
+        rustcSource: Option<String> = "null",
 
         /// Additional arguments to `rustfmt`.
         rustfmt_extraArgs: Vec<String>               = "[]",
@@ -361,28 +351,16 @@ config_data! {
         /// Enables the use of rustfmt's unstable range formatting command for the
         /// `textDocument/rangeFormatting` request. The rustfmt option is unstable and only
         /// available on a nightly build.
-        rustfmt_rangeFormatting_enable: bool = "false",
-
-        /// Use semantic tokens for strings.
-        ///
-        /// In some editors (e.g. vscode) semantic tokens override other highlighting grammars.
-        /// By disabling semantic tokens for strings, other grammars can be used to highlight
-        /// their contents.
-        semanticHighlighting_strings_enable: bool = "true",
-
-        /// Show full signature of the callable. Only shows parameters if disabled.
-        signatureInfo_detail: SignatureDetail                           = "\"full\"",
-        /// Show documentation.
-        signatureInfo_documentation_enable: bool                       = "true",
+        rustfmt_enableRangeFormatting: bool = "false",
 
+        /// Workspace symbol search scope.
+        workspace_symbol_search_scope: WorkspaceSymbolSearchScopeDef = "\"workspace\"",
         /// Workspace symbol search kind.
         workspace_symbol_search_kind: WorkspaceSymbolSearchKindDef = "\"only_types\"",
         /// Limits the number of items returned from a workspace symbol search (Defaults to 128).
         /// Some clients like vs-code issue new searches on result filtering and don't require all results to be returned in the initial search.
         /// Other clients requires all results upfront and might require a higher limit.
         workspace_symbol_search_limit: usize = "128",
-        /// Workspace symbol search scope.
-        workspace_symbol_search_scope: WorkspaceSymbolSearchScopeDef = "\"workspace\"",
     }
 }
 
@@ -422,11 +400,6 @@ impl From<ProjectJson> for LinkedProject {
     }
 }
 
-pub struct CallInfoConfig {
-    pub params_only: bool,
-    pub docs: bool,
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LensConfig {
     // runnables
@@ -438,8 +411,7 @@ pub struct LensConfig {
 
     // references
     pub method_refs: bool,
-    pub refs_adt: bool,   // for Struct, Enum, Union and Trait
-    pub refs_trait: bool, // for Struct, Enum, Union and Trait
+    pub refs: bool, // for Struct, Enum, Union and Trait
     pub enum_variant_refs: bool,
 }
 
@@ -449,8 +421,7 @@ impl LensConfig {
             || self.debug
             || self.implementations
             || self.method_refs
-            || self.refs_adt
-            || self.refs_trait
+            || self.refs
             || self.enum_variant_refs
     }
 
@@ -463,7 +434,7 @@ impl LensConfig {
     }
 
     pub fn references(&self) -> bool {
-        self.method_refs || self.refs_adt || self.refs_trait || self.enum_variant_refs
+        self.method_refs || self.refs || self.enum_variant_refs
     }
 }
 
@@ -549,7 +520,6 @@ pub struct ClientCommandsConfig {
     pub trigger_parameter_hints: bool,
 }
 
-#[derive(Debug)]
 pub struct ConfigUpdateError {
     errors: Vec<(String, serde_json::Error)>,
 }
@@ -594,10 +564,9 @@ impl Config {
                 .into_iter()
                 .map(AbsPathBuf::assert)
                 .collect();
-        patch_old_style::patch_json_for_outdated_configs(&mut json);
         self.data = ConfigData::from_json(json, &mut errors);
         self.snippets.clear();
-        for (name, def) in self.data.completion_snippets_custom.iter() {
+        for (name, def) in self.data.completion_snippets.iter() {
             if def.prefix.is_empty() && def.postfix.is_empty() {
                 continue;
             }
@@ -716,7 +685,7 @@ impl Config {
     }
 
     pub fn prefill_caches(&self) -> bool {
-        self.data.primeCaches_enable
+        self.data.cache_warmup
     }
 
     pub fn location_link(&self) -> bool {
@@ -826,9 +795,9 @@ impl Config {
 
     pub fn diagnostics(&self) -> DiagnosticsConfig {
         DiagnosticsConfig {
-            disable_experimental: !self.data.diagnostics_experimental_enable,
+            disable_experimental: !self.data.diagnostics_enableExperimental,
             disabled: self.data.diagnostics_disabled.clone(),
-            expr_fill_default: match self.data.assist_expressionFillDefault {
+            expr_fill_default: match self.data.assist_exprFillDefault {
                 ExprFillDefaultDef::Todo => ExprFillDefaultMode::Todo,
                 ExprFillDefaultDef::Default => ExprFillDefaultMode::Default,
             },
@@ -844,7 +813,7 @@ impl Config {
     }
 
     pub fn lru_capacity(&self) -> Option<usize> {
-        self.data.lru_capacity
+        self.data.lruCapacity
     }
 
     pub fn proc_macro_srv(&self) -> Option<(AbsPathBuf, Vec<OsString>)> {
@@ -863,7 +832,7 @@ impl Config {
     }
 
     pub fn expand_proc_attr_macros(&self) -> bool {
-        self.data.procMacro_attributes_enable
+        self.data.experimental_procAttrMacros
     }
 
     pub fn files(&self) -> FilesConfig {
@@ -888,11 +857,11 @@ impl Config {
     }
 
     pub fn run_build_scripts(&self) -> bool {
-        self.data.cargo_buildScripts_enable || self.data.procMacro_enable
+        self.data.cargo_runBuildScripts || self.data.procMacro_enable
     }
 
     pub fn cargo(&self) -> CargoConfig {
-        let rustc_source = self.data.rustc_source.as_ref().map(|rustc_src| {
+        let rustc_source = self.data.rustcSource.as_ref().map(|rustc_src| {
             if rustc_src == "discover" {
                 RustcSource::Discover
             } else {
@@ -902,17 +871,14 @@ impl Config {
 
         CargoConfig {
             no_default_features: self.data.cargo_noDefaultFeatures,
-            all_features: matches!(self.data.cargo_features, CargoFeatures::All),
-            features: match &self.data.cargo_features {
-                CargoFeatures::All => vec![],
-                CargoFeatures::Listed(it) => it.clone(),
-            },
+            all_features: self.data.cargo_allFeatures,
+            features: self.data.cargo_features.clone(),
             target: self.data.cargo_target.clone(),
             no_sysroot: self.data.cargo_noSysroot,
             rustc_source,
             unset_test_crates: UnsetTestCrates::Only(self.data.cargo_unsetTest.clone()),
-            wrap_rustc_in_build_scripts: self.data.cargo_buildScripts_useRustcWrapper,
-            run_build_script_command: self.data.cargo_buildScripts_overrideCommand.clone(),
+            wrap_rustc_in_build_scripts: self.data.cargo_useRustcWrapperForBuildScripts,
+            run_build_script_command: self.data.cargo_runBuildScriptsCommand.clone(),
         }
     }
 
@@ -925,7 +891,7 @@ impl Config {
             }
             Some(_) | None => RustfmtConfig::Rustfmt {
                 extra_args: self.data.rustfmt_extraArgs.clone(),
-                enable_range_formatting: self.data.rustfmt_rangeFormatting_enable,
+                enable_range_formatting: self.data.rustfmt_enableRangeFormatting,
             },
         }
     }
@@ -952,19 +918,15 @@ impl Config {
                     .data
                     .checkOnSave_noDefaultFeatures
                     .unwrap_or(self.data.cargo_noDefaultFeatures),
-                all_features: matches!(
-                    self.data.checkOnSave_features.as_ref().unwrap_or(&self.data.cargo_features),
-                    CargoFeatures::All
-                ),
-                features: match self
+                all_features: self
+                    .data
+                    .checkOnSave_allFeatures
+                    .unwrap_or(self.data.cargo_allFeatures),
+                features: self
                     .data
                     .checkOnSave_features
                     .clone()
-                    .unwrap_or_else(|| self.data.cargo_features.clone())
-                {
-                    CargoFeatures::All => vec![],
-                    CargoFeatures::Listed(it) => it,
-                },
+                    .unwrap_or_else(|| self.data.cargo_features.clone()),
                 extra_args: self.data.checkOnSave_extraArgs.clone(),
             },
         };
@@ -973,25 +935,25 @@ impl Config {
 
     pub fn runnables(&self) -> RunnablesConfig {
         RunnablesConfig {
-            override_cargo: self.data.runnables_command.clone(),
-            cargo_extra_args: self.data.runnables_extraArgs.clone(),
+            override_cargo: self.data.runnables_overrideCargo.clone(),
+            cargo_extra_args: self.data.runnables_cargoExtraArgs.clone(),
         }
     }
 
     pub fn inlay_hints(&self) -> InlayHintsConfig {
         InlayHintsConfig {
             render_colons: self.data.inlayHints_renderColons,
-            type_hints: self.data.inlayHints_typeHints_enable,
-            parameter_hints: self.data.inlayHints_parameterHints_enable,
-            chaining_hints: self.data.inlayHints_chainingHints_enable,
-            closure_return_type_hints: self.data.inlayHints_closureReturnTypeHints_enable,
+            type_hints: self.data.inlayHints_typeHints,
+            parameter_hints: self.data.inlayHints_parameterHints,
+            chaining_hints: self.data.inlayHints_chainingHints,
+            closure_return_type_hints: self.data.inlayHints_closureReturnTypeHints,
             lifetime_elision_hints: match self.data.inlayHints_lifetimeElisionHints_enable {
                 LifetimeElisionDef::Always => LifetimeElisionHints::Always,
                 LifetimeElisionDef::Never => LifetimeElisionHints::Never,
                 LifetimeElisionDef::SkipTrivial => LifetimeElisionHints::SkipTrivial,
             },
-            hide_named_constructor_hints: self.data.inlayHints_typeHints_hideNamedConstructor,
-            reborrow_hints: self.data.inlayHints_reborrowHints_enable,
+            hide_named_constructor_hints: self.data.inlayHints_hideNamedConstructorHints,
+            reborrow_hints: self.data.inlayHints_reborrowHints,
             param_names_for_lifetime_elision_hints: self
                 .data
                 .inlayHints_lifetimeElisionHints_useParameterNames,
@@ -1001,20 +963,20 @@ impl Config {
 
     fn insert_use_config(&self) -> InsertUseConfig {
         InsertUseConfig {
-            granularity: match self.data.imports_granularity_group {
+            granularity: match self.data.assist_importGranularity {
                 ImportGranularityDef::Preserve => ImportGranularity::Preserve,
                 ImportGranularityDef::Item => ImportGranularity::Item,
                 ImportGranularityDef::Crate => ImportGranularity::Crate,
                 ImportGranularityDef::Module => ImportGranularity::Module,
             },
-            enforce_granularity: self.data.imports_granularity_enforce,
-            prefix_kind: match self.data.imports_prefix {
+            enforce_granularity: self.data.assist_importEnforceGranularity,
+            prefix_kind: match self.data.assist_importPrefix {
                 ImportPrefixDef::Plain => PrefixKind::Plain,
                 ImportPrefixDef::ByCrate => PrefixKind::ByCrate,
                 ImportPrefixDef::BySelf => PrefixKind::BySelf,
             },
-            group: self.data.imports_group_enable,
-            skip_glob_imports: !self.data.imports_merge_glob,
+            group: self.data.assist_importGroup,
+            skip_glob_imports: !self.data.assist_allowMergingIntoGlobImports,
         }
     }
 
@@ -1025,14 +987,8 @@ impl Config {
                 && completion_item_edit_resolve(&self.caps),
             enable_self_on_the_fly: self.data.completion_autoself_enable,
             enable_private_editable: self.data.completion_privateEditable_enable,
-            add_call_parenthesis: matches!(
-                self.data.completion_callable_snippets,
-                Some(CallableCompletionDef::AddParentheses)
-            ),
-            add_call_argument_snippets: matches!(
-                self.data.completion_callable_snippets,
-                Some(CallableCompletionDef::FillArguments)
-            ),
+            add_call_parenthesis: self.data.completion_addCallParenthesis,
+            add_call_argument_snippets: self.data.completion_addCallArgumentSnippets,
             insert_use: self.insert_use_config(),
             snippet_cap: SnippetCap::new(try_or_def!(
                 self.caps
@@ -1065,45 +1021,40 @@ impl Config {
         }
     }
 
-    pub fn call_info(&self) -> CallInfoConfig {
-        CallInfoConfig {
-            params_only: matches!(self.data.signatureInfo_detail, SignatureDetail::Parameters),
-            docs: self.data.signatureInfo_documentation_enable,
-        }
+    pub fn call_info_full(&self) -> bool {
+        self.data.callInfo_full
     }
 
     pub fn lens(&self) -> LensConfig {
         LensConfig {
-            run: self.data.lens_enable && self.data.lens_run_enable,
-            debug: self.data.lens_enable && self.data.lens_debug_enable,
-            implementations: self.data.lens_enable && self.data.lens_implementations_enable,
-            method_refs: self.data.lens_enable && self.data.lens_references_method_enable,
-            refs_adt: self.data.lens_enable && self.data.lens_references_adt_enable,
-            refs_trait: self.data.lens_enable && self.data.lens_references_trait_enable,
-            enum_variant_refs: self.data.lens_enable
-                && self.data.lens_references_enumVariant_enable,
+            run: self.data.lens_enable && self.data.lens_run,
+            debug: self.data.lens_enable && self.data.lens_debug,
+            implementations: self.data.lens_enable && self.data.lens_implementations,
+            method_refs: self.data.lens_enable && self.data.lens_methodReferences,
+            refs: self.data.lens_enable && self.data.lens_references,
+            enum_variant_refs: self.data.lens_enable && self.data.lens_enumVariantReferences,
         }
     }
 
     pub fn hover_actions(&self) -> HoverActionsConfig {
-        let enable = self.experimental("hoverActions") && self.data.hover_actions_enable;
+        let enable = self.experimental("hoverActions") && self.data.hoverActions_enable;
         HoverActionsConfig {
-            implementations: enable && self.data.hover_actions_implementations_enable,
-            references: enable && self.data.hover_actions_references_enable,
-            run: enable && self.data.hover_actions_run_enable,
-            debug: enable && self.data.hover_actions_debug_enable,
-            goto_type_def: enable && self.data.hover_actions_gotoTypeDef_enable,
+            implementations: enable && self.data.hoverActions_implementations,
+            references: enable && self.data.hoverActions_references,
+            run: enable && self.data.hoverActions_run,
+            debug: enable && self.data.hoverActions_debug,
+            goto_type_def: enable && self.data.hoverActions_gotoTypeDef,
         }
     }
 
     pub fn highlighting_strings(&self) -> bool {
-        self.data.semanticHighlighting_strings_enable
+        self.data.highlighting_strings
     }
 
     pub fn hover(&self) -> HoverConfig {
         HoverConfig {
-            links_in_hover: self.data.hover_links_enable,
-            documentation: self.data.hover_documentation_enable.then(|| {
+            links_in_hover: self.data.hover_linksInHover,
+            documentation: self.data.hover_documentation.then(|| {
                 let is_markdown = try_or_def!(self
                     .caps
                     .text_document
@@ -1181,10 +1132,10 @@ impl Config {
 
     pub fn highlight_related(&self) -> HighlightRelatedConfig {
         HighlightRelatedConfig {
-            references: self.data.highlightRelated_references_enable,
-            break_points: self.data.highlightRelated_breakPoints_enable,
-            exit_points: self.data.highlightRelated_exitPoints_enable,
-            yield_points: self.data.highlightRelated_yieldPoints_enable,
+            references: self.data.highlightRelated_references,
+            break_points: self.data.highlightRelated_breakPoints,
+            exit_points: self.data.highlightRelated_exitPoints,
+            yield_points: self.data.highlightRelated_yieldPoints,
         }
     }
 
@@ -1195,105 +1146,8 @@ impl Config {
         }
     }
 }
-// Deserialization definitions
-
-macro_rules! create_bool_or_string_de {
-    ($ident:ident<$bool:literal, $string:literal>) => {
-        fn $ident<'de, D>(d: D) -> Result<(), D::Error>
-        where
-            D: serde::Deserializer<'de>,
-        {
-            struct V;
-            impl<'de> serde::de::Visitor<'de> for V {
-                type Value = ();
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str(concat!(
-                        stringify!($bool),
-                        " or \"",
-                        stringify!($string),
-                        "\""
-                    ))
-                }
-
-                fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-                where
-                    E: serde::de::Error,
-                {
-                    match v {
-                        $bool => Ok(()),
-                        _ => Err(serde::de::Error::invalid_value(
-                            serde::de::Unexpected::Bool(v),
-                            &self,
-                        )),
-                    }
-                }
-
-                fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                where
-                    E: serde::de::Error,
-                {
-                    match v {
-                        $string => Ok(()),
-                        _ => Err(serde::de::Error::invalid_value(
-                            serde::de::Unexpected::Str(v),
-                            &self,
-                        )),
-                    }
-                }
 
-                fn visit_enum<A>(self, a: A) -> Result<Self::Value, A::Error>
-                where
-                    A: serde::de::EnumAccess<'de>,
-                {
-                    use serde::de::VariantAccess;
-                    let (variant, va) = a.variant::<&'de str>()?;
-                    va.unit_variant()?;
-                    match variant {
-                        $string => Ok(()),
-                        _ => Err(serde::de::Error::invalid_value(
-                            serde::de::Unexpected::Str(variant),
-                            &self,
-                        )),
-                    }
-                }
-            }
-            d.deserialize_any(V)
-        }
-    };
-}
-create_bool_or_string_de!(true_or_always<true, "always">);
-create_bool_or_string_de!(false_or_never<false, "never">);
-
-macro_rules! named_unit_variant {
-    ($variant:ident) => {
-        pub(super) fn $variant<'de, D>(deserializer: D) -> Result<(), D::Error>
-        where
-            D: serde::Deserializer<'de>,
-        {
-            struct V;
-            impl<'de> serde::de::Visitor<'de> for V {
-                type Value = ();
-                fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-                    f.write_str(concat!("\"", stringify!($variant), "\""))
-                }
-                fn visit_str<E: serde::de::Error>(self, value: &str) -> Result<Self::Value, E> {
-                    if value == stringify!($variant) {
-                        Ok(())
-                    } else {
-                        Err(E::invalid_value(serde::de::Unexpected::Str(value), &self))
-                    }
-                }
-            }
-            deserializer.deserialize_str(V)
-        }
-    };
-}
-
-mod de_unit_v {
-    named_unit_variant!(all);
-    named_unit_variant!(skip_trivial);
-}
+// Deserialization definitions
 
 #[derive(Deserialize, Debug, Clone, Copy)]
 #[serde(rename_all = "snake_case")]
@@ -1365,7 +1219,9 @@ enum ManifestOrProjectJson {
 #[derive(Deserialize, Debug, Clone)]
 #[serde(rename_all = "snake_case")]
 pub enum ExprFillDefaultDef {
+    #[serde(alias = "todo")]
     Todo,
+    #[serde(alias = "default")]
     Default,
 }
 
@@ -1373,34 +1229,21 @@ pub enum ExprFillDefaultDef {
 #[serde(rename_all = "snake_case")]
 enum ImportGranularityDef {
     Preserve,
+    #[serde(alias = "none")]
     Item,
+    #[serde(alias = "full")]
     Crate,
+    #[serde(alias = "last")]
     Module,
 }
 
 #[derive(Deserialize, Debug, Clone)]
 #[serde(rename_all = "snake_case")]
-enum CallableCompletionDef {
-    FillArguments,
-    AddParentheses,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-#[serde(untagged)]
-enum CargoFeatures {
-    #[serde(deserialize_with = "de_unit_v::all")]
-    All,
-    Listed(Vec<String>),
-}
-
-#[derive(Deserialize, Debug, Clone)]
-#[serde(untagged)]
 enum LifetimeElisionDef {
-    #[serde(deserialize_with = "true_or_always")]
+    #[serde(alias = "true")]
     Always,
-    #[serde(deserialize_with = "false_or_never")]
+    #[serde(alias = "false")]
     Never,
-    #[serde(deserialize_with = "de_unit_v::skip_trivial")]
     SkipTrivial,
 }
 
@@ -1421,13 +1264,6 @@ enum WorkspaceSymbolSearchScopeDef {
     WorkspaceAndDependencies,
 }
 
-#[derive(Deserialize, Debug, Clone)]
-#[serde(rename_all = "snake_case")]
-enum SignatureDetail {
-    Full,
-    Parameters,
-}
-
 #[derive(Deserialize, Debug, Clone)]
 #[serde(rename_all = "snake_case")]
 enum WorkspaceSymbolSearchKindDef {
@@ -1481,11 +1317,6 @@ macro_rules! _config_data {
                 ])
             }
         }
-
-        #[test]
-        fn fields_are_sorted() {
-            [$(stringify!($field)),*].windows(2).for_each(|w| assert!(w[0] <= w[1], "{} <= {} does not hold", w[0], w[1]));
-        }
     };
 }
 use _config_data as config_data;
@@ -1498,6 +1329,7 @@ fn get_field<T: DeserializeOwned>(
     default: &str,
 ) -> T {
     let default = serde_json::from_str(default).unwrap();
+
     // XXX: check alias first, to work-around the VS Code where it pre-fills the
     // defaults instead of sending an empty object.
     alias
@@ -1667,7 +1499,7 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json
             "maximum": 255
         },
         "LifetimeElisionDef" => set! {
-            "type": ["string", "boolean"],
+            "type": "string",
             "enum": ["always", "never", "skip_trivial"],
             "enumDescriptions": [
                 "Always show lifetime elision hints.",
@@ -1675,38 +1507,6 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json
                 "Only show lifetime elision hints if a return type is involved."
             ],
         },
-        "CargoFeatures" => set! {
-            "type": ["string", "array"],
-            "items": { "type": "string" },
-            "enum": ["all"],
-            "enumDescriptions": [
-                "Pass `--all-features` to cargo",
-            ],
-        },
-        "Option<CargoFeatures>" => set! {
-            "type": ["string", "array", "null"],
-            "items": { "type": "string" },
-            "enum": ["all"],
-            "enumDescriptions": [
-                "Pass `--all-features` to cargo",
-            ],
-        },
-        "Option<CallableCompletionDef>" => set! {
-            "type": ["string", "null"],
-            "enum": ["fill_arguments", "add_parentheses"],
-            "enumDescriptions": [
-                "Add call parentheses and pre-fill arguments",
-                "Add call parentheses",
-            ],
-        },
-        "SignatureDetail" => set! {
-            "type": "string",
-            "enum": ["full", "parameters"],
-            "enumDescriptions": [
-                "Show the entire signature.",
-                "Show only the parameters."
-            ],
-        },
         _ => panic!("missing entry for {}: {}", ty, default),
     }
 
diff --git a/crates/rust-analyzer/src/config/patch_old_style.rs b/crates/rust-analyzer/src/config/patch_old_style.rs
deleted file mode 100644
index 277364cefa..0000000000
--- a/crates/rust-analyzer/src/config/patch_old_style.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-//! See [`patch_json_for_outdated_configs`]
-use serde_json::{json, Value};
-
-/// This function patches the json config to the new expected keys.
-/// That is we try to load old known config keys here and convert them to the new ones.
-/// See https://github.com/rust-lang/rust-analyzer/pull/12010
-pub(super) fn patch_json_for_outdated_configs(json: &mut Value) {
-    let copy = json.clone();
-
-    macro_rules! patch {
-        ($(
-            $($src:ident).+ -> $($dst:ident).+ ;
-        )+) => { $(
-            if let Some(it) = copy.pointer(concat!($("/", stringify!($src)),+)).cloned() {
-                let mut last = it;
-                for segment in [$(stringify!($dst)),+].into_iter().rev() {
-                    last = Value::Object(serde_json::Map::from_iter(std::iter::once((segment.to_string(), last))));
-                }
-
-                merge(json, last);
-            }
-        )+ };
-    }
-
-    patch! {
-        assist.allowMergingIntoGlobImports -> imports.merge.glob;
-        assist.exprFillDefault -> assist.expressionFillDefault;
-        assist.importEnforceGranularity -> imports.granularity.enforce;
-        assist.importGranularity -> imports.granularity.group;
-        assist.importMergeBehavior -> imports.granularity.group;
-        assist.importMergeBehaviour -> imports.granularity.group;
-        assist.importGroup -> imports.group.enable;
-        assist.importPrefix -> imports.prefix;
-        cache.warmup -> primeCaches.enable;
-        cargo.loadOutDirsFromCheck -> cargo.buildScripts.enable;
-        cargo.runBuildScripts -> cargo.runBuildScripts.overrideCommand;
-        cargo.runBuildScriptsCommand -> cargo.runBuildScripts.overrideCommand;
-        cargo.useRustcWrapperForBuildScripts -> cargo.runBuildScripts.useRustcWrapper;
-        completion.snippets -> completion.snippets.custom;
-        diagnostics.enableExperimental -> diagnostics.experimental.enable;
-        experimental.procAttrMacros -> procMacro.attributes.enable;
-        highlighting.strings -> semanticHighlighting.strings.enable;
-        highlightRelated.breakPoints -> semanticHighlighting.breakPoints.enable;
-        highlightRelated.exitPoints -> semanticHighlighting.exitPoints.enable;
-        highlightRelated.yieldPoints -> semanticHighlighting.yieldPoints.enable;
-        highlightRelated.references -> semanticHighlighting.references.enable;
-        hover.documentation -> hover.documentation.enable;
-        hover.linksInHover -> hover.links.enable;
-        hoverActions.linksInHover -> hover.links.enable;
-        hoverActions.debug -> hoverActions.debug.enable;
-        hoverActions.enable -> hoverActions.enable.enable;
-        hoverActions.gotoTypeDef -> hoverActions.gotoTypeDef.enable;
-        hoverActions.implementations -> hoverActions.implementations.enable;
-        hoverActions.references -> hoverActions.references.enable;
-        hoverActions.run -> hoverActions.run.enable;
-        inlayHints.chainingHints -> inlayHints.chainingHints.enable;
-        inlayHints.closureReturnTypeHints -> inlayHints.closureReturnTypeHints.enable;
-        inlayHints.hideNamedConstructorHints -> inlayHints.typeHints.hideNamedConstructorHints;
-        inlayHints.parameterHints -> inlayHints.parameterHints.enable;
-        inlayHints.reborrowHints -> inlayHints.reborrowHints.enable;
-        inlayHints.typeHints -> inlayHints.typeHints.enable;
-        lruCapacity -> lru.capacity;
-        runnables.cargoExtraArgs -> runnables.extraArgs ;
-        runnables.overrideCargo -> runnables.command ;
-        rustcSource -> rustc.source;
-        rustfmt.enableRangeFormatting -> rustfmt.rangeFormatting.enable;
-    }
-
-    // callInfo_full -> signatureInfo_detail, signatureInfo_documentation_enable
-    if let Some(Value::Bool(b)) = copy.pointer("/callInfo/full") {
-        let sig_info = match b {
-            true => json!({ "signatureInfo": {
-                "documentation": {"enable": true}},
-                "detail": "full"
-            }),
-            false => json!({ "signatureInfo": {
-                "documentation": {"enable": false}},
-                "detail": "parameters"
-            }),
-        };
-        merge(json, sig_info);
-    }
-
-    // cargo_allFeatures, cargo_features -> cargo_features
-    if let Some(Value::Bool(true)) = copy.pointer("/cargo/allFeatures") {
-        merge(json, json!({ "cargo": { "features": "all" } }));
-    }
-
-    // checkOnSave_allFeatures, checkOnSave_features -> checkOnSave_features
-    if let Some(Value::Bool(true)) = copy.pointer("/checkOnSave/allFeatures") {
-        merge(json, json!({ "checkOnSave": { "features": "all" } }));
-    }
-
-    // completion_addCallArgumentSnippets completion_addCallParenthesis -> completion_callable_snippets
-    let res = match (
-        copy.pointer("/completion/addCallArgumentSnippets"),
-        copy.pointer("/completion/addCallParenthesis"),
-    ) {
-        (Some(Value::Bool(true)), Some(Value::Bool(true))) => json!("fill_arguments"),
-        (Some(Value::Bool(true)), _) => json!("add_parentheses"),
-        (_, _) => json!(null),
-    };
-    merge(json, json!({ "completion": { "callable": {"snippets": res }} }));
-}
-
-fn merge(dst: &mut Value, src: Value) {
-    match (dst, src) {
-        (Value::Object(dst), Value::Object(src)) => {
-            for (k, v) in src {
-                merge(dst.entry(k).or_insert(v.clone()), v)
-            }
-        }
-        (dst, src) => *dst = src,
-    }
-}
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index ec897ec9d9..d005cdb985 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -911,8 +911,8 @@ pub(crate) fn handle_signature_help(
         Some(it) => it,
         None => return Ok(None),
     };
-    let config = snap.config.call_info();
-    let res = to_proto::signature_help(help, config, snap.config.signature_help_label_offsets());
+    let concise = !snap.config.call_info_full();
+    let res = to_proto::signature_help(help, concise, snap.config.signature_help_label_offsets());
     Ok(Some(res))
 }
 
@@ -1215,7 +1215,7 @@ pub(crate) fn handle_code_lens(
                 .unwrap_or(false),
             annotate_runnables: lens_config.runnable(),
             annotate_impls: lens_config.implementations,
-            annotate_references: lens_config.refs_adt,
+            annotate_references: lens_config.refs,
             annotate_method_references: lens_config.method_refs,
             annotate_enum_variant_references: lens_config.enum_variant_refs,
         },
diff --git a/crates/rust-analyzer/src/integrated_benchmarks.rs b/crates/rust-analyzer/src/integrated_benchmarks.rs
index 4e6acaa877..b1f8958e92 100644
--- a/crates/rust-analyzer/src/integrated_benchmarks.rs
+++ b/crates/rust-analyzer/src/integrated_benchmarks.rs
@@ -31,7 +31,7 @@ fn integrated_highlighting_benchmark() {
 
     // Load rust-analyzer itself.
     let workspace_to_load = project_root();
-    let file = "./crates/ide-db/src/apply_change.rs";
+    let file = "./crates/ide_db/src/apply_change.rs";
 
     let cargo_config = CargoConfig::default();
     let load_cargo_config = LoadCargoConfig {
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index ffcea078ce..57b0e93765 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -18,7 +18,7 @@ use vfs::AbsPath;
 
 use crate::{
     cargo_target_spec::CargoTargetSpec,
-    config::{CallInfoConfig, Config},
+    config::Config,
     global_state::GlobalStateSnapshot,
     line_index::{LineEndings, LineIndex, OffsetEncoding},
     lsp_ext,
@@ -338,11 +338,11 @@ fn completion_item(
 
 pub(crate) fn signature_help(
     call_info: SignatureHelp,
-    config: CallInfoConfig,
+    concise: bool,
     label_offsets: bool,
 ) -> lsp_types::SignatureHelp {
-    let (label, parameters) = match (!config.params_only, label_offsets) {
-        (concise, false) => {
+    let (label, parameters) = match (concise, label_offsets) {
+        (_, false) => {
             let params = call_info
                 .parameter_labels()
                 .map(|label| lsp_types::ParameterInformation {
@@ -388,12 +388,16 @@ pub(crate) fn signature_help(
         }
     };
 
-    let documentation = call_info.doc.filter(|_| config.docs).map(|doc| {
-        lsp_types::Documentation::MarkupContent(lsp_types::MarkupContent {
-            kind: lsp_types::MarkupKind::Markdown,
-            value: doc,
+    let documentation = if concise {
+        None
+    } else {
+        call_info.doc.map(|doc| {
+            lsp_types::Documentation::MarkupContent(lsp_types::MarkupContent {
+                kind: lsp_types::MarkupKind::Markdown,
+                value: doc,
+            })
         })
-    });
+    };
 
     let active_parameter = call_info.active_parameter.map(|it| it as u32);
 
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index bc513601a8..a9dcdfd696 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -1,115 +1,122 @@
-[[rust-analyzer.assist.expressionFillDefault]]rust-analyzer.assist.expressionFillDefault (default: `"todo"`)::
+[[rust-analyzer.assist.exprFillDefault]]rust-analyzer.assist.exprFillDefault (default: `"todo"`)::
 +
 --
-Placeholder expression to use for missing expressions in assists.
+Placeholder for missing expressions in assists.
 --
-[[rust-analyzer.cargo.autoreload]]rust-analyzer.cargo.autoreload (default: `true`)::
+[[rust-analyzer.assist.importGranularity]]rust-analyzer.assist.importGranularity (default: `"crate"`)::
 +
 --
-Automatically refresh project info via `cargo metadata` on
-`Cargo.toml` or `.cargo/config.toml` changes.
+How imports should be grouped into use statements.
 --
-[[rust-analyzer.cargo.buildScripts.enable]]rust-analyzer.cargo.buildScripts.enable (default: `true`)::
+[[rust-analyzer.assist.importEnforceGranularity]]rust-analyzer.assist.importEnforceGranularity (default: `false`)::
 +
 --
-Run build scripts (`build.rs`) for more precise code analysis.
+Whether to enforce the import granularity setting for all files. If set to false rust-analyzer will try to keep import styles consistent per file.
 --
-[[rust-analyzer.cargo.buildScripts.overrideCommand]]rust-analyzer.cargo.buildScripts.overrideCommand (default: `null`)::
+[[rust-analyzer.assist.importPrefix]]rust-analyzer.assist.importPrefix (default: `"plain"`)::
 +
 --
-Override the command rust-analyzer uses to run build scripts and
-build procedural macros. The command is required to output json
-and should therefor include `--message-format=json` or a similar
-option.
-
-By default, a cargo invocation will be constructed for the configured
-targets and features, with the following base command line:
-
-```bash
-cargo check --quiet --workspace --message-format=json --all-targets
-```
-.
+The path structure for newly inserted paths to use.
 --
-[[rust-analyzer.cargo.buildScripts.useRustcWrapper]]rust-analyzer.cargo.buildScripts.useRustcWrapper (default: `true`)::
+[[rust-analyzer.assist.importGroup]]rust-analyzer.assist.importGroup (default: `true`)::
 +
 --
-Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to
-avoid compiling unnecessary things.
+Group inserted imports by the https://rust-analyzer.github.io/manual.html#auto-import[following order]. Groups are separated by newlines.
 --
-[[rust-analyzer.cargo.features]]rust-analyzer.cargo.features (default: `[]`)::
+[[rust-analyzer.assist.allowMergingIntoGlobImports]]rust-analyzer.assist.allowMergingIntoGlobImports (default: `true`)::
 +
 --
-List of features to activate.
-
-Set this to `"all"` to pass `--all-features` to cargo.
+Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.
 --
-[[rust-analyzer.cargo.noDefaultFeatures]]rust-analyzer.cargo.noDefaultFeatures (default: `false`)::
+[[rust-analyzer.cache.warmup]]rust-analyzer.cache.warmup (default: `true`)::
 +
 --
-Whether to pass `--no-default-features` to cargo.
+Warm up caches on project load.
 --
-[[rust-analyzer.cargo.noSysroot]]rust-analyzer.cargo.noSysroot (default: `false`)::
+[[rust-analyzer.callInfo.full]]rust-analyzer.callInfo.full (default: `true`)::
 +
 --
-Internal config for debugging, disables loading of sysroot crates.
+Show function name and docs in parameter hints.
 --
-[[rust-analyzer.cargo.target]]rust-analyzer.cargo.target (default: `null`)::
+[[rust-analyzer.cargo.autoreload]]rust-analyzer.cargo.autoreload (default: `true`)::
++
+--
+Automatically refresh project info via `cargo metadata` on
+`Cargo.toml` or `.cargo/config.toml` changes.
+--
+[[rust-analyzer.cargo.allFeatures]]rust-analyzer.cargo.allFeatures (default: `false`)::
 +
 --
-Compilation target override (target triple).
+Activate all available features (`--all-features`).
 --
 [[rust-analyzer.cargo.unsetTest]]rust-analyzer.cargo.unsetTest (default: `["core"]`)::
 +
 --
 Unsets `#[cfg(test)]` for the specified crates.
 --
-[[rust-analyzer.checkOnSave.allTargets]]rust-analyzer.checkOnSave.allTargets (default: `true`)::
+[[rust-analyzer.cargo.features]]rust-analyzer.cargo.features (default: `[]`)::
 +
 --
-Check all targets and tests (`--all-targets`).
+List of features to activate.
 --
-[[rust-analyzer.checkOnSave.command]]rust-analyzer.checkOnSave.command (default: `"check"`)::
+[[rust-analyzer.cargo.runBuildScripts]]rust-analyzer.cargo.runBuildScripts (default: `true`)::
 +
 --
-Cargo command to use for `cargo check`.
+Run build scripts (`build.rs`) for more precise code analysis.
+--
+[[rust-analyzer.cargo.runBuildScriptsCommand]]rust-analyzer.cargo.runBuildScriptsCommand (default: `null`)::
++
+--
+Advanced option, fully override the command rust-analyzer uses to
+run build scripts and build procedural macros. The command should
+include `--message-format=json` or a similar option.
+--
+[[rust-analyzer.cargo.useRustcWrapperForBuildScripts]]rust-analyzer.cargo.useRustcWrapperForBuildScripts (default: `true`)::
++
+--
+Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to
+avoid compiling unnecessary things.
+--
+[[rust-analyzer.cargo.noDefaultFeatures]]rust-analyzer.cargo.noDefaultFeatures (default: `false`)::
++
+--
+Do not activate the `default` feature.
+--
+[[rust-analyzer.cargo.target]]rust-analyzer.cargo.target (default: `null`)::
++
+--
+Compilation target (target triple).
+--
+[[rust-analyzer.cargo.noSysroot]]rust-analyzer.cargo.noSysroot (default: `false`)::
++
+--
+Internal config for debugging, disables loading of sysroot crates.
 --
 [[rust-analyzer.checkOnSave.enable]]rust-analyzer.checkOnSave.enable (default: `true`)::
 +
 --
 Run specified `cargo check` command for diagnostics on save.
 --
-[[rust-analyzer.checkOnSave.extraArgs]]rust-analyzer.checkOnSave.extraArgs (default: `[]`)::
+[[rust-analyzer.checkOnSave.allFeatures]]rust-analyzer.checkOnSave.allFeatures (default: `null`)::
 +
 --
-Extra arguments for `cargo check`.
+Check with all features (`--all-features`).
+Defaults to `#rust-analyzer.cargo.allFeatures#`.
 --
-[[rust-analyzer.checkOnSave.features]]rust-analyzer.checkOnSave.features (default: `null`)::
+[[rust-analyzer.checkOnSave.allTargets]]rust-analyzer.checkOnSave.allTargets (default: `true`)::
 +
 --
-List of features to activate. Defaults to
-`#rust-analyzer.cargo.features#`.
-
-Set to `"all"` to pass `--all-features` to cargo.
+Check all targets and tests (`--all-targets`).
 --
-[[rust-analyzer.checkOnSave.noDefaultFeatures]]rust-analyzer.checkOnSave.noDefaultFeatures (default: `null`)::
+[[rust-analyzer.checkOnSave.command]]rust-analyzer.checkOnSave.command (default: `"check"`)::
 +
 --
-Do not activate the `default` feature.
+Cargo command to use for `cargo check`.
 --
-[[rust-analyzer.checkOnSave.overrideCommand]]rust-analyzer.checkOnSave.overrideCommand (default: `null`)::
+[[rust-analyzer.checkOnSave.noDefaultFeatures]]rust-analyzer.checkOnSave.noDefaultFeatures (default: `null`)::
 +
 --
-Override the command rust-analyzer uses to  run build scripts and
-build procedural macros. The command is required to output json
-and should therefor include `--message-format=json` or a similar
-option.
-
-An example command would be:
-
-```bash
-cargo check --workspace --message-format=json --all-targets
-```
-.
+Do not activate the `default` feature.
 --
 [[rust-analyzer.checkOnSave.target]]rust-analyzer.checkOnSave.target (default: `null`)::
 +
@@ -117,34 +124,36 @@ cargo check --workspace --message-format=json --all-targets
 Check for a specific target. Defaults to
 `#rust-analyzer.cargo.target#`.
 --
-[[rust-analyzer.completion.autoimport.enable]]rust-analyzer.completion.autoimport.enable (default: `true`)::
+[[rust-analyzer.checkOnSave.extraArgs]]rust-analyzer.checkOnSave.extraArgs (default: `[]`)::
 +
 --
-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.
+Extra arguments for `cargo check`.
 --
-[[rust-analyzer.completion.autoself.enable]]rust-analyzer.completion.autoself.enable (default: `true`)::
+[[rust-analyzer.checkOnSave.features]]rust-analyzer.checkOnSave.features (default: `null`)::
 +
 --
-Toggles the additional completions that automatically show method calls and field accesses
-with `self` prefixed to them when inside a method.
+List of features to activate. Defaults to
+`#rust-analyzer.cargo.features#`.
 --
-[[rust-analyzer.completion.callable.snippets]]rust-analyzer.completion.callable.snippets (default: `"fill_arguments"`)::
+[[rust-analyzer.checkOnSave.overrideCommand]]rust-analyzer.checkOnSave.overrideCommand (default: `null`)::
 +
 --
-Whether to add parenthesis and argument snippets when completing function.
+Advanced option, fully override the command rust-analyzer uses for
+checking. The command should include `--message-format=json` or
+similar option.
 --
-[[rust-analyzer.completion.postfix.enable]]rust-analyzer.completion.postfix.enable (default: `true`)::
+[[rust-analyzer.completion.addCallArgumentSnippets]]rust-analyzer.completion.addCallArgumentSnippets (default: `true`)::
 +
 --
-Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
+Whether to add argument snippets when completing functions.
+Only applies when `#rust-analyzer.completion.addCallParenthesis#` is set.
 --
-[[rust-analyzer.completion.privateEditable.enable]]rust-analyzer.completion.privateEditable.enable (default: `false`)::
+[[rust-analyzer.completion.addCallParenthesis]]rust-analyzer.completion.addCallParenthesis (default: `true`)::
 +
 --
-Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.
+Whether to add parenthesis when completing functions.
 --
-[[rust-analyzer.completion.snippets.custom]]rust-analyzer.completion.snippets.custom::
+[[rust-analyzer.completion.snippets]]rust-analyzer.completion.snippets::
 +
 --
 Default:
@@ -194,22 +203,44 @@ Default:
 Custom completion snippets.
 
 --
-[[rust-analyzer.diagnostics.disabled]]rust-analyzer.diagnostics.disabled (default: `[]`)::
+[[rust-analyzer.completion.postfix.enable]]rust-analyzer.completion.postfix.enable (default: `true`)::
 +
 --
-List of rust-analyzer diagnostics to disable.
+Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
+--
+[[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.completion.autoself.enable]]rust-analyzer.completion.autoself.enable (default: `true`)::
++
+--
+Toggles the additional completions that automatically show method calls and field accesses
+with `self` prefixed to them when inside a method.
+--
+[[rust-analyzer.completion.privateEditable.enable]]rust-analyzer.completion.privateEditable.enable (default: `false`)::
++
+--
+Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.
 --
 [[rust-analyzer.diagnostics.enable]]rust-analyzer.diagnostics.enable (default: `true`)::
 +
 --
 Whether to show native rust-analyzer diagnostics.
 --
-[[rust-analyzer.diagnostics.experimental.enable]]rust-analyzer.diagnostics.experimental.enable (default: `false`)::
+[[rust-analyzer.diagnostics.enableExperimental]]rust-analyzer.diagnostics.enableExperimental (default: `false`)::
 +
 --
 Whether to show experimental rust-analyzer diagnostics that might
 have more false positives than usual.
 --
+[[rust-analyzer.diagnostics.disabled]]rust-analyzer.diagnostics.disabled (default: `[]`)::
++
+--
+List of rust-analyzer diagnostics to disable.
+--
 [[rust-analyzer.diagnostics.remapPrefix]]rust-analyzer.diagnostics.remapPrefix (default: `{}`)::
 +
 --
@@ -232,6 +263,16 @@ List of warnings that should be displayed with info severity.
 The warnings will be indicated by a blue squiggly underline in code
 and a blue icon in the `Problems Panel`.
 --
+[[rust-analyzer.experimental.procAttrMacros]]rust-analyzer.experimental.procAttrMacros (default: `true`)::
++
+--
+Expand attribute macros.
+--
+[[rust-analyzer.files.watcher]]rust-analyzer.files.watcher (default: `"client"`)::
++
+--
+Controls file watching implementation.
+--
 [[rust-analyzer.files.excludeDirs]]rust-analyzer.files.excludeDirs (default: `[]`)::
 +
 --
@@ -239,110 +280,115 @@ These directories will be ignored by rust-analyzer. They are
 relative to the workspace root, and globs are not supported. You may
 also need to add the folders to Code's `files.watcherExclude`.
 --
-[[rust-analyzer.files.watcher]]rust-analyzer.files.watcher (default: `"client"`)::
+[[rust-analyzer.highlightRelated.references]]rust-analyzer.highlightRelated.references (default: `true`)::
 +
 --
-Controls file watching implementation.
+Enables highlighting of related references while hovering your mouse above any identifier.
 --
-[[rust-analyzer.highlightRelated.breakPoints.enable]]rust-analyzer.highlightRelated.breakPoints.enable (default: `true`)::
+[[rust-analyzer.highlightRelated.exitPoints]]rust-analyzer.highlightRelated.exitPoints (default: `true`)::
 +
 --
-Enables highlighting of related references while the cursor is on `break`, `loop`, `while`, or `for` keywords.
+Enables highlighting of all exit points while hovering your mouse above any `return`, `?`, or return type arrow (`->`).
 --
-[[rust-analyzer.highlightRelated.exitPoints.enable]]rust-analyzer.highlightRelated.exitPoints.enable (default: `true`)::
+[[rust-analyzer.highlightRelated.breakPoints]]rust-analyzer.highlightRelated.breakPoints (default: `true`)::
 +
 --
-Enables highlighting of all exit points while the cursor is on any `return`, `?`, `fn`, or return type arrow (`->`).
+Enables highlighting of related references while hovering your mouse `break`, `loop`, `while`, or `for` keywords.
 --
-[[rust-analyzer.highlightRelated.references.enable]]rust-analyzer.highlightRelated.references.enable (default: `true`)::
+[[rust-analyzer.highlightRelated.yieldPoints]]rust-analyzer.highlightRelated.yieldPoints (default: `true`)::
 +
 --
-Enables highlighting of related references while the cursor is on any identifier.
+Enables highlighting of all break points for a loop or block context while hovering your mouse above any `async` or `await` keywords.
 --
-[[rust-analyzer.highlightRelated.yieldPoints.enable]]rust-analyzer.highlightRelated.yieldPoints.enable (default: `true`)::
+[[rust-analyzer.highlighting.strings]]rust-analyzer.highlighting.strings (default: `true`)::
 +
 --
-Enables highlighting of all break points for a loop or block context while the cursor is on any `async` or `await` keywords.
+Use semantic tokens for strings.
+
+In some editors (e.g. vscode) semantic tokens override other highlighting grammars.
+By disabling semantic tokens for strings, other grammars can be used to highlight
+their contents.
+--
+[[rust-analyzer.hover.documentation]]rust-analyzer.hover.documentation (default: `true`)::
++
+--
+Whether to show documentation on hover.
+--
+[[rust-analyzer.hover.linksInHover]]rust-analyzer.hover.linksInHover (default: `true`)::
++
+--
+Use markdown syntax for links in hover.
 --
-[[rust-analyzer.hover.actions.debug.enable]]rust-analyzer.hover.actions.debug.enable (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.hover.actions.enable]]rust-analyzer.hover.actions.enable (default: `true`)::
+[[rust-analyzer.hoverActions.enable]]rust-analyzer.hoverActions.enable (default: `true`)::
 +
 --
 Whether to show HoverActions in Rust files.
 --
-[[rust-analyzer.hover.actions.gotoTypeDef.enable]]rust-analyzer.hover.actions.gotoTypeDef.enable (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.hover.actions.implementations.enable]]rust-analyzer.hover.actions.implementations.enable (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.hover.actions.references.enable]]rust-analyzer.hover.actions.references.enable (default: `false`)::
+[[rust-analyzer.hoverActions.references]]rust-analyzer.hoverActions.references (default: `false`)::
 +
 --
 Whether to show `References` action. Only applies when
 `#rust-analyzer.hoverActions.enable#` is set.
 --
-[[rust-analyzer.hover.actions.run.enable]]rust-analyzer.hover.actions.run.enable (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.hover.documentation.enable]]rust-analyzer.hover.documentation.enable (default: `true`)::
-+
---
-Whether to show documentation on hover.
---
-[[rust-analyzer.hover.links.enable]]rust-analyzer.hover.links.enable (default: `true`)::
-+
---
-Use markdown syntax for links in hover.
---
-[[rust-analyzer.imports.granularity.enforce]]rust-analyzer.imports.granularity.enforce (default: `false`)::
+[[rust-analyzer.inlayHints.renderColons]]rust-analyzer.inlayHints.renderColons (default: `true`)::
 +
 --
-Whether to enforce the import granularity setting for all files. If set to false rust-analyzer will try to keep import styles consistent per file.
+Whether to render trailing colons for parameter hints, and trailing colons for parameter hints.
 --
-[[rust-analyzer.imports.granularity.group]]rust-analyzer.imports.granularity.group (default: `"crate"`)::
+[[rust-analyzer.inlayHints.maxLength]]rust-analyzer.inlayHints.maxLength (default: `25`)::
 +
 --
-How imports should be grouped into use statements.
+Maximum length for inlay hints. Set to null to have an unlimited length.
 --
-[[rust-analyzer.imports.group.enable]]rust-analyzer.imports.group.enable (default: `true`)::
+[[rust-analyzer.inlayHints.parameterHints]]rust-analyzer.inlayHints.parameterHints (default: `true`)::
 +
 --
-Group inserted imports by the https://rust-analyzer.github.io/manual.html#auto-import[following order]. Groups are separated by newlines.
+Whether to show function parameter name inlay hints at the call
+site.
 --
-[[rust-analyzer.imports.merge.glob]]rust-analyzer.imports.merge.glob (default: `true`)::
+[[rust-analyzer.inlayHints.typeHints]]rust-analyzer.inlayHints.typeHints (default: `true`)::
 +
 --
-Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.
+Whether to show inlay type hints for variables.
 --
-[[rust-analyzer.imports.prefix]]rust-analyzer.imports.prefix (default: `"plain"`)::
+[[rust-analyzer.inlayHints.chainingHints]]rust-analyzer.inlayHints.chainingHints (default: `true`)::
 +
 --
-The path structure for newly inserted paths to use.
+Whether to show inlay type hints for method chains.
 --
-[[rust-analyzer.inlayHints.chainingHints.enable]]rust-analyzer.inlayHints.chainingHints.enable (default: `true`)::
+[[rust-analyzer.inlayHints.closureReturnTypeHints]]rust-analyzer.inlayHints.closureReturnTypeHints (default: `false`)::
 +
 --
-Whether to show inlay type hints for method chains.
+Whether to show inlay type hints for return types of closures with blocks.
 --
-[[rust-analyzer.inlayHints.closureReturnTypeHints.enable]]rust-analyzer.inlayHints.closureReturnTypeHints.enable (default: `false`)::
+[[rust-analyzer.inlayHints.reborrowHints]]rust-analyzer.inlayHints.reborrowHints (default: `false`)::
 +
 --
-Whether to show inlay type hints for return types of closures with blocks.
+Whether to show inlay type hints for compiler inserted reborrows.
 --
 [[rust-analyzer.inlayHints.lifetimeElisionHints.enable]]rust-analyzer.inlayHints.lifetimeElisionHints.enable (default: `"never"`)::
 +
@@ -354,41 +400,10 @@ Whether to show inlay type hints for elided lifetimes in function signatures.
 --
 Whether to prefer using parameter names as the name for elided lifetime hints if possible.
 --
-[[rust-analyzer.inlayHints.maxLength]]rust-analyzer.inlayHints.maxLength (default: `25`)::
-+
---
-Maximum length for inlay hints. Set to null to have an unlimited length.
---
-[[rust-analyzer.inlayHints.parameterHints.enable]]rust-analyzer.inlayHints.parameterHints.enable (default: `true`)::
-+
---
-Whether to show function parameter name inlay hints at the call
-site.
---
-[[rust-analyzer.inlayHints.reborrowHints.enable]]rust-analyzer.inlayHints.reborrowHints.enable (default: `false`)::
-+
---
-Whether to show inlay type hints for compiler inserted reborrows.
---
-[[rust-analyzer.inlayHints.renderColons]]rust-analyzer.inlayHints.renderColons (default: `true`)::
-+
---
-Whether to render trailing colons for parameter hints, and trailing colons for parameter hints.
---
-[[rust-analyzer.inlayHints.typeHints.enable]]rust-analyzer.inlayHints.typeHints.enable (default: `true`)::
-+
---
-Whether to show inlay type hints for variables.
---
-[[rust-analyzer.inlayHints.typeHints.hideNamedConstructor]]rust-analyzer.inlayHints.typeHints.hideNamedConstructor (default: `false`)::
-+
---
-Whether to hide inlay type hints for constructors.
---
-[[rust-analyzer.joinLines.joinAssignments]]rust-analyzer.joinLines.joinAssignments (default: `true`)::
+[[rust-analyzer.inlayHints.hideNamedConstructorHints]]rust-analyzer.inlayHints.hideNamedConstructorHints (default: `false`)::
 +
 --
-Join lines merges consecutive declaration and initialization of an assignment.
+Whether to hide inlay hints for constructors.
 --
 [[rust-analyzer.joinLines.joinElseIf]]rust-analyzer.joinLines.joinElseIf (default: `true`)::
 +
@@ -405,7 +420,12 @@ Join lines removes trailing commas.
 --
 Join lines unwraps trivial blocks.
 --
-[[rust-analyzer.lens.debug.enable]]rust-analyzer.lens.debug.enable (default: `true`)::
+[[rust-analyzer.joinLines.joinAssignments]]rust-analyzer.joinLines.joinAssignments (default: `true`)::
++
+--
+Join lines merges consecutive declaration and initialization of an assignment.
+--
+[[rust-analyzer.lens.debug]]rust-analyzer.lens.debug (default: `true`)::
 +
 --
 Whether to show `Debug` lens. Only applies when
@@ -416,47 +436,41 @@ Whether to show `Debug` lens. Only applies when
 --
 Whether to show CodeLens in Rust files.
 --
-[[rust-analyzer.lens.forceCustomCommands]]rust-analyzer.lens.forceCustomCommands (default: `true`)::
-+
---
-Internal config: use custom client-side commands even when the
-client doesn't set the corresponding capability.
---
-[[rust-analyzer.lens.implementations.enable]]rust-analyzer.lens.implementations.enable (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.references.adt.enable]]rust-analyzer.lens.references.adt.enable (default: `false`)::
+[[rust-analyzer.lens.run]]rust-analyzer.lens.run (default: `true`)::
 +
 --
-Whether to show `References` lens for Struct, Enum, and Union.
-Only applies when `#rust-analyzer.lens.enable#` is set.
+Whether to show `Run` lens. Only applies when
+`#rust-analyzer.lens.enable#` is set.
 --
-[[rust-analyzer.lens.references.enumVariant.enable]]rust-analyzer.lens.references.enumVariant.enable (default: `false`)::
+[[rust-analyzer.lens.methodReferences]]rust-analyzer.lens.methodReferences (default: `false`)::
 +
 --
-Whether to show `References` lens for Enum Variants.
-Only applies when `#rust-analyzer.lens.enable#` is set.
+Whether to show `Method References` lens. Only applies when
+`#rust-analyzer.lens.enable#` is set.
 --
-[[rust-analyzer.lens.references.method.enable]]rust-analyzer.lens.references.method.enable (default: `false`)::
+[[rust-analyzer.lens.references]]rust-analyzer.lens.references (default: `false`)::
 +
 --
-Whether to show `Method References` lens. Only applies when
-`#rust-analyzer.lens.enable#` is set.
+Whether to show `References` lens for Struct, Enum, Union and Trait.
+Only applies when `#rust-analyzer.lens.enable#` is set.
 --
-[[rust-analyzer.lens.references.trait.enable]]rust-analyzer.lens.references.trait.enable (default: `false`)::
+[[rust-analyzer.lens.enumVariantReferences]]rust-analyzer.lens.enumVariantReferences (default: `false`)::
 +
 --
-Whether to show `References` lens for Trait.
+Whether to show `References` lens for Enum Variants.
 Only applies when `#rust-analyzer.lens.enable#` is set.
 --
-[[rust-analyzer.lens.run.enable]]rust-analyzer.lens.run.enable (default: `true`)::
+[[rust-analyzer.lens.forceCustomCommands]]rust-analyzer.lens.forceCustomCommands (default: `true`)::
 +
 --
-Whether to show `Run` lens. Only applies when
-`#rust-analyzer.lens.enable#` is set.
+Internal config: use custom client-side commands even when the
+client doesn't set the corresponding capability.
 --
 [[rust-analyzer.linkedProjects]]rust-analyzer.linkedProjects (default: `[]`)::
 +
@@ -467,7 +481,7 @@ of projects.
 Elements must be paths pointing to `Cargo.toml`,
 `rust-project.json`, or JSON objects in `rust-project.json` format.
 --
-[[rust-analyzer.lru.capacity]]rust-analyzer.lru.capacity (default: `null`)::
+[[rust-analyzer.lruCapacity]]rust-analyzer.lruCapacity (default: `null`)::
 +
 --
 Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.
@@ -477,25 +491,21 @@ Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.
 --
 Whether to show `can't find Cargo.toml` error message.
 --
-[[rust-analyzer.primeCaches.enable]]rust-analyzer.primeCaches.enable (default: `true`)::
-+
---
-Warm up caches on project load.
---
 [[rust-analyzer.primeCaches.numThreads]]rust-analyzer.primeCaches.numThreads (default: `0`)::
 +
 --
 How many worker threads to to handle priming caches. The default `0` means to pick automatically.
 --
-[[rust-analyzer.procMacro.attributes.enable]]rust-analyzer.procMacro.attributes.enable (default: `true`)::
+[[rust-analyzer.procMacro.enable]]rust-analyzer.procMacro.enable (default: `true`)::
 +
 --
-Expand attribute macros. Requires `#rust-analyzer.procMacro.enable#` to be set.
+Enable support for procedural macros, implies `#rust-analyzer.cargo.runBuildScripts#`.
 --
-[[rust-analyzer.procMacro.enable]]rust-analyzer.procMacro.enable (default: `true`)::
+[[rust-analyzer.procMacro.server]]rust-analyzer.procMacro.server (default: `null`)::
 +
 --
-Enable support for procedural macros, implies `#rust-analyzer.cargo.buildScripts.enable#`.
+Internal config, path to proc-macro server executable (typically,
+this is rust-analyzer itself, but we override this in tests).
 --
 [[rust-analyzer.procMacro.ignored]]rust-analyzer.procMacro.ignored (default: `{}`)::
 +
@@ -504,24 +514,18 @@ These proc-macros will be ignored when trying to expand them.
 
 This config takes a map of crate names with the exported proc-macro names to ignore as values.
 --
-[[rust-analyzer.procMacro.server]]rust-analyzer.procMacro.server (default: `null`)::
-+
---
-Internal config, path to proc-macro server executable (typically,
-this is rust-analyzer itself, but we override this in tests).
---
-[[rust-analyzer.runnables.command]]rust-analyzer.runnables.command (default: `null`)::
+[[rust-analyzer.runnables.overrideCargo]]rust-analyzer.runnables.overrideCargo (default: `null`)::
 +
 --
 Command to be executed instead of 'cargo' for runnables.
 --
-[[rust-analyzer.runnables.extraArgs]]rust-analyzer.runnables.extraArgs (default: `[]`)::
+[[rust-analyzer.runnables.cargoExtraArgs]]rust-analyzer.runnables.cargoExtraArgs (default: `[]`)::
 +
 --
 Additional arguments to be passed to cargo for runnables such as
 tests or binaries. For example, it may be `--release`.
 --
-[[rust-analyzer.rustc.source]]rust-analyzer.rustc.source (default: `null`)::
+[[rust-analyzer.rustcSource]]rust-analyzer.rustcSource (default: `null`)::
 +
 --
 Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private
@@ -544,31 +548,17 @@ Additional arguments to `rustfmt`.
 Advanced option, fully override the command rust-analyzer uses for
 formatting.
 --
-[[rust-analyzer.rustfmt.rangeFormatting.enable]]rust-analyzer.rustfmt.rangeFormatting.enable (default: `false`)::
+[[rust-analyzer.rustfmt.enableRangeFormatting]]rust-analyzer.rustfmt.enableRangeFormatting (default: `false`)::
 +
 --
 Enables the use of rustfmt's unstable range formatting command for the
 `textDocument/rangeFormatting` request. The rustfmt option is unstable and only
 available on a nightly build.
 --
-[[rust-analyzer.semanticHighlighting.strings.enable]]rust-analyzer.semanticHighlighting.strings.enable (default: `true`)::
-+
---
-Use semantic tokens for strings.
-
-In some editors (e.g. vscode) semantic tokens override other highlighting grammars.
-By disabling semantic tokens for strings, other grammars can be used to highlight
-their contents.
---
-[[rust-analyzer.signatureInfo.detail]]rust-analyzer.signatureInfo.detail (default: `"full"`)::
-+
---
-Show full signature of the callable. Only shows parameters if disabled.
---
-[[rust-analyzer.signatureInfo.documentation.enable]]rust-analyzer.signatureInfo.documentation.enable (default: `true`)::
+[[rust-analyzer.workspace.symbol.search.scope]]rust-analyzer.workspace.symbol.search.scope (default: `"workspace"`)::
 +
 --
-Show documentation.
+Workspace symbol search scope.
 --
 [[rust-analyzer.workspace.symbol.search.kind]]rust-analyzer.workspace.symbol.search.kind (default: `"only_types"`)::
 +
@@ -582,8 +572,3 @@ Limits the number of items returned from a workspace symbol search (Defaults to
 Some clients like vs-code issue new searches on result filtering and don't require all results to be returned in the initial search.
 Other clients requires all results upfront and might require a higher limit.
 --
-[[rust-analyzer.workspace.symbol.search.scope]]rust-analyzer.workspace.symbol.search.scope (default: `"workspace"`)::
-+
---
-Workspace symbol search scope.
---
diff --git a/editors/code/package.json b/editors/code/package.json
index 515ecd0295..9f0f53196a 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -368,8 +368,8 @@
                     "markdownDescription": "Optional settings passed to the debug engine. Example: `{ \"lldb\": { \"terminal\":\"external\"} }`"
                 },
                 "$generated-start": {},
-                "rust-analyzer.assist.expressionFillDefault": {
-                    "markdownDescription": "Placeholder expression to use for missing expressions in assists.",
+                "rust-analyzer.assist.exprFillDefault": {
+                    "markdownDescription": "Placeholder for missing expressions in assists.",
                     "default": "todo",
                     "type": "string",
                     "enum": [
@@ -381,18 +381,98 @@
                         "Fill missing expressions with reasonable defaults, `new` or `default` constructors."
                     ]
                 },
+                "rust-analyzer.assist.importGranularity": {
+                    "markdownDescription": "How imports should be grouped into use statements.",
+                    "default": "crate",
+                    "type": "string",
+                    "enum": [
+                        "preserve",
+                        "crate",
+                        "module",
+                        "item"
+                    ],
+                    "enumDescriptions": [
+                        "Do not change the granularity of any imports and preserve the original structure written by the developer.",
+                        "Merge imports from the same crate into a single use statement. Conversely, imports from different crates are split into separate statements.",
+                        "Merge imports from the same module into a single use statement. Conversely, imports from different modules are split into separate statements.",
+                        "Flatten imports so that each has its own use statement."
+                    ]
+                },
+                "rust-analyzer.assist.importEnforceGranularity": {
+                    "markdownDescription": "Whether to enforce the import granularity setting for all files. If set to false rust-analyzer will try to keep import styles consistent per file.",
+                    "default": false,
+                    "type": "boolean"
+                },
+                "rust-analyzer.assist.importPrefix": {
+                    "markdownDescription": "The path structure for newly inserted paths to use.",
+                    "default": "plain",
+                    "type": "string",
+                    "enum": [
+                        "plain",
+                        "self",
+                        "crate"
+                    ],
+                    "enumDescriptions": [
+                        "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
+                        "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item. Prefixes `self` in front of the path if it starts with a module.",
+                        "Force import paths to be absolute by always starting them with `crate` or the extern crate name they come from."
+                    ]
+                },
+                "rust-analyzer.assist.importGroup": {
+                    "markdownDescription": "Group inserted imports by the [following order](https://rust-analyzer.github.io/manual.html#auto-import). Groups are separated by newlines.",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.assist.allowMergingIntoGlobImports": {
+                    "markdownDescription": "Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.cache.warmup": {
+                    "markdownDescription": "Warm up caches on project load.",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.callInfo.full": {
+                    "markdownDescription": "Show function name and docs in parameter hints.",
+                    "default": true,
+                    "type": "boolean"
+                },
                 "rust-analyzer.cargo.autoreload": {
                     "markdownDescription": "Automatically refresh project info via `cargo metadata` on\n`Cargo.toml` or `.cargo/config.toml` changes.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.cargo.buildScripts.enable": {
+                "rust-analyzer.cargo.allFeatures": {
+                    "markdownDescription": "Activate all available features (`--all-features`).",
+                    "default": false,
+                    "type": "boolean"
+                },
+                "rust-analyzer.cargo.unsetTest": {
+                    "markdownDescription": "Unsets `#[cfg(test)]` for the specified crates.",
+                    "default": [
+                        "core"
+                    ],
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "rust-analyzer.cargo.features": {
+                    "markdownDescription": "List of features to activate.",
+                    "default": [],
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "rust-analyzer.cargo.runBuildScripts": {
                     "markdownDescription": "Run build scripts (`build.rs`) for more precise code analysis.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.cargo.buildScripts.overrideCommand": {
-                    "markdownDescription": "Override the command rust-analyzer uses to run build scripts and\nbuild procedural macros. The command is required to output json\nand should therefor include `--message-format=json` or a similar\noption.\n\nBy default, a cargo invocation will be constructed for the configured\ntargets and features, with the following base command line:\n\n```bash\ncargo check --quiet --workspace --message-format=json --all-targets\n```\n.",
+                "rust-analyzer.cargo.runBuildScriptsCommand": {
+                    "markdownDescription": "Advanced option, fully override the command rust-analyzer uses to\nrun build scripts and build procedural macros. The command should\ninclude `--message-format=json` or a similar option.",
                     "default": null,
                     "type": [
                         "null",
@@ -402,56 +482,42 @@
                         "type": "string"
                     }
                 },
-                "rust-analyzer.cargo.buildScripts.useRustcWrapper": {
+                "rust-analyzer.cargo.useRustcWrapperForBuildScripts": {
                     "markdownDescription": "Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to\navoid compiling unnecessary things.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.cargo.features": {
-                    "markdownDescription": "List of features to activate.\n\nSet this to `\"all\"` to pass `--all-features` to cargo.",
-                    "default": [],
-                    "type": [
-                        "string",
-                        "array"
-                    ],
-                    "items": {
-                        "type": "string"
-                    },
-                    "enum": [
-                        "all"
-                    ],
-                    "enumDescriptions": [
-                        "Pass `--all-features` to cargo"
-                    ]
-                },
                 "rust-analyzer.cargo.noDefaultFeatures": {
-                    "markdownDescription": "Whether to pass `--no-default-features` to cargo.",
+                    "markdownDescription": "Do not activate the `default` feature.",
                     "default": false,
                     "type": "boolean"
                 },
+                "rust-analyzer.cargo.target": {
+                    "markdownDescription": "Compilation target (target triple).",
+                    "default": null,
+                    "type": [
+                        "null",
+                        "string"
+                    ]
+                },
                 "rust-analyzer.cargo.noSysroot": {
                     "markdownDescription": "Internal config for debugging, disables loading of sysroot crates.",
                     "default": false,
                     "type": "boolean"
                 },
-                "rust-analyzer.cargo.target": {
-                    "markdownDescription": "Compilation target override (target triple).",
+                "rust-analyzer.checkOnSave.enable": {
+                    "markdownDescription": "Run specified `cargo check` command for diagnostics on save.",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.checkOnSave.allFeatures": {
+                    "markdownDescription": "Check with all features (`--all-features`).\nDefaults to `#rust-analyzer.cargo.allFeatures#`.",
                     "default": null,
                     "type": [
                         "null",
-                        "string"
+                        "boolean"
                     ]
                 },
-                "rust-analyzer.cargo.unsetTest": {
-                    "markdownDescription": "Unsets `#[cfg(test)]` for the specified crates.",
-                    "default": [
-                        "core"
-                    ],
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    }
-                },
                 "rust-analyzer.checkOnSave.allTargets": {
                     "markdownDescription": "Check all targets and tests (`--all-targets`).",
                     "default": true,
@@ -462,10 +528,21 @@
                     "default": "check",
                     "type": "string"
                 },
-                "rust-analyzer.checkOnSave.enable": {
-                    "markdownDescription": "Run specified `cargo check` command for diagnostics on save.",
-                    "default": true,
-                    "type": "boolean"
+                "rust-analyzer.checkOnSave.noDefaultFeatures": {
+                    "markdownDescription": "Do not activate the `default` feature.",
+                    "default": null,
+                    "type": [
+                        "null",
+                        "boolean"
+                    ]
+                },
+                "rust-analyzer.checkOnSave.target": {
+                    "markdownDescription": "Check for a specific target. Defaults to\n`#rust-analyzer.cargo.target#`.",
+                    "default": null,
+                    "type": [
+                        "null",
+                        "string"
+                    ]
                 },
                 "rust-analyzer.checkOnSave.extraArgs": {
                     "markdownDescription": "Extra arguments for `cargo check`.",
@@ -476,33 +553,18 @@
                     }
                 },
                 "rust-analyzer.checkOnSave.features": {
-                    "markdownDescription": "List of features to activate. Defaults to\n`#rust-analyzer.cargo.features#`.\n\nSet to `\"all\"` to pass `--all-features` to cargo.",
+                    "markdownDescription": "List of features to activate. Defaults to\n`#rust-analyzer.cargo.features#`.",
                     "default": null,
                     "type": [
-                        "string",
-                        "array",
-                        "null"
+                        "null",
+                        "array"
                     ],
                     "items": {
                         "type": "string"
-                    },
-                    "enum": [
-                        "all"
-                    ],
-                    "enumDescriptions": [
-                        "Pass `--all-features` to cargo"
-                    ]
-                },
-                "rust-analyzer.checkOnSave.noDefaultFeatures": {
-                    "markdownDescription": "Do not activate the `default` feature.",
-                    "default": null,
-                    "type": [
-                        "null",
-                        "boolean"
-                    ]
+                    }
                 },
                 "rust-analyzer.checkOnSave.overrideCommand": {
-                    "markdownDescription": "Override the command rust-analyzer uses to    run build scripts and\nbuild procedural macros. The command is required to output json\nand should therefor include `--message-format=json` or a similar\noption.\n\nAn example command would be:\n\n```bash\ncargo check --workspace --message-format=json --all-targets\n```\n.",
+                    "markdownDescription": "Advanced option, fully override the command rust-analyzer uses for\nchecking. The command should include `--message-format=json` or\nsimilar option.",
                     "default": null,
                     "type": [
                         "null",
@@ -512,51 +574,17 @@
                         "type": "string"
                     }
                 },
-                "rust-analyzer.checkOnSave.target": {
-                    "markdownDescription": "Check for a specific target. Defaults to\n`#rust-analyzer.cargo.target#`.",
-                    "default": null,
-                    "type": [
-                        "null",
-                        "string"
-                    ]
-                },
-                "rust-analyzer.completion.autoimport.enable": {
-                    "markdownDescription": "Toggles the additional completions that automatically add imports when completed.\nNote that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.",
-                    "default": true,
-                    "type": "boolean"
-                },
-                "rust-analyzer.completion.autoself.enable": {
-                    "markdownDescription": "Toggles the additional completions that automatically show method calls and field accesses\nwith `self` prefixed to them when inside a method.",
+                "rust-analyzer.completion.addCallArgumentSnippets": {
+                    "markdownDescription": "Whether to add argument snippets when completing functions.\nOnly applies when `#rust-analyzer.completion.addCallParenthesis#` is set.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.completion.callable.snippets": {
-                    "markdownDescription": "Whether to add parenthesis and argument snippets when completing function.",
-                    "default": "fill_arguments",
-                    "type": [
-                        "string",
-                        "null"
-                    ],
-                    "enum": [
-                        "fill_arguments",
-                        "add_parentheses"
-                    ],
-                    "enumDescriptions": [
-                        "Add call parentheses and pre-fill arguments",
-                        "Add call parentheses"
-                    ]
-                },
-                "rust-analyzer.completion.postfix.enable": {
-                    "markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc.",
+                "rust-analyzer.completion.addCallParenthesis": {
+                    "markdownDescription": "Whether to add parenthesis when completing functions.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.completion.privateEditable.enable": {
-                    "markdownDescription": "Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.",
-                    "default": false,
-                    "type": "boolean"
-                },
-                "rust-analyzer.completion.snippets.custom": {
+                "rust-analyzer.completion.snippets": {
                     "markdownDescription": "Custom completion snippets.",
                     "default": {
                         "Arc::new": {
@@ -601,25 +629,45 @@
                     },
                     "type": "object"
                 },
-                "rust-analyzer.diagnostics.disabled": {
-                    "markdownDescription": "List of rust-analyzer diagnostics to disable.",
-                    "default": [],
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    },
-                    "uniqueItems": true
+                "rust-analyzer.completion.postfix.enable": {
+                    "markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc.",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.completion.autoimport.enable": {
+                    "markdownDescription": "Toggles the additional completions that automatically add imports when completed.\nNote that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.completion.autoself.enable": {
+                    "markdownDescription": "Toggles the additional completions that automatically show method calls and field accesses\nwith `self` prefixed to them when inside a method.",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.completion.privateEditable.enable": {
+                    "markdownDescription": "Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.",
+                    "default": false,
+                    "type": "boolean"
                 },
                 "rust-analyzer.diagnostics.enable": {
                     "markdownDescription": "Whether to show native rust-analyzer diagnostics.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.diagnostics.experimental.enable": {
+                "rust-analyzer.diagnostics.enableExperimental": {
                     "markdownDescription": "Whether to show experimental rust-analyzer diagnostics that might\nhave more false positives than usual.",
                     "default": false,
                     "type": "boolean"
                 },
+                "rust-analyzer.diagnostics.disabled": {
+                    "markdownDescription": "List of rust-analyzer diagnostics to disable.",
+                    "default": [],
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "uniqueItems": true
+                },
                 "rust-analyzer.diagnostics.remapPrefix": {
                     "markdownDescription": "Map of prefixes to be substituted when parsing diagnostic file paths.\nThis should be the reverse mapping of what is passed to `rustc` as `--remap-path-prefix`.",
                     "default": {},
@@ -641,6 +689,16 @@
                         "type": "string"
                     }
                 },
+                "rust-analyzer.experimental.procAttrMacros": {
+                    "markdownDescription": "Expand attribute macros.",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.files.watcher": {
+                    "markdownDescription": "Controls file watching implementation.",
+                    "default": "client",
+                    "type": "string"
+                },
                 "rust-analyzer.files.excludeDirs": {
                     "markdownDescription": "These directories will be ignored by rust-analyzer. They are\nrelative to the workspace root, and globs are not supported. You may\nalso need to add the folders to Code's `files.watcherExclude`.",
                     "default": [],
@@ -649,135 +707,114 @@
                         "type": "string"
                     }
                 },
-                "rust-analyzer.files.watcher": {
-                    "markdownDescription": "Controls file watching implementation.",
-                    "default": "client",
-                    "type": "string"
+                "rust-analyzer.highlightRelated.references": {
+                    "markdownDescription": "Enables highlighting of related references while hovering your mouse above any identifier.",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.highlightRelated.exitPoints": {
+                    "markdownDescription": "Enables highlighting of all exit points while hovering your mouse above any `return`, `?`, or return type arrow (`->`).",
+                    "default": true,
+                    "type": "boolean"
+                },
+                "rust-analyzer.highlightRelated.breakPoints": {
+                    "markdownDescription": "Enables highlighting of related references while hovering your mouse `break`, `loop`, `while`, or `for` keywords.",
+                    "default": true,
+                    "type": "boolean"
                 },
-                "rust-analyzer.highlightRelated.breakPoints.enable": {
-                    "markdownDescription": "Enables highlighting of related references while the cursor is on `break`, `loop`, `while`, or `for` keywords.",
+                "rust-analyzer.highlightRelated.yieldPoints": {
+                    "markdownDescription": "Enables highlighting of all break points for a loop or block context while hovering your mouse above any `async` or `await` keywords.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.highlightRelated.exitPoints.enable": {
-                    "markdownDescription": "Enables highlighting of all exit points while the cursor is on any `return`, `?`, `fn`, or return type arrow (`->`).",
+                "rust-analyzer.highlighting.strings": {
+                    "markdownDescription": "Use semantic tokens for strings.\n\nIn some editors (e.g. vscode) semantic tokens override other highlighting grammars.\nBy disabling semantic tokens for strings, other grammars can be used to highlight\ntheir contents.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.highlightRelated.references.enable": {
-                    "markdownDescription": "Enables highlighting of related references while the cursor is on any identifier.",
+                "rust-analyzer.hover.documentation": {
+                    "markdownDescription": "Whether to show documentation on hover.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.highlightRelated.yieldPoints.enable": {
-                    "markdownDescription": "Enables highlighting of all break points for a loop or block context while the cursor is on any `async` or `await` keywords.",
+                "rust-analyzer.hover.linksInHover": {
+                    "markdownDescription": "Use markdown syntax for links in hover.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.hover.actions.debug.enable": {
+                "rust-analyzer.hoverActions.debug": {
                     "markdownDescription": "Whether to show `Debug` action. Only applies when\n`#rust-analyzer.hoverActions.enable#` is set.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.hover.actions.enable": {
+                "rust-analyzer.hoverActions.enable": {
                     "markdownDescription": "Whether to show HoverActions in Rust files.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.hover.actions.gotoTypeDef.enable": {
+                "rust-analyzer.hoverActions.gotoTypeDef": {
                     "markdownDescription": "Whether to show `Go to Type Definition` action. Only applies when\n`#rust-analyzer.hoverActions.enable#` is set.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.hover.actions.implementations.enable": {
+                "rust-analyzer.hoverActions.implementations": {
                     "markdownDescription": "Whether to show `Implementations` action. Only applies when\n`#rust-analyzer.hoverActions.enable#` is set.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.hover.actions.references.enable": {
+                "rust-analyzer.hoverActions.references": {
                     "markdownDescription": "Whether to show `References` action. Only applies when\n`#rust-analyzer.hoverActions.enable#` is set.",
                     "default": false,
                     "type": "boolean"
                 },
-                "rust-analyzer.hover.actions.run.enable": {
+                "rust-analyzer.hoverActions.run": {
                     "markdownDescription": "Whether to show `Run` action. Only applies when\n`#rust-analyzer.hoverActions.enable#` is set.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.hover.documentation.enable": {
-                    "markdownDescription": "Whether to show documentation on hover.",
-                    "default": true,
-                    "type": "boolean"
-                },
-                "rust-analyzer.hover.links.enable": {
-                    "markdownDescription": "Use markdown syntax for links in hover.",
+                "rust-analyzer.inlayHints.renderColons": {
+                    "markdownDescription": "Whether to render trailing colons for parameter hints, and trailing colons for parameter hints.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.imports.granularity.enforce": {
-                    "markdownDescription": "Whether to enforce the import granularity setting for all files. If set to false rust-analyzer will try to keep import styles consistent per file.",
-                    "default": false,
-                    "type": "boolean"
-                },
-                "rust-analyzer.imports.granularity.group": {
-                    "markdownDescription": "How imports should be grouped into use statements.",
-                    "default": "crate",
-                    "type": "string",
-                    "enum": [
-                        "preserve",
-                        "crate",
-                        "module",
-                        "item"
+                "rust-analyzer.inlayHints.maxLength": {
+                    "markdownDescription": "Maximum length for inlay hints. Set to null to have an unlimited length.",
+                    "default": 25,
+                    "type": [
+                        "null",
+                        "integer"
                     ],
-                    "enumDescriptions": [
-                        "Do not change the granularity of any imports and preserve the original structure written by the developer.",
-                        "Merge imports from the same crate into a single use statement. Conversely, imports from different crates are split into separate statements.",
-                        "Merge imports from the same module into a single use statement. Conversely, imports from different modules are split into separate statements.",
-                        "Flatten imports so that each has its own use statement."
-                    ]
+                    "minimum": 0
                 },
-                "rust-analyzer.imports.group.enable": {
-                    "markdownDescription": "Group inserted imports by the [following order](https://rust-analyzer.github.io/manual.html#auto-import). Groups are separated by newlines.",
+                "rust-analyzer.inlayHints.parameterHints": {
+                    "markdownDescription": "Whether to show function parameter name inlay hints at the call\nsite.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.imports.merge.glob": {
-                    "markdownDescription": "Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.",
+                "rust-analyzer.inlayHints.typeHints": {
+                    "markdownDescription": "Whether to show inlay type hints for variables.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.imports.prefix": {
-                    "markdownDescription": "The path structure for newly inserted paths to use.",
-                    "default": "plain",
-                    "type": "string",
-                    "enum": [
-                        "plain",
-                        "self",
-                        "crate"
-                    ],
-                    "enumDescriptions": [
-                        "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
-                        "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item. Prefixes `self` in front of the path if it starts with a module.",
-                        "Force import paths to be absolute by always starting them with `crate` or the extern crate name they come from."
-                    ]
-                },
-                "rust-analyzer.inlayHints.chainingHints.enable": {
+                "rust-analyzer.inlayHints.chainingHints": {
                     "markdownDescription": "Whether to show inlay type hints for method chains.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.inlayHints.closureReturnTypeHints.enable": {
+                "rust-analyzer.inlayHints.closureReturnTypeHints": {
                     "markdownDescription": "Whether to show inlay type hints for return types of closures with blocks.",
                     "default": false,
                     "type": "boolean"
                 },
+                "rust-analyzer.inlayHints.reborrowHints": {
+                    "markdownDescription": "Whether to show inlay type hints for compiler inserted reborrows.",
+                    "default": false,
+                    "type": "boolean"
+                },
                 "rust-analyzer.inlayHints.lifetimeElisionHints.enable": {
                     "markdownDescription": "Whether to show inlay type hints for elided lifetimes in function signatures.",
                     "default": "never",
-                    "type": [
-                        "string",
-                        "boolean"
-                    ],
+                    "type": "string",
                     "enum": [
                         "always",
                         "never",
@@ -794,45 +831,11 @@
                     "default": false,
                     "type": "boolean"
                 },
-                "rust-analyzer.inlayHints.maxLength": {
-                    "markdownDescription": "Maximum length for inlay hints. Set to null to have an unlimited length.",
-                    "default": 25,
-                    "type": [
-                        "null",
-                        "integer"
-                    ],
-                    "minimum": 0
-                },
-                "rust-analyzer.inlayHints.parameterHints.enable": {
-                    "markdownDescription": "Whether to show function parameter name inlay hints at the call\nsite.",
-                    "default": true,
-                    "type": "boolean"
-                },
-                "rust-analyzer.inlayHints.reborrowHints.enable": {
-                    "markdownDescription": "Whether to show inlay type hints for compiler inserted reborrows.",
-                    "default": false,
-                    "type": "boolean"
-                },
-                "rust-analyzer.inlayHints.renderColons": {
-                    "markdownDescription": "Whether to render trailing colons for parameter hints, and trailing colons for parameter hints.",
-                    "default": true,
-                    "type": "boolean"
-                },
-                "rust-analyzer.inlayHints.typeHints.enable": {
-                    "markdownDescription": "Whether to show inlay type hints for variables.",
-                    "default": true,
-                    "type": "boolean"
-                },
-                "rust-analyzer.inlayHints.typeHints.hideNamedConstructor": {
-                    "markdownDescription": "Whether to hide inlay type hints for constructors.",
+                "rust-analyzer.inlayHints.hideNamedConstructorHints": {
+                    "markdownDescription": "Whether to hide inlay hints for constructors.",
                     "default": false,
                     "type": "boolean"
                 },
-                "rust-analyzer.joinLines.joinAssignments": {
-                    "markdownDescription": "Join lines merges consecutive declaration and initialization of an assignment.",
-                    "default": true,
-                    "type": "boolean"
-                },
                 "rust-analyzer.joinLines.joinElseIf": {
                     "markdownDescription": "Join lines inserts else between consecutive ifs.",
                     "default": true,
@@ -848,48 +851,48 @@
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.lens.debug.enable": {
-                    "markdownDescription": "Whether to show `Debug` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
+                "rust-analyzer.joinLines.joinAssignments": {
+                    "markdownDescription": "Join lines merges consecutive declaration and initialization of an assignment.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.lens.enable": {
-                    "markdownDescription": "Whether to show CodeLens in Rust files.",
+                "rust-analyzer.lens.debug": {
+                    "markdownDescription": "Whether to show `Debug` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.lens.forceCustomCommands": {
-                    "markdownDescription": "Internal config: use custom client-side commands even when the\nclient doesn't set the corresponding capability.",
+                "rust-analyzer.lens.enable": {
+                    "markdownDescription": "Whether to show CodeLens in Rust files.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.lens.implementations.enable": {
+                "rust-analyzer.lens.implementations": {
                     "markdownDescription": "Whether to show `Implementations` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.lens.references.adt.enable": {
-                    "markdownDescription": "Whether to show `References` lens for Struct, Enum, and Union.\nOnly applies when `#rust-analyzer.lens.enable#` is set.",
-                    "default": false,
+                "rust-analyzer.lens.run": {
+                    "markdownDescription": "Whether to show `Run` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
+                    "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.lens.references.enumVariant.enable": {
-                    "markdownDescription": "Whether to show `References` lens for Enum Variants.\nOnly applies when `#rust-analyzer.lens.enable#` is set.",
+                "rust-analyzer.lens.methodReferences": {
+                    "markdownDescription": "Whether to show `Method References` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
                     "default": false,
                     "type": "boolean"
                 },
-                "rust-analyzer.lens.references.method.enable": {
-                    "markdownDescription": "Whether to show `Method References` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
+                "rust-analyzer.lens.references": {
+                    "markdownDescription": "Whether to show `References` lens for Struct, Enum, Union and Trait.\nOnly applies when `#rust-analyzer.lens.enable#` is set.",
                     "default": false,
                     "type": "boolean"
                 },
-                "rust-analyzer.lens.references.trait.enable": {
-                    "markdownDescription": "Whether to show `References` lens for Trait.\nOnly applies when `#rust-analyzer.lens.enable#` is set.",
+                "rust-analyzer.lens.enumVariantReferences": {
+                    "markdownDescription": "Whether to show `References` lens for Enum Variants.\nOnly applies when `#rust-analyzer.lens.enable#` is set.",
                     "default": false,
                     "type": "boolean"
                 },
-                "rust-analyzer.lens.run.enable": {
-                    "markdownDescription": "Whether to show `Run` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
+                "rust-analyzer.lens.forceCustomCommands": {
+                    "markdownDescription": "Internal config: use custom client-side commands even when the\nclient doesn't set the corresponding capability.",
                     "default": true,
                     "type": "boolean"
                 },
@@ -904,7 +907,7 @@
                         ]
                     }
                 },
-                "rust-analyzer.lru.capacity": {
+                "rust-analyzer.lruCapacity": {
                     "markdownDescription": "Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.",
                     "default": null,
                     "type": [
@@ -918,11 +921,6 @@
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.primeCaches.enable": {
-                    "markdownDescription": "Warm up caches on project load.",
-                    "default": true,
-                    "type": "boolean"
-                },
                 "rust-analyzer.primeCaches.numThreads": {
                     "markdownDescription": "How many worker threads to to handle priming caches. The default `0` means to pick automatically.",
                     "default": 0,
@@ -930,21 +928,11 @@
                     "minimum": 0,
                     "maximum": 255
                 },
-                "rust-analyzer.procMacro.attributes.enable": {
-                    "markdownDescription": "Expand attribute macros. Requires `#rust-analyzer.procMacro.enable#` to be set.",
-                    "default": true,
-                    "type": "boolean"
-                },
                 "rust-analyzer.procMacro.enable": {
-                    "markdownDescription": "Enable support for procedural macros, implies `#rust-analyzer.cargo.buildScripts.enable#`.",
+                    "markdownDescription": "Enable support for procedural macros, implies `#rust-analyzer.cargo.runBuildScripts#`.",
                     "default": true,
                     "type": "boolean"
                 },
-                "rust-analyzer.procMacro.ignored": {
-                    "markdownDescription": "These proc-macros will be ignored when trying to expand them.\n\nThis config takes a map of crate names with the exported proc-macro names to ignore as values.",
-                    "default": {},
-                    "type": "object"
-                },
                 "rust-analyzer.procMacro.server": {
                     "markdownDescription": "Internal config, path to proc-macro server executable (typically,\nthis is rust-analyzer itself, but we override this in tests).",
                     "default": null,
@@ -953,7 +941,12 @@
                         "string"
                     ]
                 },
-                "rust-analyzer.runnables.command": {
+                "rust-analyzer.procMacro.ignored": {
+                    "markdownDescription": "These proc-macros will be ignored when trying to expand them.\n\nThis config takes a map of crate names with the exported proc-macro names to ignore as values.",
+                    "default": {},
+                    "type": "object"
+                },
+                "rust-analyzer.runnables.overrideCargo": {
                     "markdownDescription": "Command to be executed instead of 'cargo' for runnables.",
                     "default": null,
                     "type": [
@@ -961,7 +954,7 @@
                         "string"
                     ]
                 },
-                "rust-analyzer.runnables.extraArgs": {
+                "rust-analyzer.runnables.cargoExtraArgs": {
                     "markdownDescription": "Additional arguments to be passed to cargo for runnables such as\ntests or binaries. For example, it may be `--release`.",
                     "default": [],
                     "type": "array",
@@ -969,7 +962,7 @@
                         "type": "string"
                     }
                 },
-                "rust-analyzer.rustc.source": {
+                "rust-analyzer.rustcSource": {
                     "markdownDescription": "Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private\nprojects, or \"discover\" to try to automatically find it if the `rustc-dev` component\nis installed.\n\nAny project which uses rust-analyzer with the rustcPrivate\ncrates must set `[package.metadata.rust-analyzer] rustc_private=true` to use it.\n\nThis option does not take effect until rust-analyzer is restarted.",
                     "default": null,
                     "type": [
@@ -996,34 +989,24 @@
                         "type": "string"
                     }
                 },
-                "rust-analyzer.rustfmt.rangeFormatting.enable": {
+                "rust-analyzer.rustfmt.enableRangeFormatting": {
                     "markdownDescription": "Enables the use of rustfmt's unstable range formatting command for the\n`textDocument/rangeFormatting` request. The rustfmt option is unstable and only\navailable on a nightly build.",
                     "default": false,
                     "type": "boolean"
                 },
-                "rust-analyzer.semanticHighlighting.strings.enable": {
-                    "markdownDescription": "Use semantic tokens for strings.\n\nIn some editors (e.g. vscode) semantic tokens override other highlighting grammars.\nBy disabling semantic tokens for strings, other grammars can be used to highlight\ntheir contents.",
-                    "default": true,
-                    "type": "boolean"
-                },
-                "rust-analyzer.signatureInfo.detail": {
-                    "markdownDescription": "Show full signature of the callable. Only shows parameters if disabled.",
-                    "default": "full",
+                "rust-analyzer.workspace.symbol.search.scope": {
+                    "markdownDescription": "Workspace symbol search scope.",
+                    "default": "workspace",
                     "type": "string",
                     "enum": [
-                        "full",
-                        "parameters"
+                        "workspace",
+                        "workspace_and_dependencies"
                     ],
                     "enumDescriptions": [
-                        "Show the entire signature.",
-                        "Show only the parameters."
+                        "Search in current workspace only",
+                        "Search in current workspace and dependencies"
                     ]
                 },
-                "rust-analyzer.signatureInfo.documentation.enable": {
-                    "markdownDescription": "Show documentation.",
-                    "default": true,
-                    "type": "boolean"
-                },
                 "rust-analyzer.workspace.symbol.search.kind": {
                     "markdownDescription": "Workspace symbol search kind.",
                     "default": "only_types",
@@ -1043,19 +1026,6 @@
                     "type": "integer",
                     "minimum": 0
                 },
-                "rust-analyzer.workspace.symbol.search.scope": {
-                    "markdownDescription": "Workspace symbol search scope.",
-                    "default": "workspace",
-                    "type": "string",
-                    "enum": [
-                        "workspace",
-                        "workspace_and_dependencies"
-                    ],
-                    "enumDescriptions": [
-                        "Search in current workspace only",
-                        "Search in current workspace and dependencies"
-                    ]
-                },
                 "$generated-end": {}
             }
         },
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 99b72635d1..f7520f6c43 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -5,7 +5,6 @@ import * as Is from 'vscode-languageclient/lib/common/utils/is';
 import { assert } from './util';
 import { WorkspaceEdit } from 'vscode';
 import { Workspace } from './ctx';
-import { updateConfig } from './config';
 
 export interface Env {
     [name: string]: string;
@@ -25,7 +24,7 @@ function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownStri
     return result;
 }
 
-export async function createClient(serverPath: string, workspace: Workspace, extraEnv: Env): Promise<lc.LanguageClient> {
+export function createClient(serverPath: string, workspace: Workspace, extraEnv: Env): lc.LanguageClient {
     // '.' Is the fallback if no folder is open
     // TODO?: Workspace folders support Uri's (eg: file://test.txt).
     // It might be a good idea to test if the uri points to a file.
@@ -46,10 +45,6 @@ export async function createClient(serverPath: string, workspace: Workspace, ext
     );
 
     let initializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
-
-    // Update outdated user configs
-    await updateConfig(initializationOptions);
-
     if (workspace.kind === "Detached Files") {
         initializationOptions = { "detachedFiles": workspace.files.map(file => file.uri.fsPath), ...initializationOptions };
     }
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 5b650e1420..183521c10c 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -18,6 +18,7 @@ export class Config {
         "cargo",
         "procMacro",
         "files",
+        "highlighting",
         "lens", // works as lens.*
     ]
         .map(opt => `${this.rootSection}.${opt}`);
@@ -78,7 +79,7 @@ export class Config {
      * const nullableNum = vscode
      *  .workspace
      *  .getConfiguration
-     *  .getConfiguration("rust-analyzer")
+     *  .getConfiguration("rust-analyer")
      *  .get<number | null>(path)!;
      *
      * // What happens is that type of `nullableNum` is `number` but not `null | number`:
@@ -123,11 +124,11 @@ export class Config {
     get hoverActions() {
         return {
             enable: this.get<boolean>("hoverActions.enable"),
-            implementations: this.get<boolean>("hoverActions.implementations.enable"),
-            references: this.get<boolean>("hoverActions.references.enable"),
-            run: this.get<boolean>("hoverActions.run.enable"),
-            debug: this.get<boolean>("hoverActions.debug.enable"),
-            gotoTypeDef: this.get<boolean>("hoverActions.gotoTypeDef.enable"),
+            implementations: this.get<boolean>("hoverActions.implementations"),
+            references: this.get<boolean>("hoverActions.references"),
+            run: this.get<boolean>("hoverActions.run"),
+            debug: this.get<boolean>("hoverActions.debug"),
+            gotoTypeDef: this.get<boolean>("hoverActions.gotoTypeDef"),
         };
     }
 
@@ -135,77 +136,3 @@ export class Config {
         return this.package.releaseTag === NIGHTLY_TAG;
     }
 }
-
-export async function updateConfig(config: vscode.WorkspaceConfiguration) {
-    const renames = [
-        ["assist.allowMergingIntoGlobImports", "imports.merge.glob",],
-        ["assist.exprFillDefault", "assist.expressionFillDefault",],
-        ["assist.importEnforceGranularity", "imports.granularity.enforce",],
-        ["assist.importGranularity", "imports.granularity.group",],
-        ["assist.importMergeBehavior", "imports.granularity.group",],
-        ["assist.importMergeBehaviour", "imports.granularity.group",],
-        ["assist.importGroup", "imports.group.enable",],
-        ["assist.importPrefix", "imports.prefix",],
-        ["cache.warmup", "primeCaches.enable",],
-        ["cargo.loadOutDirsFromCheck", "cargo.buildScripts.enable",],
-        ["cargo.runBuildScripts", "cargo.runBuildScripts.overrideCommand",],
-        ["cargo.runBuildScriptsCommand", "cargo.runBuildScripts.overrideCommand",],
-        ["cargo.useRustcWrapperForBuildScripts", "cargo.runBuildScripts.useRustcWrapper",],
-        ["completion.snippets", "completion.snippets.custom",],
-        ["diagnostics.enableExperimental", "diagnostics.experimental.enable",],
-        ["experimental.procAttrMacros", "procMacro.attributes.enable",],
-        ["highlighting.strings", "semanticHighlighting.strings.enable",],
-        ["highlightRelated.breakPoints", "highlightRelated.breakPoints.enable",],
-        ["highlightRelated.exitPoints", "highlightRelated.exitPoints.enable",],
-        ["highlightRelated.yieldPoints", "highlightRelated.yieldPoints.enable",],
-        ["highlightRelated.references", "highlightRelated.references.enable",],
-        ["hover.documentation", "hover.documentation.enable",],
-        ["hover.linksInHover", "hover.links.enable",],
-        ["hoverActions.linksInHover", "hover.links.enable",],
-        ["hoverActions.debug", "hoverActions.debug.enable",],
-        ["hoverActions.enable", "hoverActions.enable.enable",],
-        ["hoverActions.gotoTypeDef", "hoverActions.gotoTypeDef.enable",],
-        ["hoverActions.implementations", "hoverActions.implementations.enable",],
-        ["hoverActions.references", "hoverActions.references.enable",],
-        ["hoverActions.run", "hoverActions.run.enable",],
-        ["inlayHints.chainingHints", "inlayHints.chainingHints.enable",],
-        ["inlayHints.closureReturnTypeHints", "inlayHints.closureReturnTypeHints.enable",],
-        ["inlayHints.hideNamedConstructorHints", "inlayHints.typeHints.hideNamedConstructorHints",],
-        ["inlayHints.parameterHints", "inlayHints.parameterHints.enable",],
-        ["inlayHints.reborrowHints", "inlayHints.reborrowHints.enable",],
-        ["inlayHints.typeHints", "inlayHints.typeHints.enable",],
-        ["lruCapacity", "lru.capacity",],
-        ["runnables.cargoExtraArgs", "runnables.extraArgs",],
-        ["runnables.overrideCargo", "runnables.command",],
-        ["rustcSource", "rustc.source",],
-        ["rustfmt.enableRangeFormatting", "rustfmt.rangeFormatting.enable"]
-    ];
-
-    for (const [oldKey, newKey] of renames) {
-        const inspect = config.inspect(oldKey);
-        if (inspect !== undefined) {
-            const valMatrix = [
-                { val: inspect.globalValue, langVal: inspect.globalLanguageValue, target: vscode.ConfigurationTarget.Global },
-                { val: inspect.workspaceFolderValue, langVal: inspect.workspaceFolderLanguageValue, target: vscode.ConfigurationTarget.WorkspaceFolder },
-                { val: inspect.workspaceValue, langVal: inspect.workspaceLanguageValue, target: vscode.ConfigurationTarget.Workspace }
-            ];
-            for (const { val, langVal, target } of valMatrix) {
-                const pred = (val: unknown) => {
-                    // some of the updates we do only append "enable" or "custom"
-                    // that means on the next run we would find these again, but as objects with
-                    // these properties causing us to destroy the config
-                    // so filter those already updated ones out
-                    return val !== undefined && !(typeof val === "object" && val !== null && (val.hasOwnProperty("enable") || val.hasOwnProperty("custom")));
-                };
-                if (pred(val)) {
-                    await config.update(newKey, val, target, false);
-                    await config.update(oldKey, undefined, target, false);
-                }
-                if (pred(langVal)) {
-                    await config.update(newKey, langVal, target, true);
-                    await config.update(oldKey, undefined, target, true);
-                }
-            }
-        }
-    }
-}
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 0c3e6810e9..666a4b6972 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -33,7 +33,7 @@ export class Ctx {
         serverPath: string,
         workspace: Workspace,
     ): Promise<Ctx> {
-        const client = await createClient(serverPath, workspace, config.serverExtraEnv);
+        const client = createClient(serverPath, workspace, config.serverExtraEnv);
 
         const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
         extCtx.subscriptions.push(statusBar);


Test patch:
diff --git a/crates/rust-analyzer/tests/slow-tests/main.rs b/crates/rust-analyzer/tests/slow-tests/main.rs
index 143b63e11c..147e8c141a 100644
--- a/crates/rust-analyzer/tests/slow-tests/main.rs
+++ b/crates/rust-analyzer/tests/slow-tests/main.rs
@@ -685,7 +685,7 @@ version = \"0.0.0\"
 #[test]
 fn out_dirs_check() {
     if skip_slow_tests() {
-        // return;
+        return;
     }
 
     let server = Project::with_fixture(
@@ -737,9 +737,7 @@ fn main() {
     )
     .with_config(serde_json::json!({
         "cargo": {
-            "buildScripts": {
-                "enable": true
-            },
+            "loadOutDirsFromCheck": true,
             "noSysroot": true,
         }
     }))
@@ -892,9 +890,7 @@ pub fn foo(_input: TokenStream) -> TokenStream {
     )
     .with_config(serde_json::json!({
         "cargo": {
-            "buildScripts": {
-                "enable": true
-            },
+            "loadOutDirsFromCheck": true,
             "noSysroot": true,
         },
         "procMacro": {
diff --git a/crates/rust-analyzer/tests/slow-tests/support.rs b/crates/rust-analyzer/tests/slow-tests/support.rs
index 36bffe3210..515cdfdc7c 100644
--- a/crates/rust-analyzer/tests/slow-tests/support.rs
+++ b/crates/rust-analyzer/tests/slow-tests/support.rs
@@ -36,9 +36,7 @@ impl<'a> Project<'a> {
                     // Loading standard library is costly, let's ignore it by default
                     "noSysroot": true,
                     // Can't use test binary as rustc wrapper.
-                    "buildScripts": {
-                        "useRustcWrapper": false
-                    },
+                    "useRustcWrapperForBuildScripts": false,
                 }
             }),
         }
@@ -139,7 +137,7 @@ impl<'a> Project<'a> {
             },
         );
         config.discovered_projects = Some(discovered_projects);
-        config.update(self.config).expect("invalid config");
+        let _ = config.update(self.config);
 
         Server::new(tmp_dir, config)
     }