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 hir::PrefixKind;
  14 use ide::{AssistConfig, CompletionConfig, DiagnosticsConfig, HoverConfig, InlayHintsConfig};
  15 use ide_db::helpers::{
  16     insert_use::{InsertUseConfig, MergeBehavior},
  17     SnippetCap,
  18 };
  19 use itertools::Itertools;
  20 use lsp_types::{ClientCapabilities, MarkupKind};
  21 use project_model::{CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest, RustcSource};
  22 use rustc_hash::FxHashSet;
  23 use serde::{de::DeserializeOwned, Deserialize};
  24 use vfs::AbsPathBuf;
  25
  26 use crate::{
  27     caps::completion_item_edit_resolve, diagnostics::DiagnosticsMapConfig,
  28     line_index::OffsetEncoding, lsp_ext::supports_utf8,
  29 };
  30
  31 config_data! {
  32     struct ConfigData {
  33         /// The strategy to use when inserting new imports or merging imports.
  34         assist_importMergeBehavior |
  35         assist_importMergeBehaviour: MergeBehaviorDef  = "\"full\"",
  36         /// The path structure for newly inserted paths to use.
  37         assist_importPrefix: ImportPrefixDef           = "\"plain\"",
  38         /// Group inserted imports by the [following order](https://rust-analyzer.github.io/manual.html#auto-import). Groups are separated by newlines.
  39         assist_importGroup: bool                       = "true",
  40         /// Show function name and docs in parameter hints.
  41         callInfo_full: bool = "true",
  42
  43         /// Automatically refresh project info via `cargo metadata` on
  44         /// `Cargo.toml` changes.
  45         cargo_autoreload: bool           = "true",
  46         /// Activate all available features (`--all-features`).
  47         cargo_allFeatures: bool          = "false",
  48         /// List of features to activate.
  49         cargo_features: Vec<String>      = "[]",
  50         /// Run build scripts (`build.rs`) for more precise code analysis.
  51         cargo_runBuildScripts |
  52         cargo_loadOutDirsFromCheck: bool = "false",
  53         /// Do not activate the `default` feature.
  54         cargo_noDefaultFeatures: bool    = "false",
  55         /// Compilation target (target triple).
  56         cargo_target: Option<String>     = "null",
  57         /// Internal config for debugging, disables loading of sysroot crates.
  58         cargo_noSysroot: bool            = "false",
  59
  60         /// Run specified `cargo check` command for diagnostics on save.
  61         checkOnSave_enable: bool                         = "true",
  62         /// Check with all features (`--all-features`).
  63         /// Defaults to `#rust-analyzer.cargo.allFeatures#`.
  64         checkOnSave_allFeatures: Option<bool>            = "null",
  65         /// Check all targets and tests (`--all-targets`).
  66         checkOnSave_allTargets: bool                     = "true",
  67         /// Cargo command to use for `cargo check`.
  68         checkOnSave_command: String                      = "\"check\"",
  69         /// Do not activate the `default` feature.
  70         checkOnSave_noDefaultFeatures: Option<bool>      = "null",
  71         /// Check for a specific target. Defaults to
  72         /// `#rust-analyzer.cargo.target#`.
  73         checkOnSave_target: Option<String>               = "null",
  74         /// Extra arguments for `cargo check`.
  75         checkOnSave_extraArgs: Vec<String>               = "[]",
  76         /// List of features to activate. Defaults to
  77         /// `#rust-analyzer.cargo.features#`.
  78         checkOnSave_features: Option<Vec<String>>        = "null",
  79         /// Advanced option, fully override the command rust-analyzer uses for
  80         /// checking. The command should include `--message-format=json` or
  81         /// similar option.
  82         checkOnSave_overrideCommand: Option<Vec<String>> = "null",
  83
  84         /// Whether to add argument snippets when completing functions.
  85         completion_addCallArgumentSnippets: bool = "true",
  86         /// Whether to add parenthesis when completing functions.
  87         completion_addCallParenthesis: bool      = "true",
  88         /// Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
  89         completion_postfix_enable: bool          = "true",
  90         /// Toggles the additional completions that automatically add imports when completed.
  91         /// Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
  92         completion_autoimport_enable: bool       = "true",
  93
  94         /// Whether to show native rust-analyzer diagnostics.
  95         diagnostics_enable: bool                = "true",
  96         /// Whether to show experimental rust-analyzer diagnostics that might
  97         /// have more false positives than usual.
  98         diagnostics_enableExperimental: bool    = "true",
  99         /// List of rust-analyzer diagnostics to disable.
 100         diagnostics_disabled: FxHashSet<String> = "[]",
 101         /// List of warnings that should be displayed with info severity.\n\nThe
 102         /// warnings will be indicated by a blue squiggly underline in code and
 103         /// a blue icon in the `Problems Panel`.
 104         diagnostics_warningsAsHint: Vec<String> = "[]",
 105         /// List of warnings that should be displayed with hint severity.\n\nThe
 106         /// warnings will be indicated by faded text or three dots in code and
 107         /// will not show up in the `Problems Panel`.
 108         diagnostics_warningsAsInfo: Vec<String> = "[]",
 109
 110         /// Controls file watching implementation.
 111         files_watcher: String = "\"client\"",
 112         /// These directories will be ignored by rust-analyzer.
 113         files_excludeDirs: Vec<PathBuf> = "[]",
 114
 115         /// Whether to show `Debug` action. Only applies when
 116         /// `#rust-analyzer.hoverActions.enable#` is set.
 117         hoverActions_debug: bool           = "true",
 118         /// Whether to show HoverActions in Rust files.
 119         hoverActions_enable: bool          = "true",
 120         /// Whether to show `Go to Type Definition` action. Only applies when
 121         /// `#rust-analyzer.hoverActions.enable#` is set.
 122         hoverActions_gotoTypeDef: bool     = "true",
 123         /// Whether to show `Implementations` action. Only applies when
 124         /// `#rust-analyzer.hoverActions.enable#` is set.
 125         hoverActions_implementations: bool = "true",
 126         /// Whether to show `Run` action. Only applies when
 127         /// `#rust-analyzer.hoverActions.enable#` is set.
 128         hoverActions_run: bool             = "true",
 129         /// Use markdown syntax for links in hover.
 130         hoverActions_linksInHover: bool    = "true",
 131
 132         /// Whether to show inlay type hints for method chains.
 133         inlayHints_chainingHints: bool      = "true",
 134         /// Maximum length for inlay hints. Default is unlimited.
 135         inlayHints_maxLength: Option<usize> = "null",
 136         /// Whether to show function parameter name inlay hints at the call
 137         /// site.
 138         inlayHints_parameterHints: bool     = "true",
 139         /// Whether to show inlay type hints for variables.
 140         inlayHints_typeHints: bool          = "true",
 141
 142         /// Whether to show `Debug` lens. Only applies when
 143         /// `#rust-analyzer.lens.enable#` is set.
 144         lens_debug: bool            = "true",
 145         /// Whether to show CodeLens in Rust files.
 146         lens_enable: bool           = "true",
 147         /// Whether to show `Implementations` lens. Only applies when
 148         /// `#rust-analyzer.lens.enable#` is set.
 149         lens_implementations: bool  = "true",
 150         /// Whether to show `Run` lens. Only applies when
 151         /// `#rust-analyzer.lens.enable#` is set.
 152         lens_run: bool              = "true",
 153         /// Whether to show `Method References` lens. Only applies when
 154         /// `#rust-analyzer.lens.enable#` is set.
 155         lens_methodReferences: bool = "false",
 156         /// Whether to show `References` lens. Only applies when
 157         /// `#rust-analyzer.lens.enable#` is set.
 158         lens_references: bool = "false",
 159
 160         /// Disable project auto-discovery in favor of explicitly specified set
 161         /// of projects.\n\nElements must be paths pointing to `Cargo.toml`,
 162         /// `rust-project.json`, or JSON objects in `rust-project.json` format.
 163         linkedProjects: Vec<ManifestOrProjectJson> = "[]",
 164
 165         /// Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.
 166         lruCapacity: Option<usize>                 = "null",
 167
 168         /// Whether to show `can't find Cargo.toml` error message.
 169         notifications_cargoTomlNotFound: bool      = "true",
 170
 171         /// Enable support for procedural macros, implies `#rust-analyzer.cargo.runBuildScripts#`.
 172         procMacro_enable: bool                     = "false",
 173         /// Internal config, path to proc-macro server executable (typically,
 174         /// this is rust-analyzer itself, but we override this in tests).
 175         procMacro_server: Option<PathBuf>          = "null",
 176
 177         /// Command to be executed instead of 'cargo' for runnables.
 178         runnables_overrideCargo: Option<String> = "null",
 179         /// Additional arguments to be passed to cargo for runnables such as
 180         /// tests or binaries.\nFor example, it may be `--release`.
 181         runnables_cargoExtraArgs: Vec<String>   = "[]",
 182
 183         /// Path to the rust compiler sources, for usage in rustc_private projects, or "discover"
 184         /// to try to automatically find it.
 185         rustcSource : Option<String> = "null",
 186
 187         /// Additional arguments to `rustfmt`.
 188         rustfmt_extraArgs: Vec<String>               = "[]",
 189         /// Advanced option, fully override the command rust-analyzer uses for
 190         /// formatting.
 191         rustfmt_overrideCommand: Option<Vec<String>> = "null",
 192     }
 193 }
 194
 195 impl Default for ConfigData {
 196     fn default() -> Self {
 197         ConfigData::from_json(serde_json::Value::Null)
 198     }
 199 }
 200
 201 #[derive(Debug, Clone)]
 202 pub struct Config {
 203     caps: lsp_types::ClientCapabilities,
 204     data: ConfigData,
 205     pub discovered_projects: Option<Vec<ProjectManifest>>,
 206     pub root_path: AbsPathBuf,
 207 }
 208
 209 #[derive(Debug, Clone, Eq, PartialEq)]
 210 pub enum LinkedProject {
 211     ProjectManifest(ProjectManifest),
 212     InlineJsonProject(ProjectJson),
 213 }
 214
 215 impl From<ProjectManifest> for LinkedProject {
 216     fn from(v: ProjectManifest) -> Self {
 217         LinkedProject::ProjectManifest(v)
 218     }
 219 }
 220
 221 impl From<ProjectJson> for LinkedProject {
 222     fn from(v: ProjectJson) -> Self {
 223         LinkedProject::InlineJsonProject(v)
 224     }
 225 }
 226
 227 #[derive(Clone, Debug, PartialEq, Eq)]
 228 pub struct LensConfig {
 229     pub run: bool,
 230     pub debug: bool,
 231     pub implementations: bool,
 232     pub method_refs: bool,
 233     pub refs: bool, // for Struct, Enum, Union and Trait
 234 }
 235
 236 impl LensConfig {
 237     pub fn any(&self) -> bool {
 238         self.implementations || self.runnable() || self.references()
 239     }
 240
 241     pub fn none(&self) -> bool {
 242         !self.any()
 243     }
 244
 245     pub fn runnable(&self) -> bool {
 246         self.run || self.debug
 247     }
 248
 249     pub fn references(&self) -> bool {
 250         self.method_refs || self.refs
 251     }
 252 }
 253
 254 #[derive(Debug, Clone)]
 255 pub struct FilesConfig {
 256     pub watcher: FilesWatcher,
 257     pub exclude: Vec<AbsPathBuf>,
 258 }
 259
 260 #[derive(Debug, Clone)]
 261 pub enum FilesWatcher {
 262     Client,
 263     Notify,
 264 }
 265
 266 #[derive(Debug, Clone)]
 267 pub struct NotificationsConfig {
 268     pub cargo_toml_not_found: bool,
 269 }
 270
 271 #[derive(Debug, Clone)]
 272 pub enum RustfmtConfig {
 273     Rustfmt { extra_args: Vec<String> },
 274     CustomCommand { command: String, args: Vec<String> },
 275 }
 276
 277 /// Configuration for runnable items, such as `main` function or tests.
 278 #[derive(Debug, Clone)]
 279 pub struct RunnablesConfig {
 280     /// Custom command to be executed instead of `cargo` for runnables.
 281     pub override_cargo: Option<String>,
 282     /// Additional arguments for the `cargo`, e.g. `--release`.
 283     pub cargo_extra_args: Vec<String>,
 284 }
 285
 286 impl Config {
 287     pub fn new(root_path: AbsPathBuf, caps: ClientCapabilities) -> Self {
 288         Config { caps, data: ConfigData::default(), discovered_projects: None, root_path }
 289     }
 290     pub fn update(&mut self, json: serde_json::Value) {
 291         log::info!("updating config from JSON: {:#}", json);
 292         if json.is_null() || json.as_object().map_or(false, |it| it.is_empty()) {
 293             return;
 294         }
 295         self.data = ConfigData::from_json(json);
 296     }
 297
 298     pub fn json_schema() -> serde_json::Value {
 299         ConfigData::json_schema()
 300     }
 301 }
 302
 303 macro_rules! try_ {
 304     ($expr:expr) => {
 305         || -> _ { Some($expr) }()
 306     };
 307 }
 308 macro_rules! try_or {
 309     ($expr:expr, $or:expr) => {
 310         try_!($expr).unwrap_or($or)
 311     };
 312 }
 313
 314 impl Config {
 315     pub fn linked_projects(&self) -> Vec<LinkedProject> {
 316         if self.data.linkedProjects.is_empty() {
 317             self.discovered_projects
 318                 .as_ref()
 319                 .into_iter()
 320                 .flatten()
 321                 .cloned()
 322                 .map(LinkedProject::from)
 323                 .collect()
 324         } else {
 325             self.data
 326                 .linkedProjects
 327                 .iter()
 328                 .filter_map(|linked_project| {
 329                     let res = match linked_project {
 330                         ManifestOrProjectJson::Manifest(it) => {
 331                             let path = self.root_path.join(it);
 332                             ProjectManifest::from_manifest_file(path)
 333                                 .map_err(|e| log::error!("failed to load linked project: {}", e))
 334                                 .ok()?
 335                                 .into()
 336                         }
 337                         ManifestOrProjectJson::ProjectJson(it) => {
 338                             ProjectJson::new(&self.root_path, it.clone()).into()
 339                         }
 340                     };
 341                     Some(res)
 342                 })
 343                 .collect()
 344         }
 345     }
 346
 347     pub fn did_save_text_document_dynamic_registration(&self) -> bool {
 348         let caps =
 349             try_or!(self.caps.text_document.as_ref()?.synchronization.clone()?, Default::default());
 350         caps.did_save == Some(true) && caps.dynamic_registration == Some(true)
 351     }
 352     pub fn did_change_watched_files_dynamic_registration(&self) -> bool {
 353         try_or!(
 354             self.caps.workspace.as_ref()?.did_change_watched_files.as_ref()?.dynamic_registration?,
 355             false
 356         )
 357     }
 358
 359     pub fn location_link(&self) -> bool {
 360         try_or!(self.caps.text_document.as_ref()?.definition?.link_support?, false)
 361     }
 362     pub fn line_folding_only(&self) -> bool {
 363         try_or!(self.caps.text_document.as_ref()?.folding_range.as_ref()?.line_folding_only?, false)
 364     }
 365     pub fn hierarchical_symbols(&self) -> bool {
 366         try_or!(
 367             self.caps
 368                 .text_document
 369                 .as_ref()?
 370                 .document_symbol
 371                 .as_ref()?
 372                 .hierarchical_document_symbol_support?,
 373             false
 374         )
 375     }
 376     pub fn code_action_literals(&self) -> bool {
 377         try_!(self
 378             .caps
 379             .text_document
 380             .as_ref()?
 381             .code_action
 382             .as_ref()?
 383             .code_action_literal_support
 384             .as_ref()?)
 385         .is_some()
 386     }
 387     pub fn work_done_progress(&self) -> bool {
 388         try_or!(self.caps.window.as_ref()?.work_done_progress?, false)
 389     }
 390     pub fn code_action_resolve(&self) -> bool {
 391         try_or!(
 392             self.caps
 393                 .text_document
 394                 .as_ref()?
 395                 .code_action
 396                 .as_ref()?
 397                 .resolve_support
 398                 .as_ref()?
 399                 .properties
 400                 .as_slice(),
 401             &[]
 402         )
 403         .iter()
 404         .any(|it| it == "edit")
 405     }
 406     pub fn signature_help_label_offsets(&self) -> bool {
 407         try_or!(
 408             self.caps
 409                 .text_document
 410                 .as_ref()?
 411                 .signature_help
 412                 .as_ref()?
 413                 .signature_information
 414                 .as_ref()?
 415                 .parameter_information
 416                 .as_ref()?
 417                 .label_offset_support?,
 418             false
 419         )
 420     }
 421     pub fn offset_encoding(&self) -> OffsetEncoding {
 422         if supports_utf8(&self.caps) {
 423             OffsetEncoding::Utf8
 424         } else {
 425             OffsetEncoding::Utf16
 426         }
 427     }
 428
 429     fn experimental(&self, index: &'static str) -> bool {
 430         try_or!(self.caps.experimental.as_ref()?.get(index)?.as_bool()?, false)
 431     }
 432     pub fn code_action_group(&self) -> bool {
 433         self.experimental("codeActionGroup")
 434     }
 435     pub fn hover_actions(&self) -> bool {
 436         self.experimental("hoverActions")
 437     }
 438     pub fn status_notification(&self) -> bool {
 439         self.experimental("statusNotification")
 440     }
 441
 442     pub fn publish_diagnostics(&self) -> bool {
 443         self.data.diagnostics_enable
 444     }
 445     pub fn diagnostics(&self) -> DiagnosticsConfig {
 446         DiagnosticsConfig {
 447             disable_experimental: !self.data.diagnostics_enableExperimental,
 448             disabled: self.data.diagnostics_disabled.clone(),
 449         }
 450     }
 451     pub fn diagnostics_map(&self) -> DiagnosticsMapConfig {
 452         DiagnosticsMapConfig {
 453             warnings_as_info: self.data.diagnostics_warningsAsInfo.clone(),
 454             warnings_as_hint: self.data.diagnostics_warningsAsHint.clone(),
 455         }
 456     }
 457     pub fn lru_capacity(&self) -> Option<usize> {
 458         self.data.lruCapacity
 459     }
 460     pub fn proc_macro_srv(&self) -> Option<(PathBuf, Vec<OsString>)> {
 461         if !self.data.procMacro_enable {
 462             return None;
 463         }
 464
 465         let path = self.data.procMacro_server.clone().or_else(|| std::env::current_exe().ok())?;
 466         Some((path, vec!["proc-macro".into()]))
 467     }
 468     pub fn files(&self) -> FilesConfig {
 469         FilesConfig {
 470             watcher: match self.data.files_watcher.as_str() {
 471                 "notify" => FilesWatcher::Notify,
 472                 "client" | _ => FilesWatcher::Client,
 473             },
 474             exclude: self.data.files_excludeDirs.iter().map(|it| self.root_path.join(it)).collect(),
 475         }
 476     }
 477     pub fn notifications(&self) -> NotificationsConfig {
 478         NotificationsConfig { cargo_toml_not_found: self.data.notifications_cargoTomlNotFound }
 479     }
 480     pub fn cargo_autoreload(&self) -> bool {
 481         self.data.cargo_autoreload
 482     }
 483     pub fn run_build_scripts(&self) -> bool {
 484         self.data.cargo_runBuildScripts || self.data.procMacro_enable
 485     }
 486     pub fn cargo(&self) -> CargoConfig {
 487         let rustc_source = self.data.rustcSource.as_ref().map(|rustc_src| {
 488             if rustc_src == "discover" {
 489                 RustcSource::Discover
 490             } else {
 491                 RustcSource::Path(self.root_path.join(rustc_src))
 492             }
 493         });
 494
 495         CargoConfig {
 496             no_default_features: self.data.cargo_noDefaultFeatures,
 497             all_features: self.data.cargo_allFeatures,
 498             features: self.data.cargo_features.clone(),
 499             target: self.data.cargo_target.clone(),
 500             rustc_source,
 501             no_sysroot: self.data.cargo_noSysroot,
 502         }
 503     }
 504     pub fn rustfmt(&self) -> RustfmtConfig {
 505         match &self.data.rustfmt_overrideCommand {
 506             Some(args) if !args.is_empty() => {
 507                 let mut args = args.clone();
 508                 let command = args.remove(0);
 509                 RustfmtConfig::CustomCommand { command, args }
 510             }
 511             Some(_) | None => {
 512                 RustfmtConfig::Rustfmt { extra_args: self.data.rustfmt_extraArgs.clone() }
 513             }
 514         }
 515     }
 516     pub fn flycheck(&self) -> Option<FlycheckConfig> {
 517         if !self.data.checkOnSave_enable {
 518             return None;
 519         }
 520         let flycheck_config = match &self.data.checkOnSave_overrideCommand {
 521             Some(args) if !args.is_empty() => {
 522                 let mut args = args.clone();
 523                 let command = args.remove(0);
 524                 FlycheckConfig::CustomCommand { command, args }
 525             }
 526             Some(_) | None => FlycheckConfig::CargoCommand {
 527                 command: self.data.checkOnSave_command.clone(),
 528                 target_triple: self
 529                     .data
 530                     .checkOnSave_target
 531                     .clone()
 532                     .or_else(|| self.data.cargo_target.clone()),
 533                 all_targets: self.data.checkOnSave_allTargets,
 534                 no_default_features: self
 535                     .data
 536                     .checkOnSave_noDefaultFeatures
 537                     .unwrap_or(self.data.cargo_noDefaultFeatures),
 538                 all_features: self
 539                     .data
 540                     .checkOnSave_allFeatures
 541                     .unwrap_or(self.data.cargo_allFeatures),
 542                 features: self
 543                     .data
 544                     .checkOnSave_features
 545                     .clone()
 546                     .unwrap_or_else(|| self.data.cargo_features.clone()),
 547                 extra_args: self.data.checkOnSave_extraArgs.clone(),
 548             },
 549         };
 550         Some(flycheck_config)
 551     }
 552     pub fn runnables(&self) -> RunnablesConfig {
 553         RunnablesConfig {
 554             override_cargo: self.data.runnables_overrideCargo.clone(),
 555             cargo_extra_args: self.data.runnables_cargoExtraArgs.clone(),
 556         }
 557     }
 558     pub fn inlay_hints(&self) -> InlayHintsConfig {
 559         InlayHintsConfig {
 560             type_hints: self.data.inlayHints_typeHints,
 561             parameter_hints: self.data.inlayHints_parameterHints,
 562             chaining_hints: self.data.inlayHints_chainingHints,
 563             max_length: self.data.inlayHints_maxLength,
 564         }
 565     }
 566     fn insert_use_config(&self) -> InsertUseConfig {
 567         InsertUseConfig {
 568             merge: match self.data.assist_importMergeBehavior {
 569                 MergeBehaviorDef::None => None,
 570                 MergeBehaviorDef::Full => Some(MergeBehavior::Full),
 571                 MergeBehaviorDef::Last => Some(MergeBehavior::Last),
 572             },
 573             prefix_kind: match self.data.assist_importPrefix {
 574                 ImportPrefixDef::Plain => PrefixKind::Plain,
 575                 ImportPrefixDef::ByCrate => PrefixKind::ByCrate,
 576                 ImportPrefixDef::BySelf => PrefixKind::BySelf,
 577             },
 578             group: self.data.assist_importGroup,
 579         }
 580     }
 581     pub fn completion(&self) -> CompletionConfig {
 582         CompletionConfig {
 583             enable_postfix_completions: self.data.completion_postfix_enable,
 584             enable_imports_on_the_fly: self.data.completion_autoimport_enable
 585                 && completion_item_edit_resolve(&self.caps),
 586             add_call_parenthesis: self.data.completion_addCallParenthesis,
 587             add_call_argument_snippets: self.data.completion_addCallArgumentSnippets,
 588             insert_use: self.insert_use_config(),
 589             snippet_cap: SnippetCap::new(try_or!(
 590                 self.caps
 591                     .text_document
 592                     .as_ref()?
 593                     .completion
 594                     .as_ref()?
 595                     .completion_item
 596                     .as_ref()?
 597                     .snippet_support?,
 598                 false
 599             )),
 600         }
 601     }
 602     pub fn assist(&self) -> AssistConfig {
 603         AssistConfig {
 604             snippet_cap: SnippetCap::new(self.experimental("snippetTextEdit")),
 605             allowed: None,
 606             insert_use: self.insert_use_config(),
 607         }
 608     }
 609     pub fn call_info_full(&self) -> bool {
 610         self.data.callInfo_full
 611     }
 612     pub fn lens(&self) -> LensConfig {
 613         LensConfig {
 614             run: self.data.lens_enable && self.data.lens_run,
 615             debug: self.data.lens_enable && self.data.lens_debug,
 616             implementations: self.data.lens_enable && self.data.lens_implementations,
 617             method_refs: self.data.lens_enable && self.data.lens_methodReferences,
 618             refs: self.data.lens_enable && self.data.lens_references,
 619         }
 620     }
 621     pub fn hover(&self) -> HoverConfig {
 622         HoverConfig {
 623             implementations: self.data.hoverActions_enable
 624                 && self.data.hoverActions_implementations,
 625             run: self.data.hoverActions_enable && self.data.hoverActions_run,
 626             debug: self.data.hoverActions_enable && self.data.hoverActions_debug,
 627             goto_type_def: self.data.hoverActions_enable && self.data.hoverActions_gotoTypeDef,
 628             links_in_hover: self.data.hoverActions_linksInHover,
 629             markdown: try_or!(
 630                 self.caps
 631                     .text_document
 632                     .as_ref()?
 633                     .hover
 634                     .as_ref()?
 635                     .content_format
 636                     .as_ref()?
 637                     .as_slice(),
 638                 &[]
 639             )
 640             .contains(&MarkupKind::Markdown),
 641         }
 642     }
 643     pub fn semantic_tokens_refresh(&self) -> bool {
 644         try_or!(self.caps.workspace.as_ref()?.semantic_tokens.as_ref()?.refresh_support?, false)
 645     }
 646     pub fn code_lens_refresh(&self) -> bool {
 647         try_or!(self.caps.workspace.as_ref()?.code_lens.as_ref()?.refresh_support?, false)
 648     }
 649 }
 650
 651 #[derive(Deserialize, Debug, Clone)]
 652 #[serde(untagged)]
 653 enum ManifestOrProjectJson {
 654     Manifest(PathBuf),
 655     ProjectJson(ProjectJsonData),
 656 }
 657
 658 #[derive(Deserialize, Debug, Clone)]
 659 #[serde(rename_all = "snake_case")]
 660 enum MergeBehaviorDef {
 661     None,
 662     Full,
 663     Last,
 664 }
 665
 666 #[derive(Deserialize, Debug, Clone)]
 667 #[serde(rename_all = "snake_case")]
 668 enum ImportPrefixDef {
 669     Plain,
 670     BySelf,
 671     ByCrate,
 672 }
 673
 674 macro_rules! _config_data {
 675     (struct $name:ident {
 676         $(
 677             $(#[doc=$doc:literal])*
 678             $field:ident $(| $alias:ident)?: $ty:ty = $default:expr,
 679         )*
 680     }) => {
 681         #[allow(non_snake_case)]
 682         #[derive(Debug, Clone)]
 683         struct $name { $($field: $ty,)* }
 684         impl $name {
 685             fn from_json(mut json: serde_json::Value) -> $name {
 686                 $name {$(
 687                     $field: get_field(
 688                         &mut json,
 689                         stringify!($field),
 690                         None$(.or(Some(stringify!($alias))))?,
 691                         $default,
 692                     ),
 693                 )*}
 694             }
 695
 696             fn json_schema() -> serde_json::Value {
 697                 schema(&[
 698                     $({
 699                         let field = stringify!($field);
 700                         let ty = stringify!($ty);
 701                         (field, ty, &[$($doc),*], $default)
 702                     },)*
 703                 ])
 704             }
 705
 706             #[cfg(test)]
 707             fn manual() -> String {
 708                 manual(&[
 709                     $({
 710                         let field = stringify!($field);
 711                         let ty = stringify!($ty);
 712                         (field, ty, &[$($doc),*], $default)
 713                     },)*
 714                 ])
 715             }
 716         }
 717     };
 718 }
 719 use _config_data as config_data;
 720
 721 fn get_field<T: DeserializeOwned>(
 722     json: &mut serde_json::Value,
 723     field: &'static str,
 724     alias: Option<&'static str>,
 725     default: &str,
 726 ) -> T {
 727     let default = serde_json::from_str(default).unwrap();
 728
 729     // XXX: check alias first, to work-around the VS Code where it pre-fills the
 730     // defaults instead of sending an empty object.
 731     alias
 732         .into_iter()
 733         .chain(iter::once(field))
 734         .find_map(move |field| {
 735             let mut pointer = field.replace('_', "/");
 736             pointer.insert(0, '/');
 737             json.pointer_mut(&pointer).and_then(|it| serde_json::from_value(it.take()).ok())
 738         })
 739         .unwrap_or(default)
 740 }
 741
 742 fn schema(fields: &[(&'static str, &'static str, &[&str], &str)]) -> serde_json::Value {
 743     for ((f1, ..), (f2, ..)) in fields.iter().zip(&fields[1..]) {
 744         fn key(f: &str) -> &str {
 745             f.splitn(2, '_').next().unwrap()
 746         }
 747         assert!(key(f1) <= key(f2), "wrong field order: {:?} {:?}", f1, f2);
 748     }
 749
 750     let map = fields
 751         .iter()
 752         .map(|(field, ty, doc, default)| {
 753             let name = field.replace("_", ".");
 754             let name = format!("rust-analyzer.{}", name);
 755             let props = field_props(field, ty, doc, default);
 756             (name, props)
 757         })
 758         .collect::<serde_json::Map<_, _>>();
 759     map.into()
 760 }
 761
 762 fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json::Value {
 763     let doc = doc.iter().map(|it| it.trim()).join(" ");
 764     assert!(
 765         doc.ends_with('.') && doc.starts_with(char::is_uppercase),
 766         "bad docs for {}: {:?}",
 767         field,
 768         doc
 769     );
 770     let default = default.parse::<serde_json::Value>().unwrap();
 771
 772     let mut map = serde_json::Map::default();
 773     macro_rules! set {
 774         ($($key:literal: $value:tt),*$(,)?) => {{$(
 775             map.insert($key.into(), serde_json::json!($value));
 776         )*}};
 777     }
 778     set!("markdownDescription": doc);
 779     set!("default": default);
 780
 781     match ty {
 782         "bool" => set!("type": "boolean"),
 783         "String" => set!("type": "string"),
 784         "Vec<String>" => set! {
 785             "type": "array",
 786             "items": { "type": "string" },
 787         },
 788         "Vec<PathBuf>" => set! {
 789             "type": "array",
 790             "items": { "type": "string" },
 791         },
 792         "FxHashSet<String>" => set! {
 793             "type": "array",
 794             "items": { "type": "string" },
 795             "uniqueItems": true,
 796         },
 797         "Option<usize>" => set! {
 798             "type": ["null", "integer"],
 799             "minimum": 0,
 800         },
 801         "Option<String>" => set! {
 802             "type": ["null", "string"],
 803         },
 804         "Option<PathBuf>" => set! {
 805             "type": ["null", "string"],
 806         },
 807         "Option<bool>" => set! {
 808             "type": ["null", "boolean"],
 809         },
 810         "Option<Vec<String>>" => set! {
 811             "type": ["null", "array"],
 812             "items": { "type": "string" },
 813         },
 814         "MergeBehaviorDef" => set! {
 815             "type": "string",
 816             "enum": ["none", "full", "last"],
 817             "enumDescriptions": [
 818                 "No merging",
 819                 "Merge all layers of the import trees",
 820                 "Only merge the last layer of the import trees"
 821             ],
 822         },
 823         "ImportPrefixDef" => set! {
 824             "type": "string",
 825             "enum": [
 826                 "plain",
 827                 "by_self",
 828                 "by_crate"
 829             ],
 830             "enumDescriptions": [
 831                 "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
 832                 "Prefix all import paths with `self` if they don't begin with `self`, `super`, `crate` or a crate name.",
 833                 "Force import paths to be absolute by always starting them with `crate` or the crate name they refer to."
 834             ],
 835         },
 836         "Vec<ManifestOrProjectJson>" => set! {
 837             "type": "array",
 838             "items": { "type": ["string", "object"] },
 839         },
 840         _ => panic!("{}: {}", ty, default),
 841     }
 842
 843     map.into()
 844 }
 845
 846 #[cfg(test)]
 847 fn manual(fields: &[(&'static str, &'static str, &[&str], &str)]) -> String {
 848     fields
 849         .iter()
 850         .map(|(field, _ty, doc, default)| {
 851             let name = format!("rust-analyzer.{}", field.replace("_", "."));
 852             format!("[[{}]]{} (default: `{}`)::\n{}\n", name, name, default, doc.join(" "))
 853         })
 854         .collect::<String>()
 855 }
 856
 857 #[cfg(test)]
 858 mod tests {
 859     use std::fs;
 860
 861     use test_utils::project_dir;
 862
 863     use super::*;
 864
 865     #[test]
 866     fn schema_in_sync_with_package_json() {
 867         let s = Config::json_schema();
 868         let schema = format!("{:#}", s);
 869         let mut schema = schema
 870             .trim_start_matches('{')
 871             .trim_end_matches('}')
 872             .replace("  ", "    ")
 873             .replace("\n", "\n            ")
 874             .trim_start_matches('\n')
 875             .trim_end()
 876             .to_string();
 877         schema.push_str(",\n");
 878
 879         let package_json_path = project_dir().join("editors/code/package.json");
 880         let mut package_json = fs::read_to_string(&package_json_path).unwrap();
 881
 882         let start_marker = "                \"$generated-start\": false,\n";
 883         let end_marker = "                \"$generated-end\": false\n";
 884
 885         let start = package_json.find(start_marker).unwrap() + start_marker.len();
 886         let end = package_json.find(end_marker).unwrap();
 887         let p = remove_ws(&package_json[start..end]);
 888         let s = remove_ws(&schema);
 889
 890         if !p.contains(&s) {
 891             package_json.replace_range(start..end, &schema);
 892             fs::write(&package_json_path, &mut package_json).unwrap();
 893             panic!("new config, updating package.json")
 894         }
 895     }
 896
 897     #[test]
 898     fn schema_in_sync_with_docs() {
 899         let docs_path = project_dir().join("docs/user/generated_config.adoc");
 900         let current = fs::read_to_string(&docs_path).unwrap();
 901         let expected = ConfigData::manual();
 902
 903         if remove_ws(&current) != remove_ws(&expected) {
 904             fs::write(&docs_path, expected).unwrap();
 905             panic!("updated config manual");
 906         }
 907     }
 908
 909     fn remove_ws(text: &str) -> String {
 910         text.replace(char::is_whitespace, "")
 911     }
 912 }