Repository: rust-lang/rust-analyzer
Pull request #12204 (2022-05-10 13:02:37)

internal: Move keyword expressions to expr completions module


Patch:
diff --git a/crates/hir-def/src/builtin_attr.rs b/crates/hir-def/src/builtin_attr.rs
index 9aad996a84..3f43111fb1 100644
--- a/crates/hir-def/src/builtin_attr.rs
+++ b/crates/hir-def/src/builtin_attr.rs
@@ -274,7 +274,6 @@ pub const INERT_ATTRIBUTES: &[BuiltinAttribute] = &[
     ungated!(feature, CrateLevel, template!(List: "name1, name1, ...")),
     // FIXME(#14407) -- only looked at on-demand so we can't
     // guarantee they'll have already been checked.
-    // FIXME(jhpratt) remove this when #[rustc_deprecated] is fully removed from the compiler
     ungated!(
         rustc_deprecated, AssumedUsed,
         template!(List: r#"since = "version", reason = "...""#)
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/hir/src/lib.rs b/crates/hir/src/lib.rs
index 39f88937d6..496b4168c0 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -54,7 +54,7 @@ use hir_def::{
 };
 use hir_expand::{name::name, MacroCallKind};
 use hir_ty::{
-    all_super_traits, autoderef,
+    autoderef,
     consteval::{unknown_const_as_generic, ComputedExpr, ConstEvalError, ConstExt},
     diagnostics::BodyValidationDiagnostic,
     method_resolution::{self, TyFingerprint},
@@ -1676,11 +1676,6 @@ impl Trait {
         db.trait_data(self.id).items.iter().map(|(_name, it)| (*it).into()).collect()
     }
 
-    pub fn items_with_supertraits(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
-        let traits = all_super_traits(db.upcast(), self.into());
-        traits.iter().flat_map(|tr| Trait::from(*tr).items(db)).collect()
-    }
-
     pub fn is_auto(self, db: &dyn HirDatabase) -> bool {
         db.trait_data(self.id).is_auto
     }
diff --git a/crates/ide-completion/src/completions/expr.rs b/crates/ide-completion/src/completions/expr.rs
index a2a17d9218..87fae18f4c 100644
--- a/crates/ide-completion/src/completions/expr.rs
+++ b/crates/ide-completion/src/completions/expr.rs
@@ -2,6 +2,7 @@
 
 use hir::ScopeDef;
 use ide_db::FxHashSet;
+use syntax::T;
 
 use crate::{
     context::{PathCompletionCtx, PathKind, PathQualifierCtx},
@@ -14,15 +15,16 @@ pub(crate) fn complete_expr_path(acc: &mut Completions, ctx: &CompletionContext)
         return;
     }
 
-    let (&is_absolute_path, qualifier) = match ctx.path_context() {
-        Some(PathCompletionCtx {
-            kind: PathKind::Expr { .. },
-            is_absolute_path,
-            qualifier,
-            ..
-        }) => (is_absolute_path, qualifier),
-        _ => return,
-    };
+    let (is_absolute_path, qualifier, in_block_expr, in_loop_body, in_functional_update) =
+        match ctx.path_context() {
+            Some(&PathCompletionCtx {
+                kind: PathKind::Expr { in_block_expr, in_loop_body, in_functional_update },
+                is_absolute_path,
+                ref qualifier,
+                ..
+            }) => (is_absolute_path, qualifier, in_block_expr, in_loop_body, in_functional_update),
+            _ => return,
+        };
 
     let scope_def_applicable = |def| {
         use hir::{GenericParam::*, ModuleDef::*};
@@ -162,6 +164,64 @@ pub(crate) fn complete_expr_path(acc: &mut Completions, ctx: &CompletionContext)
                     acc.add_resolution(ctx, name, def);
                 }
             });
+
+            if !in_functional_update {
+                let mut add_keyword =
+                    |kw, snippet| super::keyword::add_keyword(acc, ctx, kw, snippet);
+
+                if ctx.expects_expression() {
+                    if !in_block_expr {
+                        add_keyword("unsafe", "unsafe {\n    $0\n}");
+                    }
+                    add_keyword("match", "match $1 {\n    $0\n}");
+                    add_keyword("while", "while $1 {\n    $0\n}");
+                    add_keyword("while let", "while let $1 = $2 {\n    $0\n}");
+                    add_keyword("loop", "loop {\n    $0\n}");
+                    add_keyword("if", "if $1 {\n    $0\n}");
+                    add_keyword("if let", "if let $1 = $2 {\n    $0\n}");
+                    add_keyword("for", "for $1 in $2 {\n    $0\n}");
+                    add_keyword("true", "true");
+                    add_keyword("false", "false");
+                }
+
+                if ctx.previous_token_is(T![if])
+                    || ctx.previous_token_is(T![while])
+                    || in_block_expr
+                {
+                    add_keyword("let", "let");
+                }
+
+                if ctx.after_if() {
+                    add_keyword("else", "else {\n    $0\n}");
+                    add_keyword("else if", "else if $1 {\n    $0\n}");
+                }
+
+                if ctx.expects_ident_ref_expr() {
+                    add_keyword("mut", "mut ");
+                }
+
+                if in_loop_body {
+                    if in_block_expr {
+                        add_keyword("continue", "continue;");
+                        add_keyword("break", "break;");
+                    } else {
+                        add_keyword("continue", "continue");
+                        add_keyword("break", "break");
+                    }
+                }
+
+                if let Some(fn_def) = &ctx.function_def {
+                    add_keyword(
+                        "return",
+                        match (in_block_expr, fn_def.ret_type().is_some()) {
+                            (true, true) => "return ;",
+                            (true, false) => "return;",
+                            (false, true) => "return $0",
+                            (false, false) => "return",
+                        },
+                    );
+                }
+            }
         }
     }
 }
diff --git a/crates/ide-completion/src/completions/fn_param.rs b/crates/ide-completion/src/completions/fn_param.rs
index 47cead7d57..0cdb8ee119 100644
--- a/crates/ide-completion/src/completions/fn_param.rs
+++ b/crates/ide-completion/src/completions/fn_param.rs
@@ -13,6 +13,7 @@ use crate::{
     CompletionContext, CompletionItem, CompletionItemKind, Completions,
 };
 
+// FIXME: Make this a submodule of [`pattern`]
 /// Complete repeated parameters, both name and type. For example, if all
 /// functions in a file have a `spam: &mut Spam` parameter, a completion with
 /// `spam: &mut Spam` insert text/label will be suggested.
diff --git a/crates/ide-completion/src/completions/keyword.rs b/crates/ide-completion/src/completions/keyword.rs
index b34545414e..14211f86ba 100644
--- a/crates/ide-completion/src/completions/keyword.rs
+++ b/crates/ide-completion/src/completions/keyword.rs
@@ -5,9 +5,8 @@
 use syntax::T;
 
 use crate::{
-    context::{PathCompletionCtx, PathKind},
-    patterns::ImmediateLocation,
-    CompletionContext, CompletionItem, CompletionItemKind, Completions,
+    context::PathKind, patterns::ImmediateLocation, CompletionContext, CompletionItem,
+    CompletionItemKind, Completions,
 };
 
 pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
@@ -83,75 +82,9 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         add_keyword("struct", "struct $0");
         add_keyword("union", "union $1 {\n    $0\n}");
     }
-
-    if ctx.expects_type() {
-        return;
-    }
-
-    if ctx.expects_expression() {
-        if !has_block_expr_parent {
-            add_keyword("unsafe", "unsafe {\n    $0\n}");
-        }
-        add_keyword("match", "match $1 {\n    $0\n}");
-        add_keyword("while", "while $1 {\n    $0\n}");
-        add_keyword("while let", "while let $1 = $2 {\n    $0\n}");
-        add_keyword("loop", "loop {\n    $0\n}");
-        add_keyword("if", "if $1 {\n    $0\n}");
-        add_keyword("if let", "if let $1 = $2 {\n    $0\n}");
-        add_keyword("for", "for $1 in $2 {\n    $0\n}");
-        add_keyword("true", "true");
-        add_keyword("false", "false");
-    }
-
-    if ctx.previous_token_is(T![if]) || ctx.previous_token_is(T![while]) || has_block_expr_parent {
-        add_keyword("let", "let");
-    }
-
-    if ctx.after_if() {
-        add_keyword("else", "else {\n    $0\n}");
-        add_keyword("else if", "else if $1 {\n    $0\n}");
-    }
-
-    if ctx.expects_ident_ref_expr() {
-        add_keyword("mut", "mut ");
-    }
-
-    let (can_be_stmt, in_loop_body) = match ctx.path_context() {
-        Some(&PathCompletionCtx {
-            is_absolute_path: false,
-            kind: PathKind::Expr { in_block_expr, in_loop_body, .. },
-            ..
-        }) => (in_block_expr, in_loop_body),
-        _ => return,
-    };
-
-    if in_loop_body {
-        if can_be_stmt {
-            add_keyword("continue", "continue;");
-            add_keyword("break", "break;");
-        } else {
-            add_keyword("continue", "continue");
-            add_keyword("break", "break");
-        }
-    }
-
-    let fn_def = match &ctx.function_def {
-        Some(it) => it,
-        None => return,
-    };
-
-    add_keyword(
-        "return",
-        match (can_be_stmt, fn_def.ret_type().is_some()) {
-            (true, true) => "return $0;",
-            (true, false) => "return;",
-            (false, true) => "return $0",
-            (false, false) => "return",
-        },
-    )
 }
 
-fn add_keyword(acc: &mut Completions, ctx: &CompletionContext, kw: &str, snippet: &str) {
+pub(super) fn add_keyword(acc: &mut Completions, ctx: &CompletionContext, kw: &str, snippet: &str) {
     let mut item = CompletionItem::new(CompletionItemKind::Keyword, ctx.source_range(), kw);
 
     match ctx.config.snippet_cap {
diff --git a/crates/ide-completion/src/completions/trait_impl.rs b/crates/ide-completion/src/completions/trait_impl.rs
index e3c15038d0..61c5d12649 100644
--- a/crates/ide-completion/src/completions/trait_impl.rs
+++ b/crates/ide-completion/src/completions/trait_impl.rs
@@ -52,6 +52,7 @@ enum ImplCompletionKind {
     Const,
 }
 
+// FIXME: Make this a submodule of [`item_list`]
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
     if let Some((kind, replacement_range, impl_def)) = completion_match(ctx) {
         if let Some(hir_impl) = ctx.sema.to_def(&impl_def) {
diff --git a/crates/ide-completion/src/completions/type.rs b/crates/ide-completion/src/completions/type.rs
index 91414c8bf6..9381548e5e 100644
--- a/crates/ide-completion/src/completions/type.rs
+++ b/crates/ide-completion/src/completions/type.rs
@@ -165,17 +165,14 @@ pub(crate) fn complete_type_path(acc: &mut Completions, ctx: &CompletionContext)
             if let Some(ImmediateLocation::GenericArgList(arg_list)) = &ctx.completion_location {
                 if let Some(path_seg) = arg_list.syntax().parent().and_then(ast::PathSegment::cast)
                 {
-                    if path_seg.syntax().ancestors().find_map(ast::TypeBound::cast).is_some() {
-                        if let Some(hir::PathResolution::Def(hir::ModuleDef::Trait(trait_))) =
-                            ctx.sema.resolve_path(&path_seg.parent_path())
-                        {
-                            trait_.items_with_supertraits(ctx.sema.db).into_iter().for_each(|it| {
-                                if let hir::AssocItem::TypeAlias(alias) = it {
-                                    cov_mark::hit!(complete_assoc_type_in_generics_list);
-                                    acc.add_type_alias_with_eq(ctx, alias)
-                                }
-                            });
-                        }
+                    if let Some(hir::PathResolution::Def(hir::ModuleDef::Trait(trait_))) =
+                        ctx.sema.resolve_path(&path_seg.parent_path())
+                    {
+                        trait_.items(ctx.sema.db).into_iter().for_each(|it| {
+                            if let hir::AssocItem::TypeAlias(alias) = it {
+                                acc.add_type_alias_with_eq(ctx, alias)
+                            }
+                        });
                     }
                 }
             }
diff --git a/crates/ide-completion/src/completions/vis.rs b/crates/ide-completion/src/completions/vis.rs
index b5e86b62d1..d538f1879e 100644
--- a/crates/ide-completion/src/completions/vis.rs
+++ b/crates/ide-completion/src/completions/vis.rs
@@ -7,7 +7,7 @@ use crate::{
     Completions,
 };
 
-pub(crate) fn complete_vis(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_vis_path(acc: &mut Completions, ctx: &CompletionContext) {
     let (&is_absolute_path, qualifier, &has_in_token) = match ctx.path_context() {
         Some(PathCompletionCtx {
             kind: PathKind::Vis { has_in_token },
diff --git a/crates/ide-completion/src/context.rs b/crates/ide-completion/src/context.rs
index f6b8962df6..4a058ac261 100644
--- a/crates/ide-completion/src/context.rs
+++ b/crates/ide-completion/src/context.rs
@@ -48,6 +48,7 @@ pub(super) enum PathKind {
     Expr {
         in_block_expr: bool,
         in_loop_body: bool,
+        in_functional_update: bool,
     },
     Type,
     Attr {
@@ -392,10 +393,6 @@ impl<'a> CompletionContext<'a> {
         matches!(self.path_context(), Some(PathCompletionCtx { kind: PathKind::Expr { .. }, .. }))
     }
 
-    pub(crate) fn expects_type(&self) -> bool {
-        matches!(self.path_context(), Some(PathCompletionCtx { kind: PathKind::Type, .. }))
-    }
-
     pub(crate) fn is_non_trivial_path(&self) -> bool {
         matches!(
             self.path_context(),
@@ -1104,6 +1101,9 @@ impl<'a> CompletionContext<'a> {
                 })
                 .unwrap_or(false)
         };
+        let is_in_func_update = |it: &SyntaxNode| {
+            it.parent().map_or(false, |it| ast::RecordExprFieldList::can_cast(it.kind()))
+        };
 
         let kind = path.syntax().ancestors().find_map(|it| {
             // using Option<Option<PathKind>> as extra controlflow
@@ -1114,8 +1114,8 @@ impl<'a> CompletionContext<'a> {
                         path_ctx.has_call_parens = it.syntax().parent().map_or(false, |it| ast::CallExpr::can_cast(it.kind()));
                         let in_block_expr = is_in_block(it.syntax());
                         let in_loop_body = is_in_loop_body(it.syntax());
-
-                        Some(PathKind::Expr { in_block_expr, in_loop_body })
+                        let in_functional_update = is_in_func_update(it.syntax());
+                        Some(PathKind::Expr { in_block_expr, in_loop_body, in_functional_update })
                     },
                     ast::TupleStructPat(it) => {
                         path_ctx.has_call_parens = true;
@@ -1149,7 +1149,8 @@ impl<'a> CompletionContext<'a> {
                                return Some(parent.and_then(ast::MacroExpr::cast).map(|it| {
                                     let in_loop_body = is_in_loop_body(it.syntax());
                                     let in_block_expr = is_in_block(it.syntax());
-                                    PathKind::Expr { in_block_expr, in_loop_body }
+                                    let in_functional_update = is_in_func_update(it.syntax());
+                                    PathKind::Expr { in_block_expr, in_loop_body, in_functional_update }
                                 }));
                             },
                         }
diff --git a/crates/ide-completion/src/lib.rs b/crates/ide-completion/src/lib.rs
index 6695fcdc19..7789c96707 100644
--- a/crates/ide-completion/src/lib.rs
+++ b/crates/ide-completion/src/lib.rs
@@ -173,7 +173,7 @@ pub fn completions(
         completions::r#type::complete_type_path(acc, ctx);
         completions::r#type::complete_inferred_type(acc, ctx);
         completions::use_::complete_use_tree(acc, ctx);
-        completions::vis::complete_vis(acc, ctx);
+        completions::vis::complete_vis_path(acc, ctx);
     }
 
     Some(acc)
diff --git a/crates/ide-completion/src/render.rs b/crates/ide-completion/src/render.rs
index 88b6435c95..8bb0bc198a 100644
--- a/crates/ide-completion/src/render.rs
+++ b/crates/ide-completion/src/render.rs
@@ -80,7 +80,7 @@ impl<'a> RenderContext<'a> {
 
     fn is_deprecated(&self, def: impl HasAttrs) -> bool {
         let attrs = def.attrs(self.db());
-        attrs.by_key("deprecated").exists()
+        attrs.by_key("deprecated").exists() || attrs.by_key("rustc_deprecated").exists()
     }
 
     fn is_deprecated_assoc_item(&self, as_assoc_item: impl AsAssocItem) -> bool {
@@ -688,6 +688,8 @@ fn main() { let _: m::Spam = S$0 }
             r#"
 #[deprecated]
 fn something_deprecated() {}
+#[rustc_deprecated(since = "1.0.0")]
+fn something_else_deprecated() {}
 
 fn main() { som$0 }
 "#,
@@ -696,8 +698,8 @@ fn main() { som$0 }
                 [
                     CompletionItem {
                         label: "main()",
-                        source_range: 56..59,
-                        delete: 56..59,
+                        source_range: 127..130,
+                        delete: 127..130,
                         insert: "main()$0",
                         kind: SymbolKind(
                             Function,
@@ -707,8 +709,8 @@ fn main() { som$0 }
                     },
                     CompletionItem {
                         label: "something_deprecated()",
-                        source_range: 56..59,
-                        delete: 56..59,
+                        source_range: 127..130,
+                        delete: 127..130,
                         insert: "something_deprecated()$0",
                         kind: SymbolKind(
                             Function,
@@ -717,6 +719,18 @@ fn main() { som$0 }
                         detail: "fn()",
                         deprecated: true,
                     },
+                    CompletionItem {
+                        label: "something_else_deprecated()",
+                        source_range: 127..130,
+                        delete: 127..130,
+                        insert: "something_else_deprecated()$0",
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        lookup: "something_else_deprecated",
+                        detail: "fn()",
+                        deprecated: true,
+                    },
                 ]
             "#]],
         );
diff --git a/crates/ide-db/src/defs.rs b/crates/ide-db/src/defs.rs
index bea6f24523..34b557e21e 100644
--- a/crates/ide-db/src/defs.rs
+++ b/crates/ide-db/src/defs.rs
@@ -386,8 +386,9 @@ impl NameRefClass {
                     let containing_path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
                     let resolved = sema.resolve_path(&containing_path)?;
                     if let PathResolution::Def(ModuleDef::Trait(tr)) = resolved {
+                        // FIXME: resolve in supertraits
                         if let Some(ty) = tr
-                            .items_with_supertraits(sema.db)
+                            .items(sema.db)
                             .iter()
                             .filter_map(|&assoc| match assoc {
                                 hir::AssocItem::TypeAlias(it) => Some(it),
diff --git a/crates/ide-db/src/imports/insert_use.rs b/crates/ide-db/src/imports/insert_use.rs
index 66d0b2ee82..a19969ecc4 100644
--- a/crates/ide-db/src/imports/insert_use.rs
+++ b/crates/ide-db/src/imports/insert_use.rs
@@ -8,7 +8,7 @@ use hir::Semantics;
 use syntax::{
     algo,
     ast::{self, make, AstNode, HasAttrs, HasModuleItem, HasVisibility, PathSegmentKind},
-    ted, Direction, NodeOrToken, SyntaxKind, SyntaxNode,
+    ted, AstToken, Direction, NodeOrToken, SyntaxNode, SyntaxToken,
 };
 
 use crate::{
@@ -397,16 +397,12 @@ fn insert_use_(
     }
 
     // there are no imports in this file at all
-    // so put the import after all inner module attributes and possible license header comments
     if let Some(last_inner_element) = scope_syntax
         .children_with_tokens()
-        .take_while(|child| match child {
+        .filter(|child| match child {
             NodeOrToken::Node(node) => is_inner_attribute(node.clone()),
-            NodeOrToken::Token(token) => {
-                [SyntaxKind::WHITESPACE, SyntaxKind::COMMENT].contains(&token.kind())
-            }
+            NodeOrToken::Token(token) => is_comment(token.clone()),
         })
-        .filter(|child| child.as_token().map_or(true, |t| t.kind() != SyntaxKind::WHITESPACE))
         .last()
     {
         cov_mark::hit!(insert_empty_inner_attr);
@@ -443,3 +439,7 @@ fn insert_use_(
 fn is_inner_attribute(node: SyntaxNode) -> bool {
     ast::Attr::cast(node).map(|attr| attr.kind()) == Some(ast::AttrKind::Inner)
 }
+
+fn is_comment(token: SyntaxToken) -> bool {
+    ast::Comment::cast(token).is_some()
+}
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/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 30f48819e6..3d22ed9c16 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1012,22 +1012,6 @@ fn f() -> impl Iterator<Item$0 = u8> {}
         );
     }
 
-    #[test]
-    fn goto_def_for_super_assoc_ty_in_path() {
-        check(
-            r#"
-trait Super {
-    type Item;
-       //^^^^
-}
-
-trait Sub: Super {}
-
-fn f() -> impl Sub<Item$0 = u8> {}
-"#,
-        );
-    }
-
     #[test]
     fn unknown_assoc_ty() {
         check_unresolved(
diff --git a/crates/ide/src/signature_help.rs b/crates/ide/src/signature_help.rs
index e603cb4862..57b0305fb3 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 callable.receiver_param(db) {
+            fn_params = Some(match func.self_param(db) {
                 Some(_self) => func.params_without_self(db),
                 None => func.assoc_fn_params(db),
             });
@@ -1142,20 +1142,4 @@ 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/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/ide-completion/src/tests/record.rs b/crates/ide-completion/src/tests/record.rs
index a0f8b24867..2c49761748 100644
--- a/crates/ide-completion/src/tests/record.rs
+++ b/crates/ide-completion/src/tests/record.rs
@@ -168,19 +168,8 @@ fn main() {
             tt Sized
             bt u32
             kw crate::
-            kw false
-            kw for
-            kw if
-            kw if let
-            kw loop
-            kw match
-            kw return
             kw self::
             kw super::
-            kw true
-            kw unsafe
-            kw while
-            kw while let
         "#]],
     );
     check(
diff --git a/crates/ide-completion/src/tests/type_pos.rs b/crates/ide-completion/src/tests/type_pos.rs
index 1e5e86eef5..5224bc4b48 100644
--- a/crates/ide-completion/src/tests/type_pos.rs
+++ b/crates/ide-completion/src/tests/type_pos.rs
@@ -336,13 +336,9 @@ fn foo<'lt, T, const C: usize>() {
 
 #[test]
 fn completes_types_and_const_in_arg_list() {
-    cov_mark::check!(complete_assoc_type_in_generics_list);
     check(
         r#"
-trait Trait1 {
-    type Super;
-}
-trait Trait2: Trait1 {
+trait Trait2 {
     type Foo;
 }
 
@@ -352,16 +348,14 @@ fn foo<'lt, T: Trait2<$0>, const CONST_PARAM: usize>(_: T) {}
             ct CONST
             cp CONST_PARAM
             en Enum
-            ma makro!(…)            macro_rules! makro
+            ma makro!(…)          macro_rules! makro
             md module
             st Record
             st Tuple
             st Unit
             tt Trait
-            tt Trait1
             tt Trait2
-            ta Foo =  (as Trait2)   type Foo
-            ta Super =  (as Trait1) type Super
+            ta Foo =  (as Trait2) type Foo
             tp T
             un Union
             bt u32
@@ -393,38 +387,6 @@ fn foo<'lt, T: Trait2<self::$0>, const CONST_PARAM: usize>(_: T) {}
     );
 }
 
-#[test]
-fn no_assoc_completion_outside_type_bounds() {
-    check(
-        r#"
-struct S;
-trait Tr<T> {
-    type Ty;
-}
-
-impl Tr<$0
-    "#,
-        expect![[r#"
-            ct CONST
-            en Enum
-            ma makro!(…) macro_rules! makro
-            md module
-            sp Self
-            st Record
-            st S
-            st Tuple
-            st Unit
-            tt Tr
-            tt Trait
-            un Union
-            bt u32
-            kw crate::
-            kw self::
-            kw super::
-        "#]],
-    );
-}
-
 #[test]
 fn enum_qualified() {
     check(
diff --git a/crates/ide-db/src/imports/insert_use/tests.rs b/crates/ide-db/src/imports/insert_use/tests.rs
index 6569e4ed8c..acadb353b6 100644
--- a/crates/ide-db/src/imports/insert_use/tests.rs
+++ b/crates/ide-db/src/imports/insert_use/tests.rs
@@ -5,24 +5,6 @@ use test_utils::{assert_eq_text, CURSOR_MARKER};
 
 use super::*;
 
-#[test]
-fn trailing_comment_in_empty_file() {
-    check(
-        "foo::bar",
-        r#"
-struct Struct;
-// 0 = 1
-"#,
-        r#"
-use foo::bar;
-
-struct Struct;
-// 0 = 1
-"#,
-        ImportGranularity::Crate,
-    );
-}
-
 #[test]
 fn respects_cfg_attr_fn() {
     check(
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)
     }