lsp_ext::{self, supports_utf8, WorkspaceSymbolSearchKind, WorkspaceSymbolSearchScope},

};

// Defines the server-side configuration of the rust-analyzer. We generate

// *parts* of VS Code's `package.json` config from this.

//

config_data! {

struct ConfigData {

/// Placeholder for missing expressions in assists.

/// How imports should be grouped into use statements.

/// 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.

/// The path structure for newly inserted paths to use.

/// Group inserted imports by the https://rust-analyzer.github.io/manual.html#auto-import[following order]. Groups are separated by newlines.

/// Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.

/// Automatically refresh project info via `cargo metadata` on

/// `Cargo.toml` changes.

cargo_autoreload: bool = "true",

/// Unsets `#[cfg(test)]` for the specified crates.

cargo_unsetTest: Vec<String> = "[\"core\"]",

/// Run build scripts (`build.rs`) for more precise code analysis.

/// Advanced option, fully override the command rust-analyzer uses to

/// run build scripts and build procedural macros. The command should

/// include `--message-format=json` or a similar option.

/// Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to

/// avoid compiling unnecessary things.

/// Do not activate the `default` feature.

cargo_noDefaultFeatures: bool = "false",

cargo_target: Option<String> = "null",

/// Internal config for debugging, disables loading of sysroot crates.

cargo_noSysroot: bool = "false",

/// Run specified `cargo check` command for diagnostics on save.

checkOnSave_enable: bool = "true",

/// Check all targets and tests (`--all-targets`).

checkOnSave_allTargets: bool = "true",

/// Cargo command to use for `cargo check`.

/// Extra arguments for `cargo check`.

checkOnSave_extraArgs: Vec<String> = "[]",

/// List of features to activate. Defaults to

/// Advanced option, fully override the command rust-analyzer uses for

/// checking. The command should include `--message-format=json` or

/// similar option.

checkOnSave_overrideCommand: Option<Vec<String>> = "null",

/// Custom completion snippets.

// NOTE: Keep this list in sync with the feature docs of user snippets.

"Arc::new": {

"postfix": "arc",

"body": "Arc::new(${receiver})",

/// Toggles the additional completions that automatically add imports when completed.

/// Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.

completion_autoimport_enable: bool = "true",

/// Toggles the additional completions that automatically show method calls and field accesses

/// with `self` prefixed to them when inside a method.

completion_autoself_enable: bool = "true",

diagnostics_enable: bool = "true",

/// Whether to show experimental rust-analyzer diagnostics that might

/// have more false positives than usual.

/// List of rust-analyzer diagnostics to disable.

diagnostics_disabled: FxHashSet<String> = "[]",

/// Map of prefixes to be substituted when parsing diagnostic file paths.

/// and a blue icon in the `Problems Panel`.

diagnostics_warningsAsInfo: Vec<String> = "[]",

/// Controls file watching implementation.

files_watcher: String = "\"client\"",

/// These directories will be ignored by rust-analyzer. They are

files_excludeDirs: Vec<PathBuf> = "[]",

/// Enables highlighting of related references while hovering your mouse above any identifier.

/// Enables highlighting of all exit points while hovering your mouse above any `return`, `?`, or return type arrow (`->`).

/// Enables highlighting of related references while hovering your mouse `break`, `loop`, `while`, or `for` keywords.

/// Enables highlighting of all break points for a loop or block context while hovering your mouse above any `async` or `await` keywords.

/// Use semantic tokens for strings.

///

/// In some editors (e.g. vscode) semantic tokens override other highlighting grammars.

/// By disabling semantic tokens for strings, other grammars can be used to highlight

/// their contents.

/// Whether to show documentation on hover.

/// Use markdown syntax for links in hover.

/// Whether to show `Debug` action. Only applies when

/// `#rust-analyzer.hoverActions.enable#` is set.

/// Whether to show HoverActions in Rust files.

/// Whether to show `Go to Type Definition` action. Only applies when

/// `#rust-analyzer.hoverActions.enable#` is set.

/// Whether to show `Implementations` action. Only applies when

/// `#rust-analyzer.hoverActions.enable#` is set.

/// Whether to show `References` action. Only applies when

/// `#rust-analyzer.hoverActions.enable#` is set.

/// Whether to show `Run` action. Only applies when

/// `#rust-analyzer.hoverActions.enable#` is set.

/// Whether to render trailing colons for parameter hints, and trailing colons for parameter hints.

inlayHints_renderColons: bool = "true",

inlayHints_maxLength: Option<usize> = "25",

/// Whether to show function parameter name inlay hints at the call

/// site.

/// Whether to show inlay type hints for variables.

/// Whether to show inlay type hints for method chains.

/// Whether to show inlay type hints for return types of closures with blocks.

/// Whether to show inlay type hints for compiler inserted reborrows.

/// Whether to show inlay type hints for elided lifetimes in function signatures.

inlayHints_lifetimeElisionHints_enable: LifetimeElisionDef = "\"never\"",

/// Whether to prefer using parameter names as the name for elided lifetime hints if possible.

inlayHints_lifetimeElisionHints_useParameterNames: bool = "false",

/// Join lines inserts else between consecutive ifs.

joinLines_joinElseIf: bool = "true",

/// Whether to show `Debug` lens. Only applies when

/// `#rust-analyzer.lens.enable#` is set.

/// Whether to show CodeLens in Rust files.

lens_enable: bool = "true",

/// Whether to show `Implementations` lens. Only applies when

/// `#rust-analyzer.lens.enable#` is set.

/// Whether to show `Run` lens. Only applies when

/// `#rust-analyzer.lens.enable#` is set.

/// Whether to show `Method References` lens. Only applies when

/// `#rust-analyzer.lens.enable#` is set.

/// Only applies when `#rust-analyzer.lens.enable#` is set.

/// Whether to show `References` lens for Enum Variants.

/// Only applies when `#rust-analyzer.lens.enable#` is set.

/// Internal config: use custom client-side commands even when the

/// client doesn't set the corresponding capability.

lens_forceCustomCommands: bool = "true",

linkedProjects: Vec<ManifestOrProjectJson> = "[]",

/// Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.

/// Whether to show `can't find Cargo.toml` error message.

notifications_cargoTomlNotFound: bool = "true",

/// How many worker threads to to handle priming caches. The default `0` means to pick automatically.

primeCaches_numThreads: ParallelPrimeCachesNumThreads = "0",

/// Enable support for procedural macros, implies `#rust-analyzer.cargo.runBuildScripts#`.

procMacro_enable: bool = "true",

///

/// This config takes a map of crate names with the exported proc-macro names to ignore as values.

procMacro_ignored: FxHashMap<Box<str>, Box<[Box<str>]>> = "{}",

/// Command to be executed instead of 'cargo' for runnables.

/// Additional arguments to be passed to cargo for runnables such as

/// tests or binaries. For example, it may be `--release`.

/// Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private

/// projects, or "discover" to try to automatically find it if the `rustc-dev` component

/// crates must set `[package.metadata.rust-analyzer] rustc_private=true` to use it.

///

/// This option does not take effect until rust-analyzer is restarted.

/// Additional arguments to `rustfmt`.

rustfmt_extraArgs: Vec<String> = "[]",

/// Enables the use of rustfmt's unstable range formatting command for the

/// `textDocument/rangeFormatting` request. The rustfmt option is unstable and only

/// available on a nightly build.

/// Workspace symbol search scope.

workspace_symbol_search_scope: WorkspaceSymbolSearchScopeDef = "\"workspace\"",

}

}

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct LensConfig {

// runnables

// references

pub method_refs: bool,

pub enum_variant_refs: bool,

}

|| self.debug

|| self.implementations

|| self.method_refs

|| self.enum_variant_refs

}

}

pub fn references(&self) -> bool {

}

}

.collect();

self.data = ConfigData::from_json(json, &mut errors);

self.snippets.clear();

if def.prefix.is_empty() && def.postfix.is_empty() {

continue;

}

}

pub fn prefill_caches(&self) -> bool {

}

pub fn location_link(&self) -> bool {

pub fn diagnostics(&self) -> DiagnosticsConfig {

DiagnosticsConfig {

disabled: self.data.diagnostics_disabled.clone(),

ExprFillDefaultDef::Todo => ExprFillDefaultMode::Todo,

ExprFillDefaultDef::Default => ExprFillDefaultMode::Default,

},

}

pub fn lru_capacity(&self) -> Option<usize> {

}

pub fn proc_macro_srv(&self) -> Option<(AbsPathBuf, Vec<OsString>)> {

}

pub fn expand_proc_attr_macros(&self) -> bool {

}

pub fn files(&self) -> FilesConfig {

}

pub fn run_build_scripts(&self) -> bool {

}

pub fn cargo(&self) -> CargoConfig {

if rustc_src == "discover" {

RustcSource::Discover

} else {

CargoConfig {

no_default_features: self.data.cargo_noDefaultFeatures,

target: self.data.cargo_target.clone(),

no_sysroot: self.data.cargo_noSysroot,

rustc_source,

unset_test_crates: UnsetTestCrates::Only(self.data.cargo_unsetTest.clone()),

}

}

}

Some(_) | None => RustfmtConfig::Rustfmt {

extra_args: self.data.rustfmt_extraArgs.clone(),

},

}

}

.data

.checkOnSave_noDefaultFeatures

.unwrap_or(self.data.cargo_noDefaultFeatures),

.data

.checkOnSave_features

.clone()

extra_args: self.data.checkOnSave_extraArgs.clone(),

},

};

pub fn runnables(&self) -> RunnablesConfig {

RunnablesConfig {

}

}

pub fn inlay_hints(&self) -> InlayHintsConfig {

InlayHintsConfig {

render_colons: self.data.inlayHints_renderColons,

lifetime_elision_hints: match self.data.inlayHints_lifetimeElisionHints_enable {

LifetimeElisionDef::Always => LifetimeElisionHints::Always,

LifetimeElisionDef::Never => LifetimeElisionHints::Never,

LifetimeElisionDef::SkipTrivial => LifetimeElisionHints::SkipTrivial,

},

param_names_for_lifetime_elision_hints: self

.data

.inlayHints_lifetimeElisionHints_useParameterNames,

fn insert_use_config(&self) -> InsertUseConfig {

InsertUseConfig {

ImportGranularityDef::Preserve => ImportGranularity::Preserve,

ImportGranularityDef::Item => ImportGranularity::Item,

ImportGranularityDef::Crate => ImportGranularity::Crate,

ImportGranularityDef::Module => ImportGranularity::Module,

},

ImportPrefixDef::Plain => PrefixKind::Plain,

ImportPrefixDef::ByCrate => PrefixKind::ByCrate,

ImportPrefixDef::BySelf => PrefixKind::BySelf,

},

}

}

&& completion_item_edit_resolve(&self.caps),

enable_self_on_the_fly: self.data.completion_autoself_enable,

enable_private_editable: self.data.completion_privateEditable_enable,

insert_use: self.insert_use_config(),

snippet_cap: SnippetCap::new(try_or_def!(

self.caps

}

}

}

pub fn lens(&self) -> LensConfig {

LensConfig {

}

}

pub fn hover_actions(&self) -> HoverActionsConfig {

HoverActionsConfig {

}

}

pub fn highlighting_strings(&self) -> bool {

}

pub fn hover(&self) -> HoverConfig {

HoverConfig {

let is_markdown = try_or_def!(self

.caps

.text_document

pub fn highlight_related(&self) -> HighlightRelatedConfig {

HighlightRelatedConfig {

}

}

#[derive(Deserialize, Debug, Clone)]

#[serde(rename_all = "snake_case")]

enum LifetimeElisionDef {

#[serde(alias = "true")]

Always,

])

}

}

};

}

use _config_data as config_data;

Some(it) => it,

None => return Ok(None),

};

Ok(Some(res))

}

.unwrap_or(false),

annotate_runnables: lens_config.runnable(),

annotate_impls: lens_config.implementations,

annotate_method_references: lens_config.method_refs,

annotate_enum_variant_references: lens_config.enum_variant_refs,

},

use crate::{

cargo_target_spec::CargoTargetSpec,

global_state::GlobalStateSnapshot,

line_index::{LineEndings, LineIndex, OffsetEncoding},

lsp_ext,

pub(crate) fn signature_help(

call_info: SignatureHelp,

label_offsets: bool,

) -> lsp_types::SignatureHelp {

let params = call_info

.parameter_labels()

.map(|label| lsp_types::ParameterInformation {

}

};

})

let active_parameter = call_info.active_parameter.map(|it| it as u32);