Merge #3824

3824: New config names r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

crates/rust-analyzer/src/config.rs

@@ -16,20 +16,33 @@ use serde::Deserialize;
 #[derive(Debug, Clone)]
 pub struct Config {
     pub client_caps: ClientCapsConfig,
+
+    pub with_sysroot: bool,
     pub publish_diagnostics: bool,
+    pub lru_capacity: Option<usize>,
+    pub proc_macro_srv: Option<String>,
+    pub files: FilesConfig,
     pub notifications: NotificationsConfig,
+
+    pub cargo: CargoConfig,
+    pub rustfmt: RustfmtConfig,
+    pub check: Option<FlycheckConfig>,
+
     pub inlay_hints: InlayHintsConfig,
     pub completion: CompletionConfig,
     pub call_info_full: bool,
-    pub rustfmt: RustfmtConfig,
+}
-    pub check: Option<FlycheckConfig>,
+
-    pub vscode_lldb: bool,
+#[derive(Debug, Clone)]
-    pub proc_macro_srv: Option<String>,
+pub struct FilesConfig {
-    pub lru_capacity: Option<usize>,
+    pub watcher: FilesWatcher,
-    pub use_client_watching: bool,
+    pub exclude: Vec<String>,
-    pub exclude_globs: Vec<String>,
+}
-    pub cargo: CargoConfig,
+
-    pub with_sysroot: bool,
+#[derive(Debug, Clone)]
+pub enum FilesWatcher {
+    Client,
+    Notify,
 }
 
 #[derive(Debug, Clone)]
@@ -59,12 +72,26 @@ pub struct ClientCapsConfig {
 impl Default for Config {
     fn default() -> Self {
         Config {
+            client_caps: ClientCapsConfig::default(),
+
+            with_sysroot: true,
             publish_diagnostics: true,
+            lru_capacity: None,
+            proc_macro_srv: None,
+            files: FilesConfig { watcher: FilesWatcher::Notify, exclude: Vec::new() },
             notifications: NotificationsConfig {
                 workspace_loaded: true,
                 cargo_toml_not_found: true,
             },
-            client_caps: ClientCapsConfig::default(),
+
+            cargo: CargoConfig::default(),
+            rustfmt: RustfmtConfig::Rustfmt { extra_args: Vec::new() },
+            check: Some(FlycheckConfig::CargoCommand {
+                command: "check".to_string(),
+                all_targets: true,
+                extra_args: Vec::new(),
+            }),
+
             inlay_hints: InlayHintsConfig {
                 type_hints: true,
                 parameter_hints: true,
@@ -77,19 +104,6 @@ impl Default for Config {
                 add_call_argument_snippets: true,
             },
             call_info_full: true,
-            rustfmt: RustfmtConfig::Rustfmt { extra_args: Vec::new() },
-            check: Some(FlycheckConfig::CargoCommand {
-                command: "check".to_string(),
-                all_targets: true,
-                extra_args: Vec::new(),
-            }),
-            vscode_lldb: false,
-            proc_macro_srv: None,
-            lru_capacity: None,
-            use_client_watching: false,
-            exclude_globs: Vec::new(),
-            cargo: CargoConfig::default(),
-            with_sysroot: true,
         }
     }
 }
@@ -103,45 +117,44 @@ impl Config {
         *self = Default::default();
         self.client_caps = client_caps;
 
-        set(value, "/excludeGlobs", &mut self.exclude_globs);
+        set(value, "/withSysroot", &mut self.with_sysroot);
-        set(value, "/useClientWatching", &mut self.use_client_watching);
+        set(value, "/featureFlags/lsp.diagnostics", &mut self.publish_diagnostics);
         set(value, "/lruCapacity", &mut self.lru_capacity);
+        if let Some(watcher) =  get::<String>(value, "/files/watcher") {
+            self.files.watcher = match watcher.as_str() {
+                "client" => FilesWatcher::Client,
+                "notify"| _ => FilesWatcher::Notify,
+            }
+        }
+        set(value, "/notifications/workspaceLoaded", &mut self.notifications.workspace_loaded);
+        set(value, "/notifications/cargoTomlNotFound", &mut self.notifications.cargo_toml_not_found);
 
-        set(value, "/inlayHintsType", &mut self.inlay_hints.type_hints);
+        set(value, "/cargo/noDefaultFeatures", &mut self.cargo.no_default_features);
-        set(value, "/inlayHintsParameter", &mut self.inlay_hints.parameter_hints);
+        set(value, "/cargo/allFeatures", &mut self.cargo.all_features);
-        set(value, "/inlayHintsChaining", &mut self.inlay_hints.chaining_hints);
+        set(value, "/cargo/features", &mut self.cargo.features);
-        set(value, "/inlayHintsMaxLength", &mut self.inlay_hints.max_length);
+        set(value, "/cargo/loadOutDirsFromCheck", &mut self.cargo.load_out_dirs_from_check);
-
+        if let RustfmtConfig::Rustfmt { extra_args } = &mut self.rustfmt {
-        if let Some(false) = get(value, "cargo_watch_enable") {
+            set(value, "/rustfmt/extraArgs", extra_args);
+        }
+        if let Some(false) = get(value, "/checkOnSave/enable") {
             self.check = None
         } else {
             if let Some(FlycheckConfig::CargoCommand { command, extra_args, all_targets }) = &mut self.check
             {
-                set(value, "/cargoWatchArgs", extra_args);
+                set(value, "/checkOnSave/extraArgs", extra_args);
-                set(value, "/cargoWatchCommand", command);
+                set(value, "/checkOnSave/command", command);
-                set(value, "/cargoWatchAllTargets", all_targets);
+                set(value, "/checkOnSave/allTargets", all_targets);
             }
         };
 
-        set(value, "/withSysroot", &mut self.with_sysroot);
+        set(value, "/inlayHints/typeHints", &mut self.inlay_hints.type_hints);
-        if let RustfmtConfig::Rustfmt { extra_args } = &mut self.rustfmt {
+        set(value, "/inlayHints/parameterHints", &mut self.inlay_hints.parameter_hints);
-            set(value, "/rustfmtArgs", extra_args);
+        set(value, "/inlayHints/chainingHints", &mut self.inlay_hints.chaining_hints);
-        }
+        set(value, "/inlayHints/maxLength", &mut self.inlay_hints.max_length);
-
+        set(value, "/completion/postfix/enable", &mut self.completion.enable_postfix_completions);
-        set(value, "/cargoFeatures/noDefaultFeatures", &mut self.cargo.no_default_features);
+        set(value, "/completion/addCallParenthesis", &mut self.completion.add_call_parenthesis);
-        set(value, "/cargoFeatures/allFeatures", &mut self.cargo.all_features);
+        set(value, "/completion/addCallArgumentSnippets", &mut self.completion.add_call_argument_snippets);
-        set(value, "/cargoFeatures/features", &mut self.cargo.features);
+        set(value, "/callInfo/full", &mut self.call_info_full);
-        set(value, "/cargoFeatures/loadOutDirsFromCheck", &mut self.cargo.load_out_dirs_from_check);
-
-        set(value, "/vscodeLldb", &mut self.vscode_lldb);
-
-        set(value, "/featureFlags/lsp.diagnostics", &mut self.publish_diagnostics);
-        set(value, "/featureFlags/notifications.workspace-loaded", &mut self.notifications.workspace_loaded);
-        set(value, "/featureFlags/notifications.cargo-toml-not-found", &mut self.notifications.cargo_toml_not_found);
-        set(value, "/featureFlags/completion.enable-postfix", &mut self.completion.enable_postfix_completions);
-        set(value, "/featureFlags/completion.insertion.add-call-parenthesis", &mut self.completion.add_call_parenthesis);
-        set(value, "/featureFlags/completion.insertion.add-argument-snippets", &mut self.completion.add_call_argument_snippets);
-        set(value, "/featureFlags/call-info.full", &mut self.call_info_full);
 
         log::info!("Config::update() = {:#?}", self);
 

crates/rust-analyzer/src/main_loop.rs

@@ -30,7 +30,7 @@ use serde::{de::DeserializeOwned, Serialize};
 use threadpool::ThreadPool;
 
 use crate::{
-    config::Config,
+    config::{Config, FilesWatcher},
     diagnostics::DiagnosticTask,
     main_loop::{
         pending_requests::{PendingRequest, PendingRequests},
@@ -40,7 +40,6 @@ use crate::{
     world::{WorldSnapshot, WorldState},
     Result,
 };
-use req::ConfigurationParams;
 
 #[derive(Debug)]
 pub struct LspError {
@@ -122,12 +121,13 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection)
         };
 
         let globs = config
-            .exclude_globs
+            .files
+            .exclude
             .iter()
             .map(|glob| crate::vfs_glob::Glob::new(glob))
             .collect::<std::result::Result<Vec<_>, _>>()?;
 
-        if config.use_client_watching {
+        if let FilesWatcher::Client = config.files.watcher {
             let registration_options = req::DidChangeWatchedFilesRegistrationOptions {
                 watchers: workspaces
                     .iter()
@@ -153,7 +153,7 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection)
             workspaces,
             config.lru_capacity,
             &globs,
-            Watch(!config.use_client_watching),
+            Watch(matches!(config.files.watcher, FilesWatcher::Notify)),
             config,
         )
     };
@@ -607,7 +607,12 @@ fn on_notification(
             let request_id = loop_state.next_request_id();
             let request = request_new::<req::WorkspaceConfiguration>(
                 request_id.clone(),
-                ConfigurationParams::default(),
+                req::ConfigurationParams {
+                    items: vec![req::ConfigurationItem {
+                        scope_uri: None,
+                        section: Some("rust-analyzer".to_string()),
+                    }],
+                },
             );
             msg_sender.send(request.into())?;
             loop_state.configuration_request_id = Some(request_id);
@@ -884,10 +889,9 @@ fn update_file_notifications_on_threadpool(
     subscriptions: Vec<FileId>,
 ) {
     log::trace!("updating notifications for {:?}", subscriptions);
-    let publish_diagnostics = world.config.publish_diagnostics;
+    if world.config.publish_diagnostics {
         pool.execute(move || {
             for file_id in subscriptions {
-            if publish_diagnostics {
                 match handlers::publish_diagnostics(&world, file_id) {
                     Err(e) => {
                         if !is_canceled(&e) {
@@ -899,8 +903,8 @@ fn update_file_notifications_on_threadpool(
                     }
                 }
             }
+        })
     }
-    });
 }
 
 pub fn show_message(typ: req::MessageType, message: impl Into<String>, sender: &Sender<Message>) {

crates/rust-analyzer/src/main_loop/handlers.rs

@@ -810,7 +810,6 @@ pub fn handle_code_lens(
         };
         lenses.push(lens);
 
-        if world.config.vscode_lldb {
         if r.args[0] == "run" {
             r.args[0] = "build".into();
         } else {
@@ -827,7 +826,6 @@ pub fn handle_code_lens(
         };
         lenses.push(debug_lens);
     }
-    }
 
     // Handle impls
     lenses.extend(

crates/rust-analyzer/src/req.rs

@@ -6,8 +6,8 @@ use serde::{Deserialize, Serialize};
 
 pub use lsp_types::{
     notification::*, request::*, ApplyWorkspaceEditParams, CodeActionParams, CodeLens,
-    CodeLensParams, CompletionParams, CompletionResponse, ConfigurationParams, DiagnosticTag,
+    CodeLensParams, CompletionParams, CompletionResponse, ConfigurationItem, ConfigurationParams,
-    DidChangeConfigurationParams, DidChangeWatchedFilesParams,
+    DiagnosticTag, DidChangeConfigurationParams, DidChangeWatchedFilesParams,
     DidChangeWatchedFilesRegistrationOptions, DocumentOnTypeFormattingParams, DocumentSymbolParams,
     DocumentSymbolResponse, FileSystemWatcher, Hover, InitializeResult, MessageType,
     PartialResultParams, ProgressParams, ProgressParamsValue, ProgressToken,

editors/code/package.json

@@ -177,46 +177,149 @@
             "type": "object",
             "title": "Rust Analyzer",
             "properties": {
+                "rust-analyzer.diagnostics.enable": {
+                    "type": "boolean",
+                    "default": true,
+                    "markdownDescription": "Whether to show native rust-analyzer diagnostics."
+                },
+                "rust-analyzer.lruCapacity": {
+                    "type": [
+                        "null",
+                        "integer"
+                    ],
+                    "default": null,
+                    "minimum": 0,
+                    "exclusiveMinimum": true,
+                    "description": "Number of syntax trees rust-analyzer keeps in memory."
+                },
+                "rust-analyzer.files.watcher": {
+                    "type": "string",
+                    "enum": [
+                        "client",
+                        "notify"
+                    ],
+                    "default": "client",
+                    "description": "Controls file watching implementation."
+                },
+                "rust-analyzer.files.exclude": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "default": [],
+                    "description": "Paths to exclude from analysis."
+                },
+                "rust-analyzer.notifications.workspaceLoaded": {
+                    "type": "boolean",
+                    "markdownDescription": "Whether to show `workspace loaded` message."
+                },
+                "rust-analyzer.notifications.cargoTomlNotFound": {
+                    "type": "boolean",
+                    "markdownDescription": "Whether to show `can't find Cargo.toml` error message"
+                },
+                "rust-analyzer.cargo.noDefaultFeatures": {
+                    "type": "boolean",
+                    "default": false,
+                    "markdownDescription": "Do not activate the `default` feature"
+                },
+                "rust-analyzer.cargo.allFeatures": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Activate all available features"
+                },
+                "rust-analyzer.cargo.features": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "default": [],
+                    "description": "List of features to activate"
+                },
+                "rust-analyzer.cargo.loadOutDirsFromCheck": {
+                    "type": "boolean",
+                    "default": false,
+                    "markdownDescription": "Run `cargo check` on startup to get the correct value for package OUT_DIRs"
+                },
+                "rust-analyzer.rustfmt.extraArgs": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "default": [],
+                    "description": "Additional arguments to rustfmt"
+                },
+                "rust-analyzer.checkOnSave.enable": {
+                    "type": "boolean",
+                    "default": true,
+                    "markdownDescription": "Run specified `cargo check` command for diagnostics on save"
+                },
+                "rust-analyzer.checkOnSave.extraArgs": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "markdownDescription": "Extra arguments for `cargo check`",
+                    "default": []
+                },
+                "rust-analyzer.checkOnSave.command": {
+                    "type": "string",
+                    "default": "check",
+                    "markdownDescription": "Cargo command to use for `cargo check`"
+                },
+                "rust-analyzer.checkOnSave.allTargets": {
+                    "type": "boolean",
+                    "default": true,
+                    "markdownDescription": "Check all targets and tests (will be passed as `--all-targets`)"
+                },
+                "rust-analyzer.inlayHints.typeHints": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Whether to show inlay type hints"
+                },
+                "rust-analyzer.inlayHints.chainingHints": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Whether to show inlay type hints for method chains"
+                },
+                "rust-analyzer.inlayHints.parameterHints": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Whether to show function parameter name inlay hints at the call site"
+                },
+                "rust-analyzer.inlayHints.maxLength": {
+                    "type": [
+                        "null",
+                        "integer"
+                    ],
+                    "default": 20,
+                    "minimum": 0,
+                    "exclusiveMinimum": true,
+                    "description": "Maximum length for inlay hints"
+                },
+                "rust-analyzer.completion.addCallParenthesis": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Whether to add parenthesis when completing functions"
+                },
+                "rust-analyzer.completion.addCallArgumentSnippets": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Whether to add argument snippets when completing functions"
+                },
+                "rust-analyzer.completion.postfix.enable": {
+                    "type": "boolean",
+                    "default": true,
+                    "markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc."
+                },
+                "rust-analyzer.callInfo.full": {
+                    "type": "boolean",
+                    "description": "Show function name and docs in parameter hints"
+                },
                 "rust-analyzer.highlighting.semanticTokens": {
                     "type": "boolean",
                     "default": false,
                     "description": "Use proposed semantic tokens API for syntax highlighting"
                 },
-                "rust-analyzer.featureFlags": {
-                    "type": "object",
-                    "default": {},
-                    "description": "Fine grained feature flags to disable annoying features",
-                    "properties": {
-                        "lsp.diagnostics": {
-                            "type": "boolean",
-                            "markdownDescription": "Whether to show diagnostics from `cargo check`"
-                        },
-                        "completion.insertion.add-call-parenthesis": {
-                            "type": "boolean",
-                            "description": "Whether to add parenthesis when completing functions"
-                        },
-                        "completion.insertion.add-argument-snippets": {
-                            "type": "boolean",
-                            "description": "Whether to add argument snippets when completing functions"
-                        },
-                        "completion.enable-postfix": {
-                            "type": "boolean",
-                            "markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc."
-                        },
-                        "call-info.full": {
-                            "type": "boolean",
-                            "description": "Show function name and docs in parameter hints"
-                        },
-                        "notifications.workspace-loaded": {
-                            "type": "boolean",
-                            "markdownDescription": "Whether to show `workspace loaded` message"
-                        },
-                        "notifications.cargo-toml-not-found": {
-                            "type": "boolean",
-                            "markdownDescription": "Whether to show `can't find Cargo.toml` error message"
-                        }
-                    }
-                },
                 "rust-analyzer.updates.channel": {
                     "type": "string",
                     "enum": [
@@ -243,50 +346,6 @@
                     "default": null,
                     "description": "Path to rust-analyzer executable (points to bundled binary by default). If this is set, then \"rust-analyzer.updates.channel\" setting is not used"
                 },
-                "rust-analyzer.excludeGlobs": {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    },
-                    "default": [],
-                    "description": "Paths to exclude from analysis"
-                },
-                "rust-analyzer.rustfmtArgs": {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    },
-                    "default": [],
-                    "description": "Additional arguments to rustfmt"
-                },
-                "rust-analyzer.useClientWatching": {
-                    "type": "boolean",
-                    "default": true,
-                    "description": "client provided file watching instead of notify watching."
-                },
-                "rust-analyzer.cargo-watch.enable": {
-                    "type": "boolean",
-                    "default": true,
-                    "markdownDescription": "Run specified `cargo-watch` command for diagnostics on save"
-                },
-                "rust-analyzer.cargo-watch.arguments": {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    },
-                    "markdownDescription": "`cargo-watch` arguments. (e.g: `--features=\"shumway,pdf\"` will run as `cargo watch -x \"check --features=\"shumway,pdf\"\"` )",
-                    "default": []
-                },
-                "rust-analyzer.cargo-watch.command": {
-                    "type": "string",
-                    "markdownDescription": "`cargo-watch` command. (e.g: `clippy` will run as `cargo watch -x clippy` )",
-                    "default": "check"
-                },
-                "rust-analyzer.cargo-watch.allTargets": {
-                    "type": "boolean",
-                    "markdownDescription": "Check all targets and tests (will be passed as `--all-targets`)",
-                    "default": true
-                },
                 "rust-analyzer.trace.server": {
                     "type": "string",
                     "scope": "window",
@@ -307,64 +366,6 @@
                     "description": "Enable logging of VS Code extensions itself",
                     "type": "boolean",
                     "default": false
-                },
-                "rust-analyzer.lruCapacity": {
-                    "type": [
-                        "null",
-                        "integer"
-                    ],
-                    "default": null,
-                    "minimum": 0,
-                    "exclusiveMinimum": true,
-                    "description": "Number of syntax trees rust-analyzer keeps in memory"
-                },
-                "rust-analyzer.inlayHints.typeHints": {
-                    "type": "boolean",
-                    "default": true,
-                    "description": "Whether to show inlay type hints"
-                },
-                "rust-analyzer.inlayHints.chainingHints": {
-                    "type": "boolean",
-                    "default": true,
-                    "description": "Whether to show inlay type hints for method chains"
-                },
-                "rust-analyzer.inlayHints.parameterHints": {
-                    "type": "boolean",
-                    "default": true,
-                    "description": "Whether to show function parameter name inlay hints at the call site"
-                },
-                "rust-analyzer.inlayHints.maxLength": {
-                    "type": [
-                        "null",
-                        "integer"
-                    ],
-                    "default": 20,
-                    "minimum": 0,
-                    "exclusiveMinimum": true,
-                    "description": "Maximum length for inlay hints"
-                },
-                "rust-analyzer.cargoFeatures.noDefaultFeatures": {
-                    "type": "boolean",
-                    "default": false,
-                    "markdownDescription": "Do not activate the `default` feature"
-                },
-                "rust-analyzer.cargoFeatures.allFeatures": {
-                    "type": "boolean",
-                    "default": true,
-                    "description": "Activate all available features"
-                },
-                "rust-analyzer.cargoFeatures.features": {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    },
-                    "default": [],
-                    "description": "List of features to activate"
-                },
-                "rust-analyzer.cargoFeatures.loadOutDirsFromCheck": {
-                    "type": "boolean",
-                    "default": false,
-                    "markdownDescription": "Run `cargo check` on startup to get the correct value for package OUT_DIRs"
                 }
             }
         },

editors/code/src/client.ts

@@ -5,30 +5,6 @@ import { Config } from './config';
 import { CallHierarchyFeature } from 'vscode-languageclient/lib/callHierarchy.proposed';
 import { SemanticTokensFeature, DocumentSemanticsTokensSignature } from 'vscode-languageclient/lib/semanticTokens.proposed';
 
-export function configToServerOptions(config: Config) {
-    return {
-        lruCapacity: config.lruCapacity,
-
-        inlayHintsType: config.inlayHints.typeHints,
-        inlayHintsParameter: config.inlayHints.parameterHints,
-        inlayHintsChaining: config.inlayHints.chainingHints,
-        inlayHintsMaxLength: config.inlayHints.maxLength,
-
-        cargoWatchEnable: config.cargoWatchOptions.enable,
-        cargoWatchArgs: config.cargoWatchOptions.arguments,
-        cargoWatchCommand: config.cargoWatchOptions.command,
-        cargoWatchAllTargets: config.cargoWatchOptions.allTargets,
-
-        excludeGlobs: config.excludeGlobs,
-        useClientWatching: config.useClientWatching,
-        featureFlags: config.featureFlags,
-        withSysroot: config.withSysroot,
-        cargoFeatures: config.cargoFeatures,
-        rustfmtArgs: config.rustfmtArgs,
-        vscodeLldb: vscode.extensions.getExtension("vadimcn.vscode-lldb") != null,
-    };
-}
-
 export async function createClient(config: Config, serverPath: string, cwd: string): Promise<lc.LanguageClient> {
     // '.' Is the fallback if no folder is open
     // TODO?: Workspace folders support Uri's (eg: file://test.txt).
@@ -48,7 +24,7 @@ export async function createClient(config: Config, serverPath: string, cwd: stri
 
     const clientOptions: lc.LanguageClientOptions = {
         documentSelector: [{ scheme: 'file', language: 'rust' }],
-        initializationOptions: configToServerOptions(config),
+        initializationOptions: vscode.workspace.getConfiguration("rust-analyzer"),
         traceOutputChannel,
         middleware: {
             // Workaround for https://github.com/microsoft/vscode-languageserver-node/issues/576

editors/code/src/commands/runnables.ts

@@ -66,6 +66,10 @@ export function debugSingle(ctx: Ctx): Cmd {
     return async (config: ra.Runnable) => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
+        if (!vscode.extensions.getExtension("vadimcn.vscode-lldb")) {
+            vscode.window.showErrorMessage("Install `vadimcn.vscode-lldb` extension for debugging");
+            return;
+        }
 
         const debugConfig = {
             type: "lldb",

editors/code/src/config.ts

@@ -11,9 +11,8 @@ export class Config {
     private readonly rootSection = "rust-analyzer";
     private readonly requiresReloadOpts = [
         "serverPath",
-        "cargoFeatures",
+        "cargo",
-        "excludeGlobs",
+        "files",
-        "useClientWatching",
         "highlighting",
         "updates.channel",
     ]
@@ -71,17 +70,8 @@ export class Config {
     get channel() { return this.cfg.get<UpdatesChannel>("updates.channel")!; }
     get askBeforeDownload() { return this.cfg.get<boolean>("updates.askBeforeDownload")!; }
     get highlightingSemanticTokens() { return this.cfg.get<boolean>("highlighting.semanticTokens")!; }
-    get lruCapacity() { return this.cfg.get<null | number>("lruCapacity")!; }
-    get excludeGlobs() { return this.cfg.get<string[]>("excludeGlobs")!; }
-    get useClientWatching() { return this.cfg.get<boolean>("useClientWatching")!; }
-    get featureFlags() { return this.cfg.get<Record<string, boolean>>("featureFlags")!; }
-    get rustfmtArgs() { return this.cfg.get<string[]>("rustfmtArgs")!; }
-    get loadOutDirsFromCheck() { return this.cfg.get<boolean>("loadOutDirsFromCheck")!; }
     get traceExtension() { return this.cfg.get<boolean>("trace.extension")!; }
 
-    // for internal use
-    get withSysroot() { return this.cfg.get<boolean>("withSysroot", true)!; }
-
     get inlayHints() {
         return {
             typeHints: this.cfg.get<boolean>("inlayHints.typeHints")!,
@@ -91,21 +81,9 @@ export class Config {
         };
     }
 
-    get cargoWatchOptions() {
+    get checkOnSave() {
         return {
-            enable: this.cfg.get<boolean>("cargo-watch.enable")!,
+            command: this.cfg.get<string>("checkOnSave.command")!,
-            arguments: this.cfg.get<string[]>("cargo-watch.arguments")!,
-            allTargets: this.cfg.get<boolean>("cargo-watch.allTargets")!,
-            command: this.cfg.get<string>("cargo-watch.command")!,
-        };
-    }
-
-    get cargoFeatures() {
-        return {
-            noDefaultFeatures: this.cfg.get<boolean>("cargoFeatures.noDefaultFeatures")!,
-            allFeatures: this.cfg.get<boolean>("cargoFeatures.allFeatures")!,
-            features: this.cfg.get<string[]>("cargoFeatures.features")!,
-            loadOutDirsFromCheck: this.cfg.get<boolean>("cargoFeatures.loadOutDirsFromCheck")!,
         };
     }
 }

editors/code/src/ctx.ts

@@ -2,7 +2,7 @@ import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 
 import { Config } from './config';
-import { createClient, configToServerOptions } from './client';
+import { createClient } from './client';
 import { isRustEditor, RustEditor } from './util';
 
 export class Ctx {
@@ -25,7 +25,6 @@ export class Ctx {
         const res = new Ctx(config, extCtx, client, serverPath);
         res.pushCleanup(client.start());
         await client.onReady();
-        client.onRequest('workspace/configuration', _ => [configToServerOptions(config)]);
         return res;
     }
 

editors/code/src/status_display.ts

@@ -7,7 +7,7 @@ import { Ctx } from './ctx';
 const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
 export function activateStatusDisplay(ctx: Ctx) {
-    const statusDisplay = new StatusDisplay(ctx.config.cargoWatchOptions.command);
+    const statusDisplay = new StatusDisplay(ctx.config.checkOnSave.command);
     ctx.pushCleanup(statusDisplay);
     const client = ctx.client;
     if (client != null) {