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