Unnamed repository; edit this file 'description' to name the repository.
| -rw-r--r-- | crates/hir-expand/src/builtin_fn_macro.rs | 2 | ||||
| -rw-r--r-- | crates/ide-diagnostics/src/handlers/macro_error.rs | 4 | ||||
| -rw-r--r-- | crates/rust-analyzer/src/config.rs | 624 | ||||
| -rw-r--r-- | crates/rust-analyzer/src/config/patch_old_style.rs | 115 | ||||
| -rw-r--r-- | crates/rust-analyzer/src/handlers.rs | 6 | ||||
| -rw-r--r-- | crates/rust-analyzer/src/to_proto.rs | 22 | ||||
| -rw-r--r-- | crates/rust-analyzer/tests/slow-tests/main.rs | 10 | ||||
| -rw-r--r-- | crates/rust-analyzer/tests/slow-tests/support.rs | 6 | ||||
| -rw-r--r-- | docs/user/generated_config.adoc | 405 | ||||
| -rw-r--r-- | editors/code/package.json | 538 | ||||
| -rw-r--r-- | editors/code/src/client.ts | 7 | ||||
| -rw-r--r-- | editors/code/src/config.ts | 87 | ||||
| -rw-r--r-- | editors/code/src/ctx.ts | 2 |
13 files changed, 1134 insertions, 694 deletions
diff --git a/crates/hir-expand/src/builtin_fn_macro.rs b/crates/hir-expand/src/builtin_fn_macro.rs index 687c549748..2be6c78a6e 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 "run build scripts" to fix"#.into(), + r#"`OUT_DIR` not set, enable "build scripts" to fix"#.into(), )); } diff --git a/crates/ide-diagnostics/src/handlers/macro_error.rs b/crates/ide-diagnostics/src/handlers/macro_error.rs index a5bfb302d5..53d0131e02 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 "run build scripts" to fix +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: `OUT_DIR` not set, enable "build scripts" to fix "#, ); } @@ -161,7 +161,7 @@ fn main() { //^^^^^^^^^^^^^ error: could not convert tokens env!("OUT_DIR"); - //^^^^^^^^^^^^^^^ error: `OUT_DIR` not set, enable "run build scripts" to fix + //^^^^^^^^^^^^^^^ error: `OUT_DIR` not set, enable "build scripts" to fix compile_error!("compile_error works"); //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: compile_error works diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs index 1ee5fb7901..119b94f060 100644 --- a/crates/rust-analyzer/src/config.rs +++ b/crates/rust-analyzer/src/config.rs @@ -35,6 +35,15 @@ 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. // @@ -45,85 +54,89 @@ use crate::{ // parsing the old name. config_data! { struct ConfigData { - /// 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", + /// Placeholder expression to use for missing expressions in assists. + assist_expressionFillDefault: ExprFillDefaultDef = "\"todo\"", /// 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_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", + 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", /// Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to /// avoid compiling unnecessary things. - cargo_useRustcWrapperForBuildScripts: bool = "true", - /// Do not activate the `default` feature. + 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_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\"", - /// Do not activate the `default` feature. - checkOnSave_noDefaultFeatures: Option<bool> = "null", - /// Check for a specific target. Defaults to - /// `#rust-analyzer.cargo.target#`. - checkOnSave_target: Option<String> = "null", + /// 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#`. - 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. + /// + /// 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", - /// 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", + /// 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", /// Custom completion snippets. // NOTE: Keep this list in sync with the feature docs of user snippets. - completion_snippets: FxHashMap<String, SnippetDef> = r#"{ + completion_snippets_custom: FxHashMap<String, SnippetDef> = r#"{ "Arc::new": { "postfix": "arc", "body": "Arc::new(${receiver})", @@ -164,24 +177,14 @@ 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_enableExperimental: bool = "false", - /// List of rust-analyzer diagnostics to disable. - diagnostics_disabled: FxHashSet<String> = "[]", + diagnostics_experimental_enable: bool = "false", /// 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> = "{}", @@ -196,110 +199,113 @@ 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 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", + /// 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", /// Whether to show `Debug` action. Only applies when /// `#rust-analyzer.hoverActions.enable#` is set. - hoverActions_debug: bool = "true", + hover_actions_debug_enable: bool = "true", /// Whether to show HoverActions in Rust files. - hoverActions_enable: bool = "true", + hover_actions_enable: bool = "true", /// Whether to show `Go to Type Definition` action. Only applies when /// `#rust-analyzer.hoverActions.enable#` is set. - hoverActions_gotoTypeDef: bool = "true", + hover_actions_gotoTypeDef_enable: bool = "true", /// Whether to show `Implementations` action. Only applies when /// `#rust-analyzer.hoverActions.enable#` is set. - hoverActions_implementations: bool = "true", + hover_actions_implementations_enable: bool = "true", /// Whether to show `References` action. Only applies when /// `#rust-analyzer.hoverActions.enable#` is set. - hoverActions_references: bool = "false", + hover_actions_references_enable: bool = "false", /// Whether to show `Run` action. Only applies when /// `#rust-analyzer.hoverActions.enable#` is set. - hoverActions_run: bool = "true", + 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\"", - /// 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: bool = "true", + inlayHints_chainingHints_enable: bool = "true", /// Whether to show inlay type hints for return types of closures with blocks. - inlayHints_closureReturnTypeHints: bool = "false", - /// Whether to show inlay type hints for compiler inserted reborrows. - inlayHints_reborrowHints: bool = "false", + inlayHints_closureReturnTypeHints_enable: 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", - /// Whether to hide inlay hints for constructors. - inlayHints_hideNamedConstructorHints: bool = "false", + 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", + /// 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: bool = "true", + lens_debug_enable: 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: 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_methodReferences: bool = "false", - /// Whether to show `References` lens for Struct, Enum, Union and Trait. + 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: bool = "false", + lens_references_adt_enable: 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", + lens_references_enumVariant_enable: bool = "false", + /// 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. + /// 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", /// Disable project auto-discovery in favor of explicitly specified set /// of projects. @@ -309,29 +315,33 @@ config_data! { linkedProjects: Vec<ManifestOrProjectJson> = "[]", /// Number of syntax trees rust-analyzer keeps in memory. Defaults to 128. - lruCapacity: Option<usize> = "null", + lru_capacity: 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", - /// Enable support for procedural macros, implies `#rust-analyzer.cargo.runBuildScripts#`. + /// 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#`. 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_overrideCargo: Option<String> = "null", + runnables_command: Option<String> = "null", /// Additional arguments to be passed to cargo for runnables such as /// tests or binaries. For example, it may be `--release`. - runnables_cargoExtraArgs: Vec<String> = "[]", + runnables_extraArgs: 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 @@ -341,7 +351,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. - rustcSource: Option<String> = "null", + rustc_source: Option<String> = "null", /// Additional arguments to `rustfmt`. rustfmt_extraArgs: Vec<String> = "[]", @@ -351,16 +361,28 @@ 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_enableRangeFormatting: bool = "false", + 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", - /// 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\"", } } @@ -400,6 +422,11 @@ impl From<ProjectJson> for LinkedProject { } } +pub struct CallInfoConfig { + pub params_only: bool, + pub docs: bool, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct LensConfig { // runnables @@ -411,7 +438,8 @@ pub struct LensConfig { // references pub method_refs: bool, - pub refs: bool, // for Struct, Enum, Union and Trait + pub refs_adt: bool, // for Struct, Enum, Union and Trait + pub refs_trait: bool, // for Struct, Enum, Union and Trait pub enum_variant_refs: bool, } @@ -421,7 +449,8 @@ impl LensConfig { || self.debug || self.implementations || self.method_refs - || self.refs + || self.refs_adt + || self.refs_trait || self.enum_variant_refs } @@ -434,7 +463,7 @@ impl LensConfig { } pub fn references(&self) -> bool { - self.method_refs || self.refs || self.enum_variant_refs + self.method_refs || self.refs_adt || self.refs_trait || self.enum_variant_refs } } @@ -520,6 +549,7 @@ pub struct ClientCommandsConfig { pub trigger_parameter_hints: bool, } +#[derive(Debug)] pub struct ConfigUpdateError { errors: Vec<(String, serde_json::Error)>, } @@ -564,9 +594,10 @@ 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.iter() { + for (name, def) in self.data.completion_snippets_custom.iter() { if def.prefix.is_empty() && def.postfix.is_empty() { continue; } @@ -685,7 +716,7 @@ impl Config { } pub fn prefill_caches(&self) -> bool { - self.data.cache_warmup + self.data.primeCaches_enable } pub fn location_link(&self) -> bool { @@ -795,9 +826,9 @@ impl Config { pub fn diagnostics(&self) -> DiagnosticsConfig { DiagnosticsConfig { - disable_experimental: !self.data.diagnostics_enableExperimental, + disable_experimental: !self.data.diagnostics_experimental_enable, disabled: self.data.diagnostics_disabled.clone(), - expr_fill_default: match self.data.assist_exprFillDefault { + expr_fill_default: match self.data.assist_expressionFillDefault { ExprFillDefaultDef::Todo => ExprFillDefaultMode::Todo, ExprFillDefaultDef::Default => ExprFillDefaultMode::Default, }, @@ -813,7 +844,7 @@ impl Config { } pub fn lru_capacity(&self) -> Option<usize> { - self.data.lruCapacity + self.data.lru_capacity } pub fn proc_macro_srv(&self) -> Option<(AbsPathBuf, Vec<OsString>)> { @@ -832,7 +863,7 @@ impl Config { } pub fn expand_proc_attr_macros(&self) -> bool { - self.data.experimental_procAttrMacros + self.data.procMacro_attributes_enable } pub fn files(&self) -> FilesConfig { @@ -857,11 +888,11 @@ impl Config { } pub fn run_build_scripts(&self) -> bool { - self.data.cargo_runBuildScripts || self.data.procMacro_enable + self.data.cargo_buildScripts_enable || self.data.procMacro_enable } pub fn cargo(&self) -> CargoConfig { - let rustc_source = self.data.rustcSource.as_ref().map(|rustc_src| { + let rustc_source = self.data.rustc_source.as_ref().map(|rustc_src| { if rustc_src == "discover" { RustcSource::Discover } else { @@ -871,14 +902,17 @@ impl Config { CargoConfig { no_default_features: self.data.cargo_noDefaultFeatures, - all_features: self.data.cargo_allFeatures, - features: self.data.cargo_features.clone(), + all_features: matches!(self.data.cargo_features, CargoFeatures::All), + features: match &self.data.cargo_features { + CargoFeatures::All => vec![], + CargoFeatures::Listed(it) => it.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_useRustcWrapperForBuildScripts, - run_build_script_command: self.data.cargo_runBuildScriptsCommand.clone(), + wrap_rustc_in_build_scripts: self.data.cargo_buildScripts_useRustcWrapper, + run_build_script_command: self.data.cargo_buildScripts_overrideCommand.clone(), } } @@ -891,7 +925,7 @@ impl Config { } Some(_) | None => RustfmtConfig::Rustfmt { extra_args: self.data.rustfmt_extraArgs.clone(), - enable_range_formatting: self.data.rustfmt_enableRangeFormatting, + enable_range_formatting: self.data.rustfmt_rangeFormatting_enable, }, } } @@ -918,15 +952,19 @@ impl Config { .data .checkOnSave_noDefaultFeatures .unwrap_or(self.data.cargo_noDefaultFeatures), - all_features: self - .data - .checkOnSave_allFeatures - .unwrap_or(self.data.cargo_allFeatures), - features: self + all_features: matches!( + self.data.checkOnSave_features.as_ref().unwrap_or(&self.data.cargo_features), + CargoFeatures::All + ), + features: match self .data .checkOnSave_features .clone() - .unwrap_or_else(|| self.data.cargo_features.clone()), + .unwrap_or_else(|| self.data.cargo_features.clone()) + { + CargoFeatures::All => vec![], + CargoFeatures::Listed(it) => it, + }, extra_args: self.data.checkOnSave_extraArgs.clone(), }, }; @@ -935,25 +973,25 @@ impl Config { pub fn runnables(&self) -> RunnablesConfig { RunnablesConfig { - override_cargo: self.data.runnables_overrideCargo.clone(), - cargo_extra_args: self.data.runnables_cargoExtraArgs.clone(), + override_cargo: self.data.runnables_command.clone(), + cargo_extra_args: self.data.runnables_extraArgs.clone(), } } pub fn inlay_hints(&self) -> InlayHintsConfig { InlayHintsConfig { render_colons: self.data.inlayHints_renderColons, - 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, + 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, 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_hideNamedConstructorHints, - reborrow_hints: self.data.inlayHints_reborrowHints, + hide_named_constructor_hints: self.data.inlayHints_typeHints_hideNamedConstructor, + reborrow_hints: self.data.inlayHints_reborrowHints_enable, param_names_for_lifetime_elision_hints: self .data .inlayHints_lifetimeElisionHints_useParameterNames, @@ -963,20 +1001,20 @@ impl Config { fn insert_use_config(&self) -> InsertUseConfig { InsertUseConfig { - granularity: match self.data.assist_importGranularity { + granularity: match self.data.imports_granularity_group { ImportGranularityDef::Preserve => ImportGranularity::Preserve, ImportGranularityDef::Item => ImportGranularity::Item, ImportGranularityDef::Crate => ImportGranularity::Crate, ImportGranularityDef::Module => ImportGranularity::Module, }, - enforce_granularity: self.data.assist_importEnforceGranularity, - prefix_kind: match self.data.assist_importPrefix { + enforce_granularity: self.data.imports_granularity_enforce, + prefix_kind: match self.data.imports_prefix { ImportPrefixDef::Plain => PrefixKind::Plain, ImportPrefixDef::ByCrate => PrefixKind::ByCrate, ImportPrefixDef::BySelf => PrefixKind::BySelf, }, - group: self.data.assist_importGroup, - skip_glob_imports: !self.data.assist_allowMergingIntoGlobImports, + group: self.data.imports_group_enable, + skip_glob_imports: !self.data.imports_merge_glob, } } @@ -987,8 +1025,14 @@ 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: self.data.completion_addCallParenthesis, - add_call_argument_snippets: self.data.completion_addCallArgumentSnippets, + 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) + ), insert_use: self.insert_use_config(), snippet_cap: SnippetCap::new(try_or_def!( self.caps @@ -1021,40 +1065,45 @@ impl Config { } } - pub fn call_info_full(&self) -> bool { - self.data.callInfo_full + pub fn call_info(&self) -> CallInfoConfig { + CallInfoConfig { + params_only: matches!(self.data.signatureInfo_detail, SignatureDetail::Parameters), + docs: self.data.signatureInfo_documentation_enable, + } } pub fn lens(&self) -> LensConfig { LensConfig { - 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, + 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, } } pub fn hover_actions(&self) -> HoverActionsConfig { - let enable = self.experimental("hoverActions") && self.data.hoverActions_enable; + let enable = self.experimental("hoverActions") && self.data.hover_actions_enable; HoverActionsConfig { - 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, + 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, } } pub fn highlighting_strings(&self) -> bool { - self.data.highlighting_strings + self.data.semanticHighlighting_strings_enable } pub fn hover(&self) -> HoverConfig { HoverConfig { - links_in_hover: self.data.hover_linksInHover, - documentation: self.data.hover_documentation.then(|| { + links_in_hover: self.data.hover_links_enable, + documentation: self.data.hover_documentation_enable.then(|| { let is_markdown = try_or_def!(self .caps .text_document @@ -1132,10 +1181,10 @@ impl Config { pub fn highlight_related(&self) -> HighlightRelatedConfig { HighlightRelatedConfig { - references: self.data.highlightRelated_references, - break_points: self.data.highlightRelated_breakPoints, - exit_points: self.data.highlightRelated_exitPoints, - yield_points: self.data.highlightRelated_yieldPoints, + 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, } } @@ -1146,9 +1195,106 @@ 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); +} + #[derive(Deserialize, Debug, Clone, Copy)] #[serde(rename_all = "snake_case")] enum SnippetScopeDef { @@ -1219,9 +1365,7 @@ enum ManifestOrProjectJson { #[derive(Deserialize, Debug, Clone)] #[serde(rename_all = "snake_case")] pub enum ExprFillDefaultDef { - #[serde(alias = "todo")] Todo, - #[serde(alias = "default")] Default, } @@ -1229,21 +1373,34 @@ 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(alias = "true")] + #[serde(deserialize_with = "true_or_always")] Always, - #[serde(alias = "false")] + #[serde(deserialize_with = "false_or_never")] Never, + #[serde(deserialize_with = "de_unit_v::skip_trivial")] SkipTrivial, } @@ -1266,6 +1423,13 @@ enum WorkspaceSymbolSearchScopeDef { #[derive(Deserialize, Debug, Clone)] #[serde(rename_all = "snake_case")] +enum SignatureDetail { + Full, + Parameters, +} + +#[derive(Deserialize, Debug, Clone)] +#[serde(rename_all = "snake_case")] enum WorkspaceSymbolSearchKindDef { OnlyTypes, AllSymbols, @@ -1317,6 +1481,11 @@ 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; @@ -1329,7 +1498,6 @@ 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 @@ -1499,7 +1667,7 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json "maximum": 255 }, "LifetimeElisionDef" => set! { - "type": "string", + "type": ["string", "boolean"], "enum": ["always", "never", "skip_trivial"], "enumDescriptions": [ "Always show lifetime elision hints.", @@ -1507,6 +1675,38 @@ 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 new file mode 100644 index 0000000000..277364cefa --- /dev/null +++ b/crates/rust-analyzer/src/config/patch_old_style.rs @@ -0,0 +1,115 @@ +//! 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 d005cdb985..ec897ec9d9 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 concise = !snap.config.call_info_full(); - let res = to_proto::signature_help(help, concise, snap.config.signature_help_label_offsets()); + let config = snap.config.call_info(); + let res = to_proto::signature_help(help, config, 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, + annotate_references: lens_config.refs_adt, 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 57b0e93765..ffcea078ce 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::Config, + config::{CallInfoConfig, 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, - concise: bool, + config: CallInfoConfig, label_offsets: bool, ) -> lsp_types::SignatureHelp { - let (label, parameters) = match (concise, label_offsets) { - (_, false) => { + let (label, parameters) = match (!config.params_only, label_offsets) { + (concise, false) => { let params = call_info .parameter_labels() .map(|label| lsp_types::ParameterInformation { @@ -388,16 +388,12 @@ pub(crate) fn signature_help( } }; - 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 documentation = call_info.doc.filter(|_| config.docs).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/crates/rust-analyzer/tests/slow-tests/main.rs b/crates/rust-analyzer/tests/slow-tests/main.rs index 147e8c141a..143b63e11c 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,7 +737,9 @@ fn main() { ) .with_config(serde_json::json!({ "cargo": { - "loadOutDirsFromCheck": true, + "buildScripts": { + "enable": true + }, "noSysroot": true, } })) @@ -890,7 +892,9 @@ pub fn foo(_input: TokenStream) -> TokenStream { ) .with_config(serde_json::json!({ "cargo": { - "loadOutDirsFromCheck": true, + "buildScripts": { + "enable": 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 515cdfdc7c..36bffe3210 100644 --- a/crates/rust-analyzer/tests/slow-tests/support.rs +++ b/crates/rust-analyzer/tests/slow-tests/support.rs @@ -36,7 +36,9 @@ 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. - "useRustcWrapperForBuildScripts": false, + "buildScripts": { + "useRustcWrapper": false + }, } }), } @@ -137,7 +139,7 @@ impl<'a> Project<'a> { }, ); config.discovered_projects = Some(discovered_projects); - let _ = config.update(self.config); + config.update(self.config).expect("invalid config"); Server::new(tmp_dir, config) } diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc index a9dcdfd696..bc513601a8 100644 --- a/docs/user/generated_config.adoc +++ b/docs/user/generated_config.adoc @@ -1,42 +1,7 @@ -[[rust-analyzer.assist.exprFillDefault]]rust-analyzer.assist.exprFillDefault (default: `"todo"`):: +[[rust-analyzer.assist.expressionFillDefault]]rust-analyzer.assist.expressionFillDefault (default: `"todo"`):: + -- -Placeholder for missing expressions in assists. --- -[[rust-analyzer.assist.importGranularity]]rust-analyzer.assist.importGranularity (default: `"crate"`):: -+ --- -How imports should be grouped into use statements. --- -[[rust-analyzer.assist.importEnforceGranularity]]rust-analyzer.assist.importEnforceGranularity (default: `false`):: -+ --- -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.assist.importPrefix]]rust-analyzer.assist.importPrefix (default: `"plain"`):: -+ --- -The path structure for newly inserted paths to use. --- -[[rust-analyzer.assist.importGroup]]rust-analyzer.assist.importGroup (default: `true`):: -+ --- -Group inserted imports by the https://rust-analyzer.github.io/manual.html#auto-import[following order]. Groups are separated by newlines. --- -[[rust-analyzer.assist.allowMergingIntoGlobImports]]rust-analyzer.assist.allowMergingIntoGlobImports (default: `true`):: -+ --- -Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`. --- -[[rust-analyzer.cache.warmup]]rust-analyzer.cache.warmup (default: `true`):: -+ --- -Warm up caches on project load. --- -[[rust-analyzer.callInfo.full]]rust-analyzer.callInfo.full (default: `true`):: -+ --- -Show function name and docs in parameter hints. +Placeholder expression to use for missing expressions in assists. -- [[rust-analyzer.cargo.autoreload]]rust-analyzer.cargo.autoreload (default: `true`):: + @@ -44,79 +9,107 @@ Show function name and docs in parameter hints. 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`):: +[[rust-analyzer.cargo.buildScripts.enable]]rust-analyzer.cargo.buildScripts.enable (default: `true`):: + -- -Activate all available features (`--all-features`). +Run build scripts (`build.rs`) for more precise code analysis. -- -[[rust-analyzer.cargo.unsetTest]]rust-analyzer.cargo.unsetTest (default: `["core"]`):: +[[rust-analyzer.cargo.buildScripts.overrideCommand]]rust-analyzer.cargo.buildScripts.overrideCommand (default: `null`):: + -- -Unsets `#[cfg(test)]` for the specified crates. +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 +``` +. +-- +[[rust-analyzer.cargo.buildScripts.useRustcWrapper]]rust-analyzer.cargo.buildScripts.useRustcWrapper (default: `true`):: ++ +-- +Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to +avoid compiling unnecessary things. -- [[rust-analyzer.cargo.features]]rust-analyzer.cargo.features (default: `[]`):: + -- List of features to activate. + +Set this to `"all"` to pass `--all-features` to cargo. -- -[[rust-analyzer.cargo.runBuildScripts]]rust-analyzer.cargo.runBuildScripts (default: `true`):: +[[rust-analyzer.cargo.noDefaultFeatures]]rust-analyzer.cargo.noDefaultFeatures (default: `false`):: + -- -Run build scripts (`build.rs`) for more precise code analysis. +Whether to pass `--no-default-features` to cargo. -- -[[rust-analyzer.cargo.runBuildScriptsCommand]]rust-analyzer.cargo.runBuildScriptsCommand (default: `null`):: +[[rust-analyzer.cargo.noSysroot]]rust-analyzer.cargo.noSysroot (default: `false`):: + -- -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. +Internal config for debugging, disables loading of sysroot crates. -- -[[rust-analyzer.cargo.useRustcWrapperForBuildScripts]]rust-analyzer.cargo.useRustcWrapperForBuildScripts (default: `true`):: +[[rust-analyzer.cargo.target]]rust-analyzer.cargo.target (default: `null`):: + -- -Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to -avoid compiling unnecessary things. +Compilation target override (target triple). -- -[[rust-analyzer.cargo.noDefaultFeatures]]rust-analyzer.cargo.noDefaultFeatures (default: `false`):: +[[rust-analyzer.cargo.unsetTest]]rust-analyzer.cargo.unsetTest (default: `["core"]`):: + -- -Do not activate the `default` feature. +Unsets `#[cfg(test)]` for the specified crates. -- -[[rust-analyzer.cargo.target]]rust-analyzer.cargo.target (default: `null`):: +[[rust-analyzer.checkOnSave.allTargets]]rust-analyzer.checkOnSave.allTargets (default: `true`):: + -- -Compilation target (target triple). +Check all targets and tests (`--all-targets`). -- -[[rust-analyzer.cargo.noSysroot]]rust-analyzer.cargo.noSysroot (default: `false`):: +[[rust-analyzer.checkOnSave.command]]rust-analyzer.checkOnSave.command (default: `"check"`):: + -- -Internal config for debugging, disables loading of sysroot crates. +Cargo command to use for `cargo check`. -- [[rust-analyzer.checkOnSave.enable]]rust-analyzer.checkOnSave.enable (default: `true`):: + -- Run specified `cargo check` command for diagnostics on save. -- -[[rust-analyzer.checkOnSave.allFeatures]]rust-analyzer.checkOnSave.allFeatures (default: `null`):: +[[rust-analyzer.checkOnSave.extraArgs]]rust-analyzer.checkOnSave.extraArgs (default: `[]`):: + -- -Check with all features (`--all-features`). -Defaults to `#rust-analyzer.cargo.allFeatures#`. +Extra arguments for `cargo check`. -- -[[rust-analyzer.checkOnSave.allTargets]]rust-analyzer.checkOnSave.allTargets (default: `true`):: +[[rust-analyzer.checkOnSave.features]]rust-analyzer.checkOnSave.features (default: `null`):: + -- -Check all targets and tests (`--all-targets`). +List of features to activate. Defaults to +`#rust-analyzer.cargo.features#`. + +Set to `"all"` to pass `--all-features` to cargo. -- -[[rust-analyzer.checkOnSave.command]]rust-analyzer.checkOnSave.command (default: `"check"`):: +[[rust-analyzer.checkOnSave.noDefaultFeatures]]rust-analyzer.checkOnSave.noDefaultFeatures (default: `null`):: + -- -Cargo command to use for `cargo check`. +Do not activate the `default` feature. -- -[[rust-analyzer.checkOnSave.noDefaultFeatures]]rust-analyzer.checkOnSave.noDefaultFeatures (default: `null`):: +[[rust-analyzer.checkOnSave.overrideCommand]]rust-analyzer.checkOnSave.overrideCommand (default: `null`):: + -- -Do not activate the `default` feature. +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 +``` +. -- [[rust-analyzer.checkOnSave.target]]rust-analyzer.checkOnSave.target (default: `null`):: + @@ -124,36 +117,34 @@ Do not activate the `default` feature. Check for a specific target. Defaults to `#rust-analyzer.cargo.target#`. -- -[[rust-analyzer.checkOnSave.extraArgs]]rust-analyzer.checkOnSave.extraArgs (default: `[]`):: +[[rust-analyzer.completion.autoimport.enable]]rust-analyzer.completion.autoimport.enable (default: `true`):: + -- -Extra arguments for `cargo check`. +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.checkOnSave.features]]rust-analyzer.checkOnSave.features (default: `null`):: +[[rust-analyzer.completion.autoself.enable]]rust-analyzer.completion.autoself.enable (default: `true`):: + -- -List of features to activate. Defaults to -`#rust-analyzer.cargo.features#`. +Toggles the additional completions that automatically show method calls and field accesses +with `self` prefixed to them when inside a method. -- -[[rust-analyzer.checkOnSave.overrideCommand]]rust-analyzer.checkOnSave.overrideCommand (default: `null`):: +[[rust-analyzer.completion.callable.snippets]]rust-analyzer.completion.callable.snippets (default: `"fill_arguments"`):: + -- -Advanced option, fully override the command rust-analyzer uses for -checking. The command should include `--message-format=json` or -similar option. +Whether to add parenthesis and argument snippets when completing function. -- -[[rust-analyzer.completion.addCallArgumentSnippets]]rust-analyzer.completion.addCallArgumentSnippets (default: `true`):: +[[rust-analyzer.completion.postfix.enable]]rust-analyzer.completion.postfix.enable (default: `true`):: + -- -Whether to add argument snippets when completing functions. -Only applies when `#rust-analyzer.completion.addCallParenthesis#` is set. +Whether to show postfix snippets like `dbg`, `if`, `not`, etc. -- -[[rust-analyzer.completion.addCallParenthesis]]rust-analyzer.completion.addCallParenthesis (default: `true`):: +[[rust-analyzer.completion.privateEditable.enable]]rust-analyzer.completion.privateEditable.enable (default: `false`):: + -- -Whether to add parenthesis when completing functions. +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.completion.snippets]]rust-analyzer.completion.snippets:: +[[rust-analyzer.completion.snippets.custom]]rust-analyzer.completion.snippets.custom:: + -- Default: @@ -203,44 +194,22 @@ Default: Custom completion snippets. -- -[[rust-analyzer.completion.postfix.enable]]rust-analyzer.completion.postfix.enable (default: `true`):: -+ --- -Whether to show postfix snippets like `dbg`, `if`, `not`, etc. --- -[[rust-analyzer.completion.autoimport.enable]]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`):: +[[rust-analyzer.diagnostics.disabled]]rust-analyzer.diagnostics.disabled (default: `[]`):: + -- -Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position. +List of rust-analyzer diagnostics to disable. -- [[rust-analyzer.diagnostics.enable]]rust-analyzer.diagnostics.enable (default: `true`):: + -- Whether to show native rust-analyzer diagnostics. -- -[[rust-analyzer.diagnostics.enableExperimental]]rust-analyzer.diagnostics.enableExperimental (default: `false`):: +[[rust-analyzer.diagnostics.experimental.enable]]rust-analyzer.diagnostics.experimental.enable (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: `{}`):: + -- @@ -263,16 +232,6 @@ 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: `[]`):: + -- @@ -280,115 +239,110 @@ 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.highlightRelated.references]]rust-analyzer.highlightRelated.references (default: `true`):: -+ --- -Enables highlighting of related references while hovering your mouse above any identifier. --- -[[rust-analyzer.highlightRelated.exitPoints]]rust-analyzer.highlightRelated.exitPoints (default: `true`):: -+ --- -Enables highlighting of all exit points while hovering your mouse above any `return`, `?`, or return type arrow (`->`). --- -[[rust-analyzer.highlightRelated.breakPoints]]rust-analyzer.highlightRelated.breakPoints (default: `true`):: +[[rust-analyzer.files.watcher]]rust-analyzer.files.watcher (default: `"client"`):: + -- -Enables highlighting of related references while hovering your mouse `break`, `loop`, `while`, or `for` keywords. +Controls file watching implementation. -- -[[rust-analyzer.highlightRelated.yieldPoints]]rust-analyzer.highlightRelated.yieldPoints (default: `true`):: +[[rust-analyzer.highlightRelated.breakPoints.enable]]rust-analyzer.highlightRelated.breakPoints.enable (default: `true`):: + -- -Enables highlighting of all break points for a loop or block context while hovering your mouse above any `async` or `await` keywords. +Enables highlighting of related references while the cursor is on `break`, `loop`, `while`, or `for` keywords. -- -[[rust-analyzer.highlighting.strings]]rust-analyzer.highlighting.strings (default: `true`):: +[[rust-analyzer.highlightRelated.exitPoints.enable]]rust-analyzer.highlightRelated.exitPoints.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. +Enables highlighting of all exit points while the cursor is on any `return`, `?`, `fn`, or return type arrow (`->`). -- -[[rust-analyzer.hover.documentation]]rust-analyzer.hover.documentation (default: `true`):: +[[rust-analyzer.highlightRelated.references.enable]]rust-analyzer.highlightRelated.references.enable (default: `true`):: + -- -Whether to show documentation on hover. +Enables highlighting of related references while the cursor is on any identifier. -- -[[rust-analyzer.hover.linksInHover]]rust-analyzer.hover.linksInHover (default: `true`):: +[[rust-analyzer.highlightRelated.yieldPoints.enable]]rust-analyzer.highlightRelated.yieldPoints.enable (default: `true`):: + -- -Use markdown syntax for links in hover. +Enables highlighting of all break points for a loop or block context while the cursor is on any `async` or `await` keywords. -- -[[rust-analyzer.hoverActions.debug]]rust-analyzer.hoverActions.debug (default: `true`):: +[[rust-analyzer.hover.actions.debug.enable]]rust-analyzer.hover.actions.debug.enable (default: `true`):: + -- Whether to show `Debug` action. Only applies when `#rust-analyzer.hoverActions.enable#` is set. -- -[[rust-analyzer.hoverActions.enable]]rust-analyzer.hoverActions.enable (default: `true`):: +[[rust-analyzer.hover.actions.enable]]rust-analyzer.hover.actions.enable (default: `true`):: + -- Whether to show HoverActions in Rust files. -- -[[rust-analyzer.hoverActions.gotoTypeDef]]rust-analyzer.hoverActions.gotoTypeDef (default: `true`):: +[[rust-analyzer.hover.actions.gotoTypeDef.enable]]rust-analyzer.hover.actions.gotoTypeDef.enable (default: `true`):: + -- Whether to show `Go to Type Definition` action. Only applies when `#rust-analyzer.hoverActions.enable#` is set. -- -[[rust-analyzer.hoverActions.implementations]]rust-analyzer.hoverActions.implementations (default: `true`):: +[[rust-analyzer.hover.actions.implementations.enable]]rust-analyzer.hover.actions.implementations.enable (default: `true`):: + -- Whether to show `Implementations` action. Only applies when `#rust-analyzer.hoverActions.enable#` is set. -- -[[rust-analyzer.hoverActions.references]]rust-analyzer.hoverActions.references (default: `false`):: +[[rust-analyzer.hover.actions.references.enable]]rust-analyzer.hover.actions.references.enable (default: `false`):: + -- Whether to show `References` action. Only applies when `#rust-analyzer.hoverActions.enable#` is set. -- -[[rust-analyzer.hoverActions.run]]rust-analyzer.hoverActions.run (default: `true`):: +[[rust-analyzer.hover.actions.run.enable]]rust-analyzer.hover.actions.run.enable (default: `true`):: + -- Whether to show `Run` action. Only applies when `#rust-analyzer.hoverActions.enable#` is set. -- -[[rust-analyzer.inlayHints.renderColons]]rust-analyzer.inlayHints.renderColons (default: `true`):: +[[rust-analyzer.hover.documentation.enable]]rust-analyzer.hover.documentation.enable (default: `true`):: + -- -Whether to render trailing colons for parameter hints, and trailing colons for parameter hints. +Whether to show documentation on hover. -- -[[rust-analyzer.inlayHints.maxLength]]rust-analyzer.inlayHints.maxLength (default: `25`):: +[[rust-analyzer.hover.links.enable]]rust-analyzer.hover.links.enable (default: `true`):: + -- -Maximum length for inlay hints. Set to null to have an unlimited length. +Use markdown syntax for links in hover. -- -[[rust-analyzer.inlayHints.parameterHints]]rust-analyzer.inlayHints.parameterHints (default: `true`):: +[[rust-analyzer.imports.granularity.enforce]]rust-analyzer.imports.granularity.enforce (default: `false`):: + -- -Whether to show function parameter name inlay hints at the call -site. +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.inlayHints.typeHints]]rust-analyzer.inlayHints.typeHints (default: `true`):: +[[rust-analyzer.imports.granularity.group]]rust-analyzer.imports.granularity.group (default: `"crate"`):: + -- -Whether to show inlay type hints for variables. +How imports should be grouped into use statements. -- -[[rust-analyzer.inlayHints.chainingHints]]rust-analyzer.inlayHints.chainingHints (default: `true`):: +[[rust-analyzer.imports.group.enable]]rust-analyzer.imports.group.enable (default: `true`):: + -- -Whether to show inlay type hints for method chains. +Group inserted imports by the https://rust-analyzer.github.io/manual.html#auto-import[following order]. Groups are separated by newlines. -- -[[rust-analyzer.inlayHints.closureReturnTypeHints]]rust-analyzer.inlayHints.closureReturnTypeHints (default: `false`):: +[[rust-analyzer.imports.merge.glob]]rust-analyzer.imports.merge.glob (default: `true`):: + -- -Whether to show inlay type hints for return types of closures with blocks. +Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`. -- -[[rust-analyzer.inlayHints.reborrowHints]]rust-analyzer.inlayHints.reborrowHints (default: `false`):: +[[rust-analyzer.imports.prefix]]rust-analyzer.imports.prefix (default: `"plain"`):: + -- -Whether to show inlay type hints for compiler inserted reborrows. +The path structure for newly inserted paths to use. +-- +[[rust-analyzer.inlayHints.chainingHints.enable]]rust-analyzer.inlayHints.chainingHints.enable (default: `true`):: ++ +-- +Whether to show inlay type hints for method chains. +-- +[[rust-analyzer.inlayHints.closureReturnTypeHints.enable]]rust-analyzer.inlayHints.closureReturnTypeHints.enable (default: `false`):: ++ +-- +Whether to show inlay type hints for return types of closures with blocks. -- [[rust-analyzer.inlayHints.lifetimeElisionHints.enable]]rust-analyzer.inlayHints.lifetimeElisionHints.enable (default: `"never"`):: + @@ -400,10 +354,41 @@ 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.hideNamedConstructorHints]]rust-analyzer.inlayHints.hideNamedConstructorHints (default: `false`):: +[[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`):: + -- -Whether to hide inlay hints for constructors. +Join lines merges consecutive declaration and initialization of an assignment. -- [[rust-analyzer.joinLines.joinElseIf]]rust-analyzer.joinLines.joinElseIf (default: `true`):: + @@ -420,12 +405,7 @@ Join lines removes trailing commas. -- Join lines unwraps trivial blocks. -- -[[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`):: +[[rust-analyzer.lens.debug.enable]]rust-analyzer.lens.debug.enable (default: `true`):: + -- Whether to show `Debug` lens. Only applies when @@ -436,41 +416,47 @@ Whether to show `Debug` lens. Only applies when -- Whether to show CodeLens in Rust files. -- -[[rust-analyzer.lens.implementations]]rust-analyzer.lens.implementations (default: `true`):: +[[rust-analyzer.lens.forceCustomCommands]]rust-analyzer.lens.forceCustomCommands (default: `true`):: + -- -Whether to show `Implementations` 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.lens.run]]rust-analyzer.lens.run (default: `true`):: +[[rust-analyzer.lens.implementations.enable]]rust-analyzer.lens.implementations.enable (default: `true`):: + -- -Whether to show `Run` lens. Only applies when +Whether to show `Implementations` lens. Only applies when `#rust-analyzer.lens.enable#` is set. -- -[[rust-analyzer.lens.methodReferences]]rust-analyzer.lens.methodReferences (default: `false`):: +[[rust-analyzer.lens.references.adt.enable]]rust-analyzer.lens.references.adt.enable (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, and Union. +Only applies when `#rust-analyzer.lens.enable#` is set. -- -[[rust-analyzer.lens.references]]rust-analyzer.lens.references (default: `false`):: +[[rust-analyzer.lens.references.enumVariant.enable]]rust-analyzer.lens.references.enumVariant.enable (default: `false`):: + -- -Whether to show `References` lens for Struct, Enum, Union and Trait. +Whether to show `References` lens for Enum Variants. Only applies when `#rust-analyzer.lens.enable#` is set. -- -[[rust-analyzer.lens.enumVariantReferences]]rust-analyzer.lens.enumVariantReferences (default: `false`):: +[[rust-analyzer.lens.references.method.enable]]rust-analyzer.lens.references.method.enable (default: `false`):: + -- -Whether to show `References` lens for Enum Variants. +Whether to show `Method References` lens. Only applies when +`#rust-analyzer.lens.enable#` is set. +-- +[[rust-analyzer.lens.references.trait.enable]]rust-analyzer.lens.references.trait.enable (default: `false`):: ++ +-- +Whether to show `References` lens for Trait. Only applies when `#rust-analyzer.lens.enable#` is set. -- -[[rust-analyzer.lens.forceCustomCommands]]rust-analyzer.lens.forceCustomCommands (default: `true`):: +[[rust-analyzer.lens.run.enable]]rust-analyzer.lens.run.enable (default: `true`):: + -- -Internal config: use custom client-side commands even when the -client doesn't set the corresponding capability. +Whether to show `Run` lens. Only applies when +`#rust-analyzer.lens.enable#` is set. -- [[rust-analyzer.linkedProjects]]rust-analyzer.linkedProjects (default: `[]`):: + @@ -481,7 +467,7 @@ of projects. Elements must be paths pointing to `Cargo.toml`, `rust-project.json`, or JSON objects in `rust-project.json` format. -- -[[rust-analyzer.lruCapacity]]rust-analyzer.lruCapacity (default: `null`):: +[[rust-analyzer.lru.capacity]]rust-analyzer.lru.capacity (default: `null`):: + -- Number of syntax trees rust-analyzer keeps in memory. Defaults to 128. @@ -491,21 +477,25 @@ 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.enable]]rust-analyzer.procMacro.enable (default: `true`):: +[[rust-analyzer.procMacro.attributes.enable]]rust-analyzer.procMacro.attributes.enable (default: `true`):: + -- -Enable support for procedural macros, implies `#rust-analyzer.cargo.runBuildScripts#`. +Expand attribute macros. Requires `#rust-analyzer.procMacro.enable#` to be set. -- -[[rust-analyzer.procMacro.server]]rust-analyzer.procMacro.server (default: `null`):: +[[rust-analyzer.procMacro.enable]]rust-analyzer.procMacro.enable (default: `true`):: + -- -Internal config, path to proc-macro server executable (typically, -this is rust-analyzer itself, but we override this in tests). +Enable support for procedural macros, implies `#rust-analyzer.cargo.buildScripts.enable#`. -- [[rust-analyzer.procMacro.ignored]]rust-analyzer.procMacro.ignored (default: `{}`):: + @@ -514,18 +504,24 @@ 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.runnables.overrideCargo]]rust-analyzer.runnables.overrideCargo (default: `null`):: +[[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`):: + -- Command to be executed instead of 'cargo' for runnables. -- -[[rust-analyzer.runnables.cargoExtraArgs]]rust-analyzer.runnables.cargoExtraArgs (default: `[]`):: +[[rust-analyzer.runnables.extraArgs]]rust-analyzer.runnables.extraArgs (default: `[]`):: + -- Additional arguments to be passed to cargo for runnables such as tests or binaries. For example, it may be `--release`. -- -[[rust-analyzer.rustcSource]]rust-analyzer.rustcSource (default: `null`):: +[[rust-analyzer.rustc.source]]rust-analyzer.rustc.source (default: `null`):: + -- Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private @@ -548,17 +544,31 @@ Additional arguments to `rustfmt`. Advanced option, fully override the command rust-analyzer uses for formatting. -- -[[rust-analyzer.rustfmt.enableRangeFormatting]]rust-analyzer.rustfmt.enableRangeFormatting (default: `false`):: +[[rust-analyzer.rustfmt.rangeFormatting.enable]]rust-analyzer.rustfmt.rangeFormatting.enable (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.workspace.symbol.search.scope]]rust-analyzer.workspace.symbol.search.scope (default: `"workspace"`):: +[[rust-analyzer.semanticHighlighting.strings.enable]]rust-analyzer.semanticHighlighting.strings.enable (default: `true`):: + -- -Workspace symbol search scope. +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`):: ++ +-- +Show documentation. -- [[rust-analyzer.workspace.symbol.search.kind]]rust-analyzer.workspace.symbol.search.kind (default: `"only_types"`):: + @@ -572,3 +582,8 @@ 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 9f0f53196a..515ecd0295 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.exprFillDefault": { - "markdownDescription": "Placeholder for missing expressions in assists.", + "rust-analyzer.assist.expressionFillDefault": { + "markdownDescription": "Placeholder expression to use for missing expressions in assists.", "default": "todo", "type": "string", "enum": [ @@ -381,98 +381,18 @@ "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.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": { + "rust-analyzer.cargo.buildScripts.enable": { "markdownDescription": "Run build scripts (`build.rs`) for more precise code analysis.", "default": true, "type": "boolean" }, - "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.", + "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.", "default": null, "type": [ "null", @@ -482,42 +402,56 @@ "type": "string" } }, - "rust-analyzer.cargo.useRustcWrapperForBuildScripts": { + "rust-analyzer.cargo.buildScripts.useRustcWrapper": { "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": "Do not activate the `default` feature.", + "markdownDescription": "Whether to pass `--no-default-features` to cargo.", "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.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#`.", + "rust-analyzer.cargo.target": { + "markdownDescription": "Compilation target override (target triple).", "default": null, "type": [ "null", - "boolean" + "string" ] }, + "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, @@ -528,21 +462,10 @@ "default": "check", "type": "string" }, - "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.enable": { + "markdownDescription": "Run specified `cargo check` command for diagnostics on save.", + "default": true, + "type": "boolean" }, "rust-analyzer.checkOnSave.extraArgs": { "markdownDescription": "Extra arguments for `cargo check`.", @@ -553,18 +476,33 @@ } }, "rust-analyzer.checkOnSave.features": { - "markdownDescription": "List of features to activate. Defaults to\n`#rust-analyzer.cargo.features#`.", + "markdownDescription": "List of features to activate. Defaults to\n`#rust-analyzer.cargo.features#`.\n\nSet to `\"all\"` to pass `--all-features` to cargo.", "default": null, "type": [ - "null", - "array" + "string", + "array", + "null" ], "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": "Advanced option, fully override the command rust-analyzer uses for\nchecking. The command should include `--message-format=json` or\nsimilar option.", + "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.", "default": null, "type": [ "null", @@ -574,17 +512,51 @@ "type": "string" } }, - "rust-analyzer.completion.addCallArgumentSnippets": { - "markdownDescription": "Whether to add argument snippets when completing functions.\nOnly applies when `#rust-analyzer.completion.addCallParenthesis#` is set.", + "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.", "default": true, "type": "boolean" }, - "rust-analyzer.completion.addCallParenthesis": { - "markdownDescription": "Whether to add parenthesis when completing functions.", + "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.", "default": true, "type": "boolean" }, - "rust-analyzer.completion.snippets": { + "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": { "markdownDescription": "Custom completion snippets.", "default": { "Arc::new": { @@ -629,45 +601,25 @@ }, "type": "object" }, - "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.disabled": { + "markdownDescription": "List of rust-analyzer diagnostics to disable.", + "default": [], + "type": "array", + "items": { + "type": "string" + }, + "uniqueItems": true }, "rust-analyzer.diagnostics.enable": { "markdownDescription": "Whether to show native rust-analyzer diagnostics.", "default": true, "type": "boolean" }, - "rust-analyzer.diagnostics.enableExperimental": { + "rust-analyzer.diagnostics.experimental.enable": { "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": {}, @@ -689,16 +641,6 @@ "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": [], @@ -707,114 +649,135 @@ "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.files.watcher": { + "markdownDescription": "Controls file watching implementation.", + "default": "client", + "type": "string" }, - "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.", + "rust-analyzer.highlightRelated.breakPoints.enable": { + "markdownDescription": "Enables highlighting of related references while the cursor is on `break`, `loop`, `while`, or `for` keywords.", "default": true, "type": "boolean" }, - "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.", + "rust-analyzer.highlightRelated.exitPoints.enable": { + "markdownDescription": "Enables highlighting of all exit points while the cursor is on any `return`, `?`, `fn`, or return type arrow (`->`).", "default": true, "type": "boolean" }, - "rust-analyzer.hover.documentation": { - "markdownDescription": "Whether to show documentation on hover.", + "rust-analyzer.highlightRelated.references.enable": { + "markdownDescription": "Enables highlighting of related references while the cursor is on any identifier.", "default": true, "type": "boolean" }, - "rust-analyzer.hover.linksInHover": { - "markdownDescription": "Use markdown syntax for links in hover.", + "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.", "default": true, "type": "boolean" }, - "rust-analyzer.hoverActions.debug": { + "rust-analyzer.hover.actions.debug.enable": { "markdownDescription": "Whether to show `Debug` action. Only applies when\n`#rust-analyzer.hoverActions.enable#` is set.", "default": true, "type": "boolean" }, - "rust-analyzer.hoverActions.enable": { + "rust-analyzer.hover.actions.enable": { "markdownDescription": "Whether to show HoverActions in Rust files.", "default": true, "type": "boolean" }, - "rust-analyzer.hoverActions.gotoTypeDef": { + "rust-analyzer.hover.actions.gotoTypeDef.enable": { "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.hoverActions.implementations": { + "rust-analyzer.hover.actions.implementations.enable": { "markdownDescription": "Whether to show `Implementations` action. Only applies when\n`#rust-analyzer.hoverActions.enable#` is set.", "default": true, "type": "boolean" }, - "rust-analyzer.hoverActions.references": { + "rust-analyzer.hover.actions.references.enable": { "markdownDescription": "Whether to show `References` action. Only applies when\n`#rust-analyzer.hoverActions.enable#` is set.", "default": false, "type": "boolean" }, - "rust-analyzer.hoverActions.run": { + "rust-analyzer.hover.actions.run.enable": { "markdownDescription": "Whether to show `Run` action. Only applies when\n`#rust-analyzer.hoverActions.enable#` is set.", "default": true, "type": "boolean" }, - "rust-analyzer.inlayHints.renderColons": { - "markdownDescription": "Whether to render trailing colons for parameter hints, and trailing colons for parameter hints.", + "rust-analyzer.hover.documentation.enable": { + "markdownDescription": "Whether to show documentation on hover.", "default": true, "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" + "rust-analyzer.hover.links.enable": { + "markdownDescription": "Use markdown syntax for links in hover.", + "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" ], - "minimum": 0 + "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.inlayHints.parameterHints": { - "markdownDescription": "Whether to show function parameter name inlay hints at the call\nsite.", + "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.", "default": true, "type": "boolean" }, - "rust-analyzer.inlayHints.typeHints": { - "markdownDescription": "Whether to show inlay type hints for variables.", + "rust-analyzer.imports.merge.glob": { + "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.inlayHints.chainingHints": { + "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": { "markdownDescription": "Whether to show inlay type hints for method chains.", "default": true, "type": "boolean" }, - "rust-analyzer.inlayHints.closureReturnTypeHints": { + "rust-analyzer.inlayHints.closureReturnTypeHints.enable": { "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", + "type": [ + "string", + "boolean" + ], "enum": [ "always", "never", @@ -831,11 +794,45 @@ "default": false, "type": "boolean" }, - "rust-analyzer.inlayHints.hideNamedConstructorHints": { - "markdownDescription": "Whether to hide inlay hints for constructors.", + "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.", "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, @@ -851,12 +848,7 @@ "default": true, "type": "boolean" }, - "rust-analyzer.joinLines.joinAssignments": { - "markdownDescription": "Join lines merges consecutive declaration and initialization of an assignment.", - "default": true, - "type": "boolean" - }, - "rust-analyzer.lens.debug": { + "rust-analyzer.lens.debug.enable": { "markdownDescription": "Whether to show `Debug` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.", "default": true, "type": "boolean" @@ -866,33 +858,38 @@ "default": true, "type": "boolean" }, - "rust-analyzer.lens.implementations": { - "markdownDescription": "Whether to show `Implementations` 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" }, - "rust-analyzer.lens.run": { - "markdownDescription": "Whether to show `Run` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.", + "rust-analyzer.lens.implementations.enable": { + "markdownDescription": "Whether to show `Implementations` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.", "default": true, "type": "boolean" }, - "rust-analyzer.lens.methodReferences": { - "markdownDescription": "Whether to show `Method References` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.", + "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, "type": "boolean" }, - "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.", + "rust-analyzer.lens.references.enumVariant.enable": { + "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.enumVariantReferences": { - "markdownDescription": "Whether to show `References` lens for Enum Variants.\nOnly applies when `#rust-analyzer.lens.enable#` is set.", + "rust-analyzer.lens.references.method.enable": { + "markdownDescription": "Whether to show `Method References` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.", "default": false, "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.references.trait.enable": { + "markdownDescription": "Whether to show `References` lens for Trait.\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.", "default": true, "type": "boolean" }, @@ -907,7 +904,7 @@ ] } }, - "rust-analyzer.lruCapacity": { + "rust-analyzer.lru.capacity": { "markdownDescription": "Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.", "default": null, "type": [ @@ -921,6 +918,11 @@ "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, @@ -928,11 +930,21 @@ "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.runBuildScripts#`.", + "markdownDescription": "Enable support for procedural macros, implies `#rust-analyzer.cargo.buildScripts.enable#`.", "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, @@ -941,12 +953,7 @@ "string" ] }, - "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": { + "rust-analyzer.runnables.command": { "markdownDescription": "Command to be executed instead of 'cargo' for runnables.", "default": null, "type": [ @@ -954,7 +961,7 @@ "string" ] }, - "rust-analyzer.runnables.cargoExtraArgs": { + "rust-analyzer.runnables.extraArgs": { "markdownDescription": "Additional arguments to be passed to cargo for runnables such as\ntests or binaries. For example, it may be `--release`.", "default": [], "type": "array", @@ -962,7 +969,7 @@ "type": "string" } }, - "rust-analyzer.rustcSource": { + "rust-analyzer.rustc.source": { "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": [ @@ -989,24 +996,34 @@ "type": "string" } }, - "rust-analyzer.rustfmt.enableRangeFormatting": { + "rust-analyzer.rustfmt.rangeFormatting.enable": { "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.workspace.symbol.search.scope": { - "markdownDescription": "Workspace symbol search scope.", - "default": "workspace", + "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", "type": "string", "enum": [ - "workspace", - "workspace_and_dependencies" + "full", + "parameters" ], "enumDescriptions": [ - "Search in current workspace only", - "Search in current workspace and dependencies" + "Show the entire signature.", + "Show only the parameters." ] }, + "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", @@ -1026,6 +1043,19 @@ "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 f7520f6c43..99b72635d1 100644 --- a/editors/code/src/client.ts +++ b/editors/code/src/client.ts @@ -5,6 +5,7 @@ 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; @@ -24,7 +25,7 @@ function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownStri return result; } -export function createClient(serverPath: string, workspace: Workspace, extraEnv: Env): lc.LanguageClient { +export async function createClient(serverPath: string, workspace: Workspace, extraEnv: Env): Promise<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. @@ -45,6 +46,10 @@ export function createClient(serverPath: string, workspace: Workspace, extraEnv: ); 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 183521c10c..5b650e1420 100644 --- a/editors/code/src/config.ts +++ b/editors/code/src/config.ts @@ -18,7 +18,6 @@ export class Config { "cargo", "procMacro", "files", - "highlighting", "lens", // works as lens.* ] .map(opt => `${this.rootSection}.${opt}`); @@ -79,7 +78,7 @@ export class Config { * const nullableNum = vscode * .workspace * .getConfiguration - * .getConfiguration("rust-analyer") + * .getConfiguration("rust-analyzer") * .get<number | null>(path)!; * * // What happens is that type of `nullableNum` is `number` but not `null | number`: @@ -124,11 +123,11 @@ export class Config { get hoverActions() { return { enable: this.get<boolean>("hoverActions.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"), + 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"), }; } @@ -136,3 +135,77 @@ 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 666a4b6972..0c3e6810e9 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 = createClient(serverPath, workspace, config.serverExtraEnv); + const client = await createClient(serverPath, workspace, config.serverExtraEnv); const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left); extCtx.subscriptions.push(statusBar); |