crates/rust-analyzer/src/config.rs

   1 //! Config used by the language server.
   2 //!
   3 //! We currently get this config from `initialize` LSP request, which is not the
   4 //! best way to do it, but was the simplest thing we could implement.
   5 //!
   6 //! Of particular interest is the `feature_flags` hash map: while other fields
   7 //! configure the server itself, feature flags are passed into analysis, and
   8 //! tweak things like automatic insertion of `()` in completions.
   9
  10 use std::{ffi::OsString, iter, path::PathBuf};
  11
  12 use flycheck::FlycheckConfig;
  13 use ide::{
  14     AssistConfig, CompletionConfig, DiagnosticsConfig, HighlightRelatedConfig, HoverConfig,
  15     HoverDocFormat, InlayHintsConfig, JoinLinesConfig, Snippet, SnippetScope,
  16 };
  17 use ide_db::helpers::{
  18     insert_use::{ImportGranularity, InsertUseConfig, PrefixKind},
  19     SnippetCap,
  20 };
  21 use lsp_types::{ClientCapabilities, MarkupKind};
  22 use project_model::{
  23     CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest, RustcSource, UnsetTestCrates,
  24 };
  25 use rustc_hash::{FxHashMap, FxHashSet};
  26 use serde::{de::DeserializeOwned, Deserialize};
  27 use vfs::AbsPathBuf;
  28
  29 use crate::{
  30     caps::completion_item_edit_resolve,
  31     diagnostics::DiagnosticsMapConfig,
  32     line_index::OffsetEncoding,
  33     lsp_ext::supports_utf8,
  34     lsp_ext::WorkspaceSymbolSearchScope,
  35     lsp_ext::{self, WorkspaceSymbolSearchKind},
  36 };
  37
  38 // Defines the server-side configuration of the rust-analyzer. We generate
  39 // *parts* of VS Code's `package.json` config from this.
  40 //
  41 // However, editor specific config, which the server doesn't know about, should
  42 // be specified directly in `package.json`.
  43 //
  44 // To deprecate an option by replacing it with another name use `new_name | `old_name` so that we keep
  45 // parsing the old name.
  46 config_data! {
  47     struct ConfigData {
  48         /// How imports should be grouped into use statements.
  49         assist_importGranularity |
  50         assist_importMergeBehavior |
  51         assist_importMergeBehaviour: ImportGranularityDef  = "\"crate\"",
  52         /// 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.
  53         assist_importEnforceGranularity: bool              = "false",
  54         /// The path structure for newly inserted paths to use.
  55         assist_importPrefix: ImportPrefixDef               = "\"plain\"",
  56         /// Group inserted imports by the https://rust-analyzer.github.io/manual.html#auto-import[following order]. Groups are separated by newlines.
  57         assist_importGroup: bool                           = "true",
  58         /// Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.
  59         assist_allowMergingIntoGlobImports: bool           = "true",
  60
  61         /// Warm up caches on project load.
  62         cache_warmup: bool = "true",
  63
  64         /// Show function name and docs in parameter hints.
  65         callInfo_full: bool                                = "true",
  66
  67         /// Automatically refresh project info via `cargo metadata` on
  68         /// `Cargo.toml` changes.
  69         cargo_autoreload: bool           = "true",
  70         /// Activate all available features (`--all-features`).
  71         cargo_allFeatures: bool          = "false",
  72         /// Unsets `#[cfg(test)]` for the specified crates.
  73         cargo_unsetTest: Vec<String>   = "[\"core\"]",
  74         /// List of features to activate.
  75         cargo_features: Vec<String>      = "[]",
  76         /// Run build scripts (`build.rs`) for more precise code analysis.
  77         cargo_runBuildScripts |
  78         cargo_loadOutDirsFromCheck: bool = "true",
  79         /// Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to
  80         /// avoid compiling unnecessary things.
  81         cargo_useRustcWrapperForBuildScripts: bool = "true",
  82         /// Do not activate the `default` feature.
  83         cargo_noDefaultFeatures: bool    = "false",
  84         /// Compilation target (target triple).
  85         cargo_target: Option<String>     = "null",
  86         /// Internal config for debugging, disables loading of sysroot crates.
  87         cargo_noSysroot: bool            = "false",
  88
  89         /// Run specified `cargo check` command for diagnostics on save.
  90         checkOnSave_enable: bool                         = "true",
  91         /// Check with all features (`--all-features`).
  92         /// Defaults to `#rust-analyzer.cargo.allFeatures#`.
  93         checkOnSave_allFeatures: Option<bool>            = "null",
  94         /// Check all targets and tests (`--all-targets`).
  95         checkOnSave_allTargets: bool                     = "true",
  96         /// Cargo command to use for `cargo check`.
  97         checkOnSave_command: String                      = "\"check\"",
  98         /// Do not activate the `default` feature.
  99         checkOnSave_noDefaultFeatures: Option<bool>      = "null",
 100         /// Check for a specific target. Defaults to
 101         /// `#rust-analyzer.cargo.target#`.
 102         checkOnSave_target: Option<String>               = "null",
 103         /// Extra arguments for `cargo check`.
 104         checkOnSave_extraArgs: Vec<String>               = "[]",
 105         /// List of features to activate. Defaults to
 106         /// `#rust-analyzer.cargo.features#`.
 107         checkOnSave_features: Option<Vec<String>>        = "null",
 108         /// Advanced option, fully override the command rust-analyzer uses for
 109         /// checking. The command should include `--message-format=json` or
 110         /// similar option.
 111         checkOnSave_overrideCommand: Option<Vec<String>> = "null",
 112
 113         /// Whether to add argument snippets when completing functions.
 114         /// Only applies when `#rust-analyzer.completion.addCallParenthesis#` is set.
 115         completion_addCallArgumentSnippets: bool = "true",
 116         /// Whether to add parenthesis when completing functions.
 117         completion_addCallParenthesis: bool      = "true",
 118         /// Custom completion snippets.
 119         // NOTE: Keep this list in sync with the feature docs of user snippets.
 120         completion_snippets: FxHashMap<String, SnippetDef> = r#"{
 121             "Arc::new": {
 122                 "postfix": "arc",
 123                 "body": "Arc::new(${receiver})",
 124                 "requires": "std::sync::Arc",
 125                 "description": "Put the expression into an `Arc`",
 126                 "scope": "expr"
 127             },
 128             "Rc::new": {
 129                 "postfix": "rc",
 130                 "body": "Rc::new(${receiver})",
 131                 "requires": "std::rc::Rc",
 132                 "description": "Put the expression into an `Rc`",
 133                 "scope": "expr"
 134             },
 135             "Box::pin": {
 136                 "postfix": "pinbox",
 137                 "body": "Box::pin(${receiver})",
 138                 "requires": "std::boxed::Box",
 139                 "description": "Put the expression into a pinned `Box`",
 140                 "scope": "expr"
 141             },
 142             "Ok": {
 143                 "postfix": "ok",
 144                 "body": "Ok(${receiver})",
 145                 "description": "Wrap the expression in a `Result::Ok`",
 146                 "scope": "expr"
 147             },
 148             "Err": {
 149                 "postfix": "err",
 150                 "body": "Err(${receiver})",
 151                 "description": "Wrap the expression in a `Result::Err`",
 152                 "scope": "expr"
 153             },
 154             "Some": {
 155                 "postfix": "some",
 156                 "body": "Some(${receiver})",
 157                 "description": "Wrap the expression in an `Option::Some`",
 158                 "scope": "expr"
 159             }
 160         }"#,
 161         /// Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
 162         completion_postfix_enable: bool          = "true",
 163         /// Toggles the additional completions that automatically add imports when completed.
 164         /// Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
 165         completion_autoimport_enable: bool       = "true",
 166         /// Toggles the additional completions that automatically show method calls and field accesses
 167         /// with `self` prefixed to them when inside a method.
 168         completion_autoself_enable: bool       = "true",
 169
 170         /// Whether to show native rust-analyzer diagnostics.
 171         diagnostics_enable: bool                = "true",
 172         /// Whether to show experimental rust-analyzer diagnostics that might
 173         /// have more false positives than usual.
 174         diagnostics_enableExperimental: bool    = "true",
 175         /// List of rust-analyzer diagnostics to disable.
 176         diagnostics_disabled: FxHashSet<String> = "[]",
 177         /// Map of prefixes to be substituted when parsing diagnostic file paths.
 178         /// This should be the reverse mapping of what is passed to `rustc` as `--remap-path-prefix`.
 179         diagnostics_remapPrefix: FxHashMap<String, String> = "{}",
 180         /// List of warnings that should be displayed with hint severity.
 181         ///
 182         /// The warnings will be indicated by faded text or three dots in code
 183         /// and will not show up in the `Problems Panel`.
 184         diagnostics_warningsAsHint: Vec<String> = "[]",
 185         /// List of warnings that should be displayed with info severity.
 186         ///
 187         /// The warnings will be indicated by a blue squiggly underline in code
 188         /// and a blue icon in the `Problems Panel`.
 189         diagnostics_warningsAsInfo: Vec<String> = "[]",
 190
 191         /// Expand attribute macros.
 192         experimental_procAttrMacros: bool = "true",
 193
 194         /// Controls file watching implementation.
 195         files_watcher: String = "\"client\"",
 196         /// These directories will be ignored by rust-analyzer. They are
 197         /// relative to the workspace root, and globs are not supported. You may
 198         /// also need to add the folders to Code's `files.watcherExclude`.
 199         files_excludeDirs: Vec<PathBuf> = "[]",
 200
 201         /// Enables highlighting of related references while hovering your mouse above any identifier.
 202         highlightRelated_references: bool = "true",
 203         /// Enables highlighting of all exit points while hovering your mouse above any `return`, `?`, or return type arrow (`->`).
 204         highlightRelated_exitPoints: bool = "true",
 205         /// Enables highlighting of related references while hovering your mouse `break`, `loop`, `while`, or `for` keywords.
 206         highlightRelated_breakPoints: bool = "true",
 207         /// Enables highlighting of all break points for a loop or block context while hovering your mouse above any `async` or `await` keywords.
 208         highlightRelated_yieldPoints: bool = "true",
 209
 210         /// Use semantic tokens for strings.
 211         ///
 212         /// In some editors (e.g. vscode) semantic tokens override other highlighting grammars.
 213         /// By disabling semantic tokens for strings, other grammars can be used to highlight
 214         /// their contents.
 215         highlighting_strings: bool = "true",
 216
 217         /// Whether to show documentation on hover.
 218         hover_documentation: bool       = "true",
 219         /// Use markdown syntax for links in hover.
 220         hover_linksInHover |
 221         hoverActions_linksInHover: bool = "true",
 222
 223         /// Whether to show `Debug` action. Only applies when
 224         /// `#rust-analyzer.hoverActions.enable#` is set.
 225         hoverActions_debug: bool           = "true",
 226         /// Whether to show HoverActions in Rust files.
 227         hoverActions_enable: bool          = "true",
 228         /// Whether to show `Go to Type Definition` action. Only applies when
 229         /// `#rust-analyzer.hoverActions.enable#` is set.
 230         hoverActions_gotoTypeDef: bool     = "true",
 231         /// Whether to show `Implementations` action. Only applies when
 232         /// `#rust-analyzer.hoverActions.enable#` is set.
 233         hoverActions_implementations: bool = "true",
 234         /// Whether to show `References` action. Only applies when
 235         /// `#rust-analyzer.hoverActions.enable#` is set.
 236         hoverActions_references: bool      = "false",
 237         /// Whether to show `Run` action. Only applies when
 238         /// `#rust-analyzer.hoverActions.enable#` is set.
 239         hoverActions_run: bool             = "true",
 240
 241         /// Whether to show inlay type hints for method chains.
 242         inlayHints_chainingHints: bool              = "true",
 243         /// Maximum length for inlay hints. Set to null to have an unlimited length.
 244         inlayHints_maxLength: Option<usize>         = "25",
 245         /// Whether to show function parameter name inlay hints at the call
 246         /// site.
 247         inlayHints_parameterHints: bool             = "true",
 248         /// Whether to show inlay type hints for variables.
 249         inlayHints_typeHints: bool                  = "true",
 250         /// Whether to hide inlay hints for constructors.
 251         inlayHints_hideNamedConstructorHints: bool  = "false",
 252
 253         /// Join lines inserts else between consecutive ifs.
 254         joinLines_joinElseIf: bool = "true",
 255         /// Join lines removes trailing commas.
 256         joinLines_removeTrailingComma: bool = "true",
 257         /// Join lines unwraps trivial blocks.
 258         joinLines_unwrapTrivialBlock: bool = "true",
 259         /// Join lines merges consecutive declaration and initialization of an assignment.
 260         joinLines_joinAssignments: bool = "true",
 261
 262         /// Whether to show `Debug` lens. Only applies when
 263         /// `#rust-analyzer.lens.enable#` is set.
 264         lens_debug: bool            = "true",
 265         /// Whether to show CodeLens in Rust files.
 266         lens_enable: bool           = "true",
 267         /// Whether to show `Implementations` lens. Only applies when
 268         /// `#rust-analyzer.lens.enable#` is set.
 269         lens_implementations: bool  = "true",
 270         /// Whether to show `Run` lens. Only applies when
 271         /// `#rust-analyzer.lens.enable#` is set.
 272         lens_run: bool              = "true",
 273         /// Whether to show `Method References` lens. Only applies when
 274         /// `#rust-analyzer.lens.enable#` is set.
 275         lens_methodReferences: bool = "false",
 276         /// Whether to show `References` lens for Struct, Enum, Union and Trait.
 277         /// Only applies when `#rust-analyzer.lens.enable#` is set.
 278         lens_references: bool = "false",
 279         /// Whether to show `References` lens for Enum Variants.
 280         /// Only applies when `#rust-analyzer.lens.enable#` is set.
 281         lens_enumVariantReferences: bool = "false",
 282         /// Internal config: use custom client-side commands even when the
 283         /// client doesn't set the corresponding capability.
 284         lens_forceCustomCommands: bool = "true",
 285
 286         /// Disable project auto-discovery in favor of explicitly specified set
 287         /// of projects.
 288         ///
 289         /// Elements must be paths pointing to `Cargo.toml`,
 290         /// `rust-project.json`, or JSON objects in `rust-project.json` format.
 291         linkedProjects: Vec<ManifestOrProjectJson> = "[]",
 292
 293         /// Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.
 294         lruCapacity: Option<usize>                 = "null",
 295
 296         /// Whether to show `can't find Cargo.toml` error message.
 297         notifications_cargoTomlNotFound: bool      = "true",
 298
 299         /// Enable support for procedural macros, implies `#rust-analyzer.cargo.runBuildScripts#`.
 300         procMacro_enable: bool                     = "true",
 301         /// Internal config, path to proc-macro server executable (typically,
 302         /// this is rust-analyzer itself, but we override this in tests).
 303         procMacro_server: Option<PathBuf>          = "null",
 304
 305         /// Command to be executed instead of 'cargo' for runnables.
 306         runnables_overrideCargo: Option<String> = "null",
 307         /// Additional arguments to be passed to cargo for runnables such as
 308         /// tests or binaries. For example, it may be `--release`.
 309         runnables_cargoExtraArgs: Vec<String>   = "[]",
 310
 311         /// Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private
 312         /// projects, or "discover" to try to automatically find it if the `rustc-dev` component
 313         /// is installed.
 314         ///
 315         /// Any project which uses rust-analyzer with the rustcPrivate
 316         /// crates must set `[package.metadata.rust-analyzer] rustc_private=true` to use it.
 317         ///
 318         /// This option does not take effect until rust-analyzer is restarted.
 319         rustcSource: Option<String> = "null",
 320
 321         /// Additional arguments to `rustfmt`.
 322         rustfmt_extraArgs: Vec<String>               = "[]",
 323         /// Advanced option, fully override the command rust-analyzer uses for
 324         /// formatting.
 325         rustfmt_overrideCommand: Option<Vec<String>> = "null",
 326         /// Enables the use of rustfmt's unstable range formatting command for the
 327         /// `textDocument/rangeFormatting` request. The rustfmt option is unstable and only
 328         /// available on a nightly build.
 329         rustfmt_enableRangeFormatting: bool = "false",
 330
 331         /// Workspace symbol search scope.
 332         workspace_symbol_search_scope: WorkspaceSymbolSearchScopeDef = "\"workspace\"",
 333         /// Workspace symbol search kind.
 334         workspace_symbol_search_kind: WorkspaceSymbolSearchKindDef = "\"only_types\"",
 335     }
 336 }
 337
 338 impl Default for ConfigData {
 339     fn default() -> Self {
 340         ConfigData::from_json(serde_json::Value::Null)
 341     }
 342 }
 343
 344 #[derive(Debug, Clone)]
 345 pub struct Config {
 346     pub caps: lsp_types::ClientCapabilities,
 347     data: ConfigData,
 348     detached_files: Vec<AbsPathBuf>,
 349     pub discovered_projects: Option<Vec<ProjectManifest>>,
 350     pub root_path: AbsPathBuf,
 351     snippets: Vec<Snippet>,
 352 }
 353
 354 #[derive(Debug, Clone, Eq, PartialEq)]
 355 pub enum LinkedProject {
 356     ProjectManifest(ProjectManifest),
 357     InlineJsonProject(ProjectJson),
 358 }
 359
 360 impl From<ProjectManifest> for LinkedProject {
 361     fn from(v: ProjectManifest) -> Self {
 362         LinkedProject::ProjectManifest(v)
 363     }
 364 }
 365
 366 impl From<ProjectJson> for LinkedProject {
 367     fn from(v: ProjectJson) -> Self {
 368         LinkedProject::InlineJsonProject(v)
 369     }
 370 }
 371
 372 #[derive(Clone, Debug, PartialEq, Eq)]
 373 pub struct LensConfig {
 374     pub run: bool,
 375     pub debug: bool,
 376     pub implementations: bool,
 377     pub method_refs: bool,
 378     pub refs: bool, // for Struct, Enum, Union and Trait
 379     pub enum_variant_refs: bool,
 380 }
 381
 382 impl LensConfig {
 383     pub fn any(&self) -> bool {
 384         self.implementations || self.runnable() || self.references()
 385     }
 386
 387     pub fn none(&self) -> bool {
 388         !self.any()
 389     }
 390
 391     pub fn runnable(&self) -> bool {
 392         self.run || self.debug
 393     }
 394
 395     pub fn references(&self) -> bool {
 396         self.method_refs || self.refs || self.enum_variant_refs
 397     }
 398 }
 399
 400 #[derive(Clone, Debug, PartialEq, Eq)]
 401 pub struct HoverActionsConfig {
 402     pub implementations: bool,
 403     pub references: bool,
 404     pub run: bool,
 405     pub debug: bool,
 406     pub goto_type_def: bool,
 407 }
 408
 409 impl HoverActionsConfig {
 410     pub const NO_ACTIONS: Self = Self {
 411         implementations: false,
 412         references: false,
 413         run: false,
 414         debug: false,
 415         goto_type_def: false,
 416     };
 417
 418     pub fn any(&self) -> bool {
 419         self.implementations || self.references || self.runnable() || self.goto_type_def
 420     }
 421
 422     pub fn none(&self) -> bool {
 423         !self.any()
 424     }
 425
 426     pub fn runnable(&self) -> bool {
 427         self.run || self.debug
 428     }
 429 }
 430
 431 #[derive(Debug, Clone)]
 432 pub struct FilesConfig {
 433     pub watcher: FilesWatcher,
 434     pub exclude: Vec<AbsPathBuf>,
 435 }
 436
 437 #[derive(Debug, Clone)]
 438 pub enum FilesWatcher {
 439     Client,
 440     Notify,
 441 }
 442
 443 #[derive(Debug, Clone)]
 444 pub struct NotificationsConfig {
 445     pub cargo_toml_not_found: bool,
 446 }
 447
 448 #[derive(Debug, Clone)]
 449 pub enum RustfmtConfig {
 450     Rustfmt { extra_args: Vec<String>, enable_range_formatting: bool },
 451     CustomCommand { command: String, args: Vec<String> },
 452 }
 453
 454 /// Configuration for runnable items, such as `main` function or tests.
 455 #[derive(Debug, Clone)]
 456 pub struct RunnablesConfig {
 457     /// Custom command to be executed instead of `cargo` for runnables.
 458     pub override_cargo: Option<String>,
 459     /// Additional arguments for the `cargo`, e.g. `--release`.
 460     pub cargo_extra_args: Vec<String>,
 461 }
 462
 463 /// Configuration for workspace symbol search requests.
 464 #[derive(Debug, Clone)]
 465 pub struct WorkspaceSymbolConfig {
 466     /// In what scope should the symbol be searched in.
 467     pub search_scope: WorkspaceSymbolSearchScope,
 468     /// What kind of symbol is being search for.
 469     pub search_kind: WorkspaceSymbolSearchKind,
 470 }
 471
 472 pub struct ClientCommandsConfig {
 473     pub run_single: bool,
 474     pub debug_single: bool,
 475     pub show_reference: bool,
 476     pub goto_location: bool,
 477     pub trigger_parameter_hints: bool,
 478 }
 479
 480 impl Config {
 481     pub fn new(root_path: AbsPathBuf, caps: ClientCapabilities) -> Self {
 482         Config {
 483             caps,
 484             data: ConfigData::default(),
 485             detached_files: Vec::new(),
 486             discovered_projects: None,
 487             root_path,
 488             snippets: Default::default(),
 489         }
 490     }
 491     pub fn update(&mut self, mut json: serde_json::Value) {
 492         tracing::info!("updating config from JSON: {:#}", json);
 493         if json.is_null() || json.as_object().map_or(false, |it| it.is_empty()) {
 494             return;
 495         }
 496         self.detached_files = get_field::<Vec<PathBuf>>(&mut json, "detachedFiles", None, "[]")
 497             .into_iter()
 498             .map(AbsPathBuf::assert)
 499             .collect();
 500         self.data = ConfigData::from_json(json);
 501         self.snippets.clear();
 502         for (name, def) in self.data.completion_snippets.iter() {
 503             if def.prefix.is_empty() && def.postfix.is_empty() {
 504                 continue;
 505             }
 506             let scope = match def.scope {
 507                 SnippetScopeDef::Expr => SnippetScope::Expr,
 508                 SnippetScopeDef::Type => SnippetScope::Type,
 509                 SnippetScopeDef::Item => SnippetScope::Item,
 510             };
 511             match Snippet::new(
 512                 &def.prefix,
 513                 &def.postfix,
 514                 &def.body,
 515                 def.description.as_ref().unwrap_or(name),
 516                 &def.requires,
 517                 scope,
 518             ) {
 519                 Some(snippet) => self.snippets.push(snippet),
 520                 None => tracing::info!("Invalid snippet {}", name),
 521             }
 522         }
 523     }
 524
 525     pub fn json_schema() -> serde_json::Value {
 526         ConfigData::json_schema()
 527     }
 528 }
 529
 530 macro_rules! try_ {
 531     ($expr:expr) => {
 532         || -> _ { Some($expr) }()
 533     };
 534 }
 535 macro_rules! try_or {
 536     ($expr:expr, $or:expr) => {
 537         try_!($expr).unwrap_or($or)
 538     };
 539 }
 540
 541 impl Config {
 542     pub fn linked_projects(&self) -> Vec<LinkedProject> {
 543         if self.data.linkedProjects.is_empty() {
 544             self.discovered_projects
 545                 .as_ref()
 546                 .into_iter()
 547                 .flatten()
 548                 .cloned()
 549                 .map(LinkedProject::from)
 550                 .collect()
 551         } else {
 552             self.data
 553                 .linkedProjects
 554                 .iter()
 555                 .filter_map(|linked_project| {
 556                     let res = match linked_project {
 557                         ManifestOrProjectJson::Manifest(it) => {
 558                             let path = self.root_path.join(it);
 559                             ProjectManifest::from_manifest_file(path)
 560                                 .map_err(|e| {
 561                                     tracing::error!("failed to load linked project: {}", e)
 562                                 })
 563                                 .ok()?
 564                                 .into()
 565                         }
 566                         ManifestOrProjectJson::ProjectJson(it) => {
 567                             ProjectJson::new(&self.root_path, it.clone()).into()
 568                         }
 569                     };
 570                     Some(res)
 571                 })
 572                 .collect()
 573         }
 574     }
 575
 576     pub fn detached_files(&self) -> &[AbsPathBuf] {
 577         &self.detached_files
 578     }
 579
 580     pub fn did_save_text_document_dynamic_registration(&self) -> bool {
 581         let caps =
 582             try_or!(self.caps.text_document.as_ref()?.synchronization.clone()?, Default::default());
 583         caps.did_save == Some(true) && caps.dynamic_registration == Some(true)
 584     }
 585     pub fn did_change_watched_files_dynamic_registration(&self) -> bool {
 586         try_or!(
 587             self.caps.workspace.as_ref()?.did_change_watched_files.as_ref()?.dynamic_registration?,
 588             false
 589         )
 590     }
 591
 592     pub fn prefill_caches(&self) -> bool {
 593         self.data.cache_warmup
 594     }
 595
 596     pub fn location_link(&self) -> bool {
 597         try_or!(self.caps.text_document.as_ref()?.definition?.link_support?, false)
 598     }
 599     pub fn line_folding_only(&self) -> bool {
 600         try_or!(self.caps.text_document.as_ref()?.folding_range.as_ref()?.line_folding_only?, false)
 601     }
 602     pub fn hierarchical_symbols(&self) -> bool {
 603         try_or!(
 604             self.caps
 605                 .text_document
 606                 .as_ref()?
 607                 .document_symbol
 608                 .as_ref()?
 609                 .hierarchical_document_symbol_support?,
 610             false
 611         )
 612     }
 613     pub fn code_action_literals(&self) -> bool {
 614         try_!(self
 615             .caps
 616             .text_document
 617             .as_ref()?
 618             .code_action
 619             .as_ref()?
 620             .code_action_literal_support
 621             .as_ref()?)
 622         .is_some()
 623     }
 624     pub fn work_done_progress(&self) -> bool {
 625         try_or!(self.caps.window.as_ref()?.work_done_progress?, false)
 626     }
 627     pub fn will_rename(&self) -> bool {
 628         try_or!(self.caps.workspace.as_ref()?.file_operations.as_ref()?.will_rename?, false)
 629     }
 630     pub fn change_annotation_support(&self) -> bool {
 631         try_!(self
 632             .caps
 633             .workspace
 634             .as_ref()?
 635             .workspace_edit
 636             .as_ref()?
 637             .change_annotation_support
 638             .as_ref()?)
 639         .is_some()
 640     }
 641     pub fn code_action_resolve(&self) -> bool {
 642         try_or!(
 643             self.caps
 644                 .text_document
 645                 .as_ref()?
 646                 .code_action
 647                 .as_ref()?
 648                 .resolve_support
 649                 .as_ref()?
 650                 .properties
 651                 .as_slice(),
 652             &[]
 653         )
 654         .iter()
 655         .any(|it| it == "edit")
 656     }
 657     pub fn signature_help_label_offsets(&self) -> bool {
 658         try_or!(
 659             self.caps
 660                 .text_document
 661                 .as_ref()?
 662                 .signature_help
 663                 .as_ref()?
 664                 .signature_information
 665                 .as_ref()?
 666                 .parameter_information
 667                 .as_ref()?
 668                 .label_offset_support?,
 669             false
 670         )
 671     }
 672     pub fn offset_encoding(&self) -> OffsetEncoding {
 673         if supports_utf8(&self.caps) {
 674             OffsetEncoding::Utf8
 675         } else {
 676             OffsetEncoding::Utf16
 677         }
 678     }
 679
 680     fn experimental(&self, index: &'static str) -> bool {
 681         try_or!(self.caps.experimental.as_ref()?.get(index)?.as_bool()?, false)
 682     }
 683     pub fn code_action_group(&self) -> bool {
 684         self.experimental("codeActionGroup")
 685     }
 686     pub fn server_status_notification(&self) -> bool {
 687         self.experimental("serverStatusNotification")
 688     }
 689
 690     pub fn publish_diagnostics(&self) -> bool {
 691         self.data.diagnostics_enable
 692     }
 693     pub fn diagnostics(&self) -> DiagnosticsConfig {
 694         DiagnosticsConfig {
 695             disable_experimental: !self.data.diagnostics_enableExperimental,
 696             disabled: self.data.diagnostics_disabled.clone(),
 697         }
 698     }
 699     pub fn diagnostics_map(&self) -> DiagnosticsMapConfig {
 700         DiagnosticsMapConfig {
 701             remap_prefix: self.data.diagnostics_remapPrefix.clone(),
 702             warnings_as_info: self.data.diagnostics_warningsAsInfo.clone(),
 703             warnings_as_hint: self.data.diagnostics_warningsAsHint.clone(),
 704         }
 705     }
 706     pub fn lru_capacity(&self) -> Option<usize> {
 707         self.data.lruCapacity
 708     }
 709     pub fn proc_macro_srv(&self) -> Option<(AbsPathBuf, Vec<OsString>)> {
 710         if !self.data.procMacro_enable {
 711             return None;
 712         }
 713         let path = match &self.data.procMacro_server {
 714             Some(it) => self.root_path.join(it),
 715             None => AbsPathBuf::assert(std::env::current_exe().ok()?),
 716         };
 717         Some((path, vec!["proc-macro".into()]))
 718     }
 719     pub fn expand_proc_attr_macros(&self) -> bool {
 720         self.data.experimental_procAttrMacros
 721     }
 722     pub fn files(&self) -> FilesConfig {
 723         FilesConfig {
 724             watcher: match self.data.files_watcher.as_str() {
 725                 "notify" => FilesWatcher::Notify,
 726                 "client" if self.did_change_watched_files_dynamic_registration() => {
 727                     FilesWatcher::Client
 728                 }
 729                 _ => FilesWatcher::Notify,
 730             },
 731             exclude: self.data.files_excludeDirs.iter().map(|it| self.root_path.join(it)).collect(),
 732         }
 733     }
 734     pub fn notifications(&self) -> NotificationsConfig {
 735         NotificationsConfig { cargo_toml_not_found: self.data.notifications_cargoTomlNotFound }
 736     }
 737     pub fn cargo_autoreload(&self) -> bool {
 738         self.data.cargo_autoreload
 739     }
 740     pub fn run_build_scripts(&self) -> bool {
 741         self.data.cargo_runBuildScripts || self.data.procMacro_enable
 742     }
 743     pub fn cargo(&self) -> CargoConfig {
 744         let rustc_source = self.data.rustcSource.as_ref().map(|rustc_src| {
 745             if rustc_src == "discover" {
 746                 RustcSource::Discover
 747             } else {
 748                 RustcSource::Path(self.root_path.join(rustc_src))
 749             }
 750         });
 751
 752         CargoConfig {
 753             no_default_features: self.data.cargo_noDefaultFeatures,
 754             all_features: self.data.cargo_allFeatures,
 755             features: self.data.cargo_features.clone(),
 756             target: self.data.cargo_target.clone(),
 757             no_sysroot: self.data.cargo_noSysroot,
 758             rustc_source,
 759             unset_test_crates: UnsetTestCrates::Only(self.data.cargo_unsetTest.clone()),
 760             wrap_rustc_in_build_scripts: self.data.cargo_useRustcWrapperForBuildScripts,
 761         }
 762     }
 763
 764     pub fn rustfmt(&self) -> RustfmtConfig {
 765         match &self.data.rustfmt_overrideCommand {
 766             Some(args) if !args.is_empty() => {
 767                 let mut args = args.clone();
 768                 let command = args.remove(0);
 769                 RustfmtConfig::CustomCommand { command, args }
 770             }
 771             Some(_) | None => RustfmtConfig::Rustfmt {
 772                 extra_args: self.data.rustfmt_extraArgs.clone(),
 773                 enable_range_formatting: self.data.rustfmt_enableRangeFormatting,
 774             },
 775         }
 776     }
 777     pub fn flycheck(&self) -> Option<FlycheckConfig> {
 778         if !self.data.checkOnSave_enable {
 779             return None;
 780         }
 781         let flycheck_config = match &self.data.checkOnSave_overrideCommand {
 782             Some(args) if !args.is_empty() => {
 783                 let mut args = args.clone();
 784                 let command = args.remove(0);
 785                 FlycheckConfig::CustomCommand { command, args }
 786             }
 787             Some(_) | None => FlycheckConfig::CargoCommand {
 788                 command: self.data.checkOnSave_command.clone(),
 789                 target_triple: self
 790                     .data
 791                     .checkOnSave_target
 792                     .clone()
 793                     .or_else(|| self.data.cargo_target.clone()),
 794                 all_targets: self.data.checkOnSave_allTargets,
 795                 no_default_features: self
 796                     .data
 797                     .checkOnSave_noDefaultFeatures
 798                     .unwrap_or(self.data.cargo_noDefaultFeatures),
 799                 all_features: self
 800                     .data
 801                     .checkOnSave_allFeatures
 802                     .unwrap_or(self.data.cargo_allFeatures),
 803                 features: self
 804                     .data
 805                     .checkOnSave_features
 806                     .clone()
 807                     .unwrap_or_else(|| self.data.cargo_features.clone()),
 808                 extra_args: self.data.checkOnSave_extraArgs.clone(),
 809             },
 810         };
 811         Some(flycheck_config)
 812     }
 813     pub fn runnables(&self) -> RunnablesConfig {
 814         RunnablesConfig {
 815             override_cargo: self.data.runnables_overrideCargo.clone(),
 816             cargo_extra_args: self.data.runnables_cargoExtraArgs.clone(),
 817         }
 818     }
 819     pub fn inlay_hints(&self) -> InlayHintsConfig {
 820         InlayHintsConfig {
 821             type_hints: self.data.inlayHints_typeHints,
 822             parameter_hints: self.data.inlayHints_parameterHints,
 823             chaining_hints: self.data.inlayHints_chainingHints,
 824             hide_named_constructor_hints: self.data.inlayHints_hideNamedConstructorHints,
 825             max_length: self.data.inlayHints_maxLength,
 826         }
 827     }
 828     fn insert_use_config(&self) -> InsertUseConfig {
 829         InsertUseConfig {
 830             granularity: match self.data.assist_importGranularity {
 831                 ImportGranularityDef::Preserve => ImportGranularity::Preserve,
 832                 ImportGranularityDef::Item => ImportGranularity::Item,
 833                 ImportGranularityDef::Crate => ImportGranularity::Crate,
 834                 ImportGranularityDef::Module => ImportGranularity::Module,
 835             },
 836             enforce_granularity: self.data.assist_importEnforceGranularity,
 837             prefix_kind: match self.data.assist_importPrefix {
 838                 ImportPrefixDef::Plain => PrefixKind::Plain,
 839                 ImportPrefixDef::ByCrate => PrefixKind::ByCrate,
 840                 ImportPrefixDef::BySelf => PrefixKind::BySelf,
 841             },
 842             group: self.data.assist_importGroup,
 843             skip_glob_imports: !self.data.assist_allowMergingIntoGlobImports,
 844         }
 845     }
 846     pub fn completion(&self) -> CompletionConfig {
 847         CompletionConfig {
 848             enable_postfix_completions: self.data.completion_postfix_enable,
 849             enable_imports_on_the_fly: self.data.completion_autoimport_enable
 850                 && completion_item_edit_resolve(&self.caps),
 851             enable_self_on_the_fly: self.data.completion_autoself_enable,
 852             add_call_parenthesis: self.data.completion_addCallParenthesis,
 853             add_call_argument_snippets: self.data.completion_addCallArgumentSnippets,
 854             insert_use: self.insert_use_config(),
 855             snippet_cap: SnippetCap::new(try_or!(
 856                 self.caps
 857                     .text_document
 858                     .as_ref()?
 859                     .completion
 860                     .as_ref()?
 861                     .completion_item
 862                     .as_ref()?
 863                     .snippet_support?,
 864                 false
 865             )),
 866             snippets: self.snippets.clone(),
 867         }
 868     }
 869     pub fn assist(&self) -> AssistConfig {
 870         AssistConfig {
 871             snippet_cap: SnippetCap::new(self.experimental("snippetTextEdit")),
 872             allowed: None,
 873             insert_use: self.insert_use_config(),
 874         }
 875     }
 876     pub fn join_lines(&self) -> JoinLinesConfig {
 877         JoinLinesConfig {
 878             join_else_if: self.data.joinLines_joinElseIf,
 879             remove_trailing_comma: self.data.joinLines_removeTrailingComma,
 880             unwrap_trivial_blocks: self.data.joinLines_unwrapTrivialBlock,
 881             join_assignments: self.data.joinLines_joinAssignments,
 882         }
 883     }
 884     pub fn call_info_full(&self) -> bool {
 885         self.data.callInfo_full
 886     }
 887     pub fn lens(&self) -> LensConfig {
 888         LensConfig {
 889             run: self.data.lens_enable && self.data.lens_run,
 890             debug: self.data.lens_enable && self.data.lens_debug,
 891             implementations: self.data.lens_enable && self.data.lens_implementations,
 892             method_refs: self.data.lens_enable && self.data.lens_methodReferences,
 893             refs: self.data.lens_enable && self.data.lens_references,
 894             enum_variant_refs: self.data.lens_enable && self.data.lens_enumVariantReferences,
 895         }
 896     }
 897     pub fn hover_actions(&self) -> HoverActionsConfig {
 898         let enable = self.experimental("hoverActions") && self.data.hoverActions_enable;
 899         HoverActionsConfig {
 900             implementations: enable && self.data.hoverActions_implementations,
 901             references: enable && self.data.hoverActions_references,
 902             run: enable && self.data.hoverActions_run,
 903             debug: enable && self.data.hoverActions_debug,
 904             goto_type_def: enable && self.data.hoverActions_gotoTypeDef,
 905         }
 906     }
 907     pub fn highlighting_strings(&self) -> bool {
 908         self.data.highlighting_strings
 909     }
 910     pub fn hover(&self) -> HoverConfig {
 911         HoverConfig {
 912             links_in_hover: self.data.hover_linksInHover,
 913             documentation: self.data.hover_documentation.then(|| {
 914                 let is_markdown = try_or!(
 915                     self.caps
 916                         .text_document
 917                         .as_ref()?
 918                         .hover
 919                         .as_ref()?
 920                         .content_format
 921                         .as_ref()?
 922                         .as_slice(),
 923                     &[]
 924                 )
 925                 .contains(&MarkupKind::Markdown);
 926                 if is_markdown {
 927                     HoverDocFormat::Markdown
 928                 } else {
 929                     HoverDocFormat::PlainText
 930                 }
 931             }),
 932         }
 933     }
 934
 935     pub fn workspace_symbol(&self) -> WorkspaceSymbolConfig {
 936         WorkspaceSymbolConfig {
 937             search_scope: match self.data.workspace_symbol_search_scope {
 938                 WorkspaceSymbolSearchScopeDef::Workspace => WorkspaceSymbolSearchScope::Workspace,
 939                 WorkspaceSymbolSearchScopeDef::WorkspaceAndDependencies => {
 940                     WorkspaceSymbolSearchScope::WorkspaceAndDependencies
 941                 }
 942             },
 943             search_kind: match self.data.workspace_symbol_search_kind {
 944                 WorkspaceSymbolSearchKindDef::OnlyTypes => WorkspaceSymbolSearchKind::OnlyTypes,
 945                 WorkspaceSymbolSearchKindDef::AllSymbols => WorkspaceSymbolSearchKind::AllSymbols,
 946             },
 947         }
 948     }
 949
 950     pub fn semantic_tokens_refresh(&self) -> bool {
 951         try_or!(self.caps.workspace.as_ref()?.semantic_tokens.as_ref()?.refresh_support?, false)
 952     }
 953     pub fn code_lens_refresh(&self) -> bool {
 954         try_or!(self.caps.workspace.as_ref()?.code_lens.as_ref()?.refresh_support?, false)
 955     }
 956     pub fn insert_replace_support(&self) -> bool {
 957         try_or!(
 958             self.caps
 959                 .text_document
 960                 .as_ref()?
 961                 .completion
 962                 .as_ref()?
 963                 .completion_item
 964                 .as_ref()?
 965                 .insert_replace_support?,
 966             false
 967         )
 968     }
 969     pub fn client_commands(&self) -> ClientCommandsConfig {
 970         let commands =
 971             try_or!(self.caps.experimental.as_ref()?.get("commands")?, &serde_json::Value::Null);
 972         let commands: Option<lsp_ext::ClientCommandOptions> =
 973             serde_json::from_value(commands.clone()).ok();
 974         let force = commands.is_none() && self.data.lens_forceCustomCommands;
 975         let commands = commands.map(|it| it.commands).unwrap_or_default();
 976
 977         let get = |name: &str| commands.iter().any(|it| it == name) || force;
 978
 979         ClientCommandsConfig {
 980             run_single: get("rust-analyzer.runSingle"),
 981             debug_single: get("rust-analyzer.debugSingle"),
 982             show_reference: get("rust-analyzer.showReferences"),
 983             goto_location: get("rust-analyzer.gotoLocation"),
 984             trigger_parameter_hints: get("editor.action.triggerParameterHints"),
 985         }
 986     }
 987
 988     pub fn highlight_related(&self) -> HighlightRelatedConfig {
 989         HighlightRelatedConfig {
 990             references: self.data.highlightRelated_references,
 991             break_points: self.data.highlightRelated_breakPoints,
 992             exit_points: self.data.highlightRelated_exitPoints,
 993             yield_points: self.data.highlightRelated_yieldPoints,
 994         }
 995     }
 996 }
 997
 998 #[derive(Deserialize, Debug, Clone, Copy)]
 999 #[serde(rename_all = "snake_case")]
1000 enum SnippetScopeDef {
1001     Expr,
1002     Item,
1003     Type,
1004 }
1005
1006 impl Default for SnippetScopeDef {
1007     fn default() -> Self {
1008         SnippetScopeDef::Expr
1009     }
1010 }
1011
1012 #[derive(Deserialize, Debug, Clone, Default)]
1013 #[serde(default)]
1014 struct SnippetDef {
1015     #[serde(deserialize_with = "single_or_array")]
1016     prefix: Vec<String>,
1017     #[serde(deserialize_with = "single_or_array")]
1018     postfix: Vec<String>,
1019     description: Option<String>,
1020     #[serde(deserialize_with = "single_or_array")]
1021     body: Vec<String>,
1022     #[serde(deserialize_with = "single_or_array")]
1023     requires: Vec<String>,
1024     scope: SnippetScopeDef,
1025 }
1026
1027 fn single_or_array<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
1028 where
1029     D: serde::Deserializer<'de>,
1030 {
1031     struct SingleOrVec;
1032
1033     impl<'de> serde::de::Visitor<'de> for SingleOrVec {
1034         type Value = Vec<String>;
1035
1036         fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
1037             formatter.write_str("string or array of strings")
1038         }
1039
1040         fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1041         where
1042             E: serde::de::Error,
1043         {
1044             Ok(vec![value.to_owned()])
1045         }
1046
1047         fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
1048         where
1049             A: serde::de::SeqAccess<'de>,
1050         {
1051             Deserialize::deserialize(serde::de::value::SeqAccessDeserializer::new(seq))
1052         }
1053     }
1054
1055     deserializer.deserialize_any(SingleOrVec)
1056 }
1057
1058 #[derive(Deserialize, Debug, Clone)]
1059 #[serde(untagged)]
1060 enum ManifestOrProjectJson {
1061     Manifest(PathBuf),
1062     ProjectJson(ProjectJsonData),
1063 }
1064
1065 #[derive(Deserialize, Debug, Clone)]
1066 #[serde(rename_all = "snake_case")]
1067 enum ImportGranularityDef {
1068     Preserve,
1069     #[serde(alias = "none")]
1070     Item,
1071     #[serde(alias = "full")]
1072     Crate,
1073     #[serde(alias = "last")]
1074     Module,
1075 }
1076
1077 #[derive(Deserialize, Debug, Clone)]
1078 #[serde(rename_all = "snake_case")]
1079 enum ImportPrefixDef {
1080     Plain,
1081     #[serde(alias = "self")]
1082     BySelf,
1083     #[serde(alias = "crate")]
1084     ByCrate,
1085 }
1086
1087 #[derive(Deserialize, Debug, Clone)]
1088 #[serde(rename_all = "snake_case")]
1089 enum WorkspaceSymbolSearchScopeDef {
1090     Workspace,
1091     WorkspaceAndDependencies,
1092 }
1093
1094 #[derive(Deserialize, Debug, Clone)]
1095 #[serde(rename_all = "snake_case")]
1096 enum WorkspaceSymbolSearchKindDef {
1097     OnlyTypes,
1098     AllSymbols,
1099 }
1100
1101 macro_rules! _config_data {
1102     (struct $name:ident {
1103         $(
1104             $(#[doc=$doc:literal])*
1105             $field:ident $(| $alias:ident)*: $ty:ty = $default:expr,
1106         )*
1107     }) => {
1108         #[allow(non_snake_case)]
1109         #[derive(Debug, Clone)]
1110         struct $name { $($field: $ty,)* }
1111         impl $name {
1112             fn from_json(mut json: serde_json::Value) -> $name {
1113                 $name {$(
1114                     $field: get_field(
1115                         &mut json,
1116                         stringify!($field),
1117                         None$(.or(Some(stringify!($alias))))*,
1118                         $default,
1119                     ),
1120                 )*}
1121             }
1122
1123             fn json_schema() -> serde_json::Value {
1124                 schema(&[
1125                     $({
1126                         let field = stringify!($field);
1127                         let ty = stringify!($ty);
1128
1129                         (field, ty, &[$($doc),*], $default)
1130                     },)*
1131                 ])
1132             }
1133
1134             #[cfg(test)]
1135             fn manual() -> String {
1136                 manual(&[
1137                     $({
1138                         let field = stringify!($field);
1139                         let ty = stringify!($ty);
1140
1141                         (field, ty, &[$($doc),*], $default)
1142                     },)*
1143                 ])
1144             }
1145         }
1146     };
1147 }
1148 use _config_data as config_data;
1149
1150 fn get_field<T: DeserializeOwned>(
1151     json: &mut serde_json::Value,
1152     field: &'static str,
1153     alias: Option<&'static str>,
1154     default: &str,
1155 ) -> T {
1156     let default = serde_json::from_str(default).unwrap();
1157
1158     // XXX: check alias first, to work-around the VS Code where it pre-fills the
1159     // defaults instead of sending an empty object.
1160     alias
1161         .into_iter()
1162         .chain(iter::once(field))
1163         .find_map(move |field| {
1164             let mut pointer = field.replace('_', "/");
1165             pointer.insert(0, '/');
1166             json.pointer_mut(&pointer).and_then(|it| serde_json::from_value(it.take()).ok())
1167         })
1168         .unwrap_or(default)
1169 }
1170
1171 fn schema(fields: &[(&'static str, &'static str, &[&str], &str)]) -> serde_json::Value {
1172     for ((f1, ..), (f2, ..)) in fields.iter().zip(&fields[1..]) {
1173         fn key(f: &str) -> &str {
1174             f.splitn(2, '_').next().unwrap()
1175         }
1176         assert!(key(f1) <= key(f2), "wrong field order: {:?} {:?}", f1, f2);
1177     }
1178
1179     let map = fields
1180         .iter()
1181         .map(|(field, ty, doc, default)| {
1182             let name = field.replace("_", ".");
1183             let name = format!("rust-analyzer.{}", name);
1184             let props = field_props(field, ty, doc, default);
1185             (name, props)
1186         })
1187         .collect::<serde_json::Map<_, _>>();
1188     map.into()
1189 }
1190
1191 fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json::Value {
1192     let doc = doc_comment_to_string(doc);
1193     let doc = doc.trim_end_matches('\n');
1194     assert!(
1195         doc.ends_with('.') && doc.starts_with(char::is_uppercase),
1196         "bad docs for {}: {:?}",
1197         field,
1198         doc
1199     );
1200     let default = default.parse::<serde_json::Value>().unwrap();
1201
1202     let mut map = serde_json::Map::default();
1203     macro_rules! set {
1204         ($($key:literal: $value:tt),*$(,)?) => {{$(
1205             map.insert($key.into(), serde_json::json!($value));
1206         )*}};
1207     }
1208     set!("markdownDescription": doc);
1209     set!("default": default);
1210
1211     match ty {
1212         "bool" => set!("type": "boolean"),
1213         "String" => set!("type": "string"),
1214         "Vec<String>" => set! {
1215             "type": "array",
1216             "items": { "type": "string" },
1217         },
1218         "Vec<PathBuf>" => set! {
1219             "type": "array",
1220             "items": { "type": "string" },
1221         },
1222         "FxHashSet<String>" => set! {
1223             "type": "array",
1224             "items": { "type": "string" },
1225             "uniqueItems": true,
1226         },
1227         "FxHashMap<String, SnippetDef>" => set! {
1228             "type": "object",
1229         },
1230         "FxHashMap<String, String>" => set! {
1231             "type": "object",
1232         },
1233         "Option<usize>" => set! {
1234             "type": ["null", "integer"],
1235             "minimum": 0,
1236         },
1237         "Option<String>" => set! {
1238             "type": ["null", "string"],
1239         },
1240         "Option<PathBuf>" => set! {
1241             "type": ["null", "string"],
1242         },
1243         "Option<bool>" => set! {
1244             "type": ["null", "boolean"],
1245         },
1246         "Option<Vec<String>>" => set! {
1247             "type": ["null", "array"],
1248             "items": { "type": "string" },
1249         },
1250         "MergeBehaviorDef" => set! {
1251             "type": "string",
1252             "enum": ["none", "crate", "module"],
1253             "enumDescriptions": [
1254                 "Do not merge imports at all.",
1255                 "Merge imports from the same crate into a single `use` statement.",
1256                 "Merge imports from the same module into a single `use` statement."
1257             ],
1258         },
1259         "ImportGranularityDef" => set! {
1260             "type": "string",
1261             "enum": ["preserve", "crate", "module", "item"],
1262             "enumDescriptions": [
1263                 "Do not change the granularity of any imports and preserve the original structure written by the developer.",
1264                 "Merge imports from the same crate into a single use statement. Conversely, imports from different crates are split into separate statements.",
1265                 "Merge imports from the same module into a single use statement. Conversely, imports from different modules are split into separate statements.",
1266                 "Flatten imports so that each has its own use statement."
1267             ],
1268         },
1269         "ImportPrefixDef" => set! {
1270             "type": "string",
1271             "enum": [
1272                 "plain",
1273                 "self",
1274                 "crate"
1275             ],
1276             "enumDescriptions": [
1277                 "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
1278                 "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.",
1279                 "Force import paths to be absolute by always starting them with `crate` or the extern crate name they come from."
1280             ],
1281         },
1282         "Vec<ManifestOrProjectJson>" => set! {
1283             "type": "array",
1284             "items": { "type": ["string", "object"] },
1285         },
1286         "WorkspaceSymbolSearchScopeDef" => set! {
1287             "type": "string",
1288             "enum": ["workspace", "workspace_and_dependencies"],
1289             "enumDescriptions": [
1290                 "Search in current workspace only",
1291                 "Search in current workspace and dependencies"
1292             ],
1293         },
1294         "WorkspaceSymbolSearchKindDef" => set! {
1295             "type": "string",
1296             "enum": ["only_types", "all_symbols"],
1297             "enumDescriptions": [
1298                 "Search for types only",
1299                 "Search for all symbols kinds"
1300             ],
1301         },
1302         _ => panic!("{}: {}", ty, default),
1303     }
1304
1305     map.into()
1306 }
1307
1308 #[cfg(test)]
1309 fn manual(fields: &[(&'static str, &'static str, &[&str], &str)]) -> String {
1310     fields
1311         .iter()
1312         .map(|(field, _ty, doc, default)| {
1313             let name = format!("rust-analyzer.{}", field.replace("_", "."));
1314             let doc = doc_comment_to_string(*doc);
1315             format!("[[{}]]{} (default: `{}`)::\n+\n--\n{}--\n", name, name, default, doc)
1316         })
1317         .collect::<String>()
1318 }
1319
1320 fn doc_comment_to_string(doc: &[&str]) -> String {
1321     doc.iter().map(|it| it.strip_prefix(' ').unwrap_or(it)).map(|it| format!("{}\n", it)).collect()
1322 }
1323
1324 #[cfg(test)]
1325 mod tests {
1326     use std::fs;
1327
1328     use test_utils::{ensure_file_contents, project_root};
1329
1330     use super::*;
1331
1332     #[test]
1333     fn generate_package_json_config() {
1334         let s = Config::json_schema();
1335         let schema = format!("{:#}", s);
1336         let mut schema = schema
1337             .trim_start_matches('{')
1338             .trim_end_matches('}')
1339             .replace("  ", "    ")
1340             .replace("\n", "\n            ")
1341             .trim_start_matches('\n')
1342             .trim_end()
1343             .to_string();
1344         schema.push_str(",\n");
1345
1346         // Transform the asciidoc form link to markdown style.
1347         //
1348         // https://link[text] => [text](https://link)
1349         let url_matches = schema.match_indices("https://");
1350         let mut url_offsets = url_matches.map(|(idx, _)| idx).collect::<Vec<usize>>();
1351         url_offsets.reverse();
1352         for idx in url_offsets {
1353             let link = &schema[idx..];
1354             // matching on whitespace to ignore normal links
1355             if let Some(link_end) = link.find(|c| c == ' ' || c == '[') {
1356                 if link.chars().nth(link_end) == Some('[') {
1357                     if let Some(link_text_end) = link.find(']') {
1358                         let link_text = link[link_end..(link_text_end + 1)].to_string();
1359
1360                         schema.replace_range((idx + link_end)..(idx + link_text_end + 1), "");
1361                         schema.insert(idx, '(');
1362                         schema.insert(idx + link_end + 1, ')');
1363                         schema.insert_str(idx, &link_text);
1364                     }
1365                 }
1366             }
1367         }
1368
1369         let package_json_path = project_root().join("editors/code/package.json");
1370         let mut package_json = fs::read_to_string(&package_json_path).unwrap();
1371
1372         let start_marker = "                \"$generated-start\": {},\n";
1373         let end_marker = "                \"$generated-end\": {}\n";
1374
1375         let start = package_json.find(start_marker).unwrap() + start_marker.len();
1376         let end = package_json.find(end_marker).unwrap();
1377
1378         let p = remove_ws(&package_json[start..end]);
1379         let s = remove_ws(&schema);
1380         if !p.contains(&s) {
1381             package_json.replace_range(start..end, &schema);
1382             ensure_file_contents(&package_json_path, &package_json)
1383         }
1384     }
1385
1386     #[test]
1387     fn generate_config_documentation() {
1388         let docs_path = project_root().join("docs/user/generated_config.adoc");
1389         let expected = ConfigData::manual();
1390         ensure_file_contents(&docs_path, &expected);
1391     }
1392
1393     fn remove_ws(text: &str) -> String {
1394         text.replace(char::is_whitespace, "")
1395     }
1396 }