use ide_db::base_db::{FileLoader, SourceDatabase};

// hack until we get hygiene working (same character amount to preserve formatting as much as possible)

const DOLLAR_CRATE_REPLACE: &str = "__r_a_";

let (prefix, suffix) = match kind {

SyntaxKind::MACRO_PAT => ("fn __(", ": u32);"),

SyntaxKind::MACRO_EXPR | SyntaxKind::MACRO_STMTS => ("fn __() {", "}"),

let captured_stdout = String::from_utf8(output.stdout).ok()?;

if output.status.success() && !captured_stdout.trim().is_empty() {

let output = output.trim().strip_prefix(prefix)?;

let output = match kind {

SyntaxKind::MACRO_PAT => {

walkdir = "2.3.2"

semver.workspace = true

memchr = "2.7.1"

cfg.workspace = true

flycheck.workspace = true

//! Of particular interest is the `feature_flags` hash map: while other fields

//! configure the server itself, feature flags are passed into analysis, and

//! tweak things like automatic insertion of `()` in completions.

use std::{fmt, iter, ops::Not};

use cfg::{CfgAtom, CfgDiff};

/// 3. `rust-analyzer.toml` file located at the workspace root

///

/// A config is searched for by traversing a "config tree" in a bottom up fashion. It is chosen by the nearest first principle.

/// Whether to insert #[must_use] when generating `as_` methods

/// for enum variants.

assist_emitMustUse: bool = false,

cargo_allTargets: bool = true,

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

/// `Cargo.toml` or `.cargo/config.toml` changes.

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

cargo_buildScripts_enable: bool = true,

/// Specifies the working directory for running build scripts.

config_data! {

/// Local configurations can be overridden for every crate by placing a `rust-analyzer.toml` on crate root.

/// A config is searched for by traversing a "config tree" in a bottom up fashion. It is chosen by the nearest first principle.

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

config_data! {

/// Configs that only make sense when they are set by a client. As such they can only be defined

/// by setting them using client's settings (e.g `settings.json` on VS Code).

}

#[derive(Debug, Clone)]

snippets: Vec<Snippet>,

visual_studio_code_version: Option<Version>,

ratoml_files: FxHashMap<SourceRootId, RatomlNode>,

}

#[derive(Clone, Debug)]

struct RatomlNode {

parent: Option<SourceRootId>,

}

snippets: Default::default(),

workspace_roots,

visual_studio_code_version,

ratoml_files: FxHashMap::default(),

}

}

.map(AbsPathBuf::assert)

.collect();

patch_old_style::patch_json_for_outdated_configs(&mut json);

tracing::debug!(?self.client_config, "deserialized config data");

self.snippets.clear();

}

pub fn json_schema() -> serde_json::Value {

}

pub fn root_path(&self) -> &AbsPathBuf {

#[derive(Serialize, Deserialize, Debug, Clone)]

#[serde(untagged)]

Manifest(Utf8PathBuf),

ProjectJson(ProjectJsonData),

}

#[derive(Serialize, Deserialize, Debug, Clone)]

#[serde(rename_all = "snake_case")]

Todo,

Default,

}

#[derive(Serialize, Deserialize, Debug, Clone)]

#[serde(untagged)]

#[serde(with = "unit_v::all")]

All,

Selected(Vec<String>),

}

#[derive(Serialize, Deserialize, Debug, Clone)]

#[derive(Serialize, Deserialize, Debug, Clone)]

#[serde(rename_all = "snake_case")]

Root,

Workspace,

}

#[derive(Serialize, Deserialize, Debug, Clone)]

#[serde(rename_all = "snake_case")]

Client,

Notify,

Server,

#[derive(Serialize, Deserialize, Debug, Clone)]

#[serde(rename_all = "snake_case")]

Workspace,

WorkspaceAndDependencies,

}

#[derive(Serialize, Deserialize, Debug, Clone)]

#[serde(rename_all = "snake_case")]

Full,

Parameters,

}

#[derive(Serialize, Deserialize, Debug, Clone)]

#[serde(rename_all = "snake_case")]

OnlyTypes,

AllSymbols,

}

#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq)]

#[serde(rename_all = "snake_case")]

#[serde(untagged)]

#[serde(with = "unit_v::decimal")]

Decimal,

#[serde(with = "unit_v::hexadecimal")]

default_

}};

}

macro_rules! _default_str {

(@verbatim: $s:literal, $_ty:ty) => {

serde_json::to_string_pretty(&val).unwrap()

}};

}

macro_rules! _impl_for_config_data {

(local, $(

$(#[doc=$doc:literal])*

)*

) => {

impl Config {

$(

$($doc)*

#[allow(non_snake_case)]

if let Some(v) = self.client_config.local.$field.as_ref() {

return &v;

}

};

(global, $(

$(#[doc=$doc:literal])*

)*

) => {

impl Config {

$(

$($doc)*

#[allow(non_snake_case)]

if let Some(v) = self.client_config.global.$field.as_ref() {

return &v;

}

};

(client, $(

$(#[doc=$doc:literal])*

)*

) => {

impl Config {

$(

$($doc)*

#[allow(non_snake_case)]

if let Some(v) = self.client_config.global.$field.as_ref() {

return &v;

}

}

};

}

macro_rules! _config_data {

// modname is for the tests

($(#[doc=$dox:literal])* $modname:ident: struct $name:ident <- $input:ident -> {

$(

$(#[doc=$doc:literal])*

)*

}) => {

#[allow(non_snake_case)]

#[derive(Debug, Clone, Serialize)]

struct $name { $($field: $ty,)* }

impl_for_config_data!{

$modname,

$(

)*

}

}

}

impl $name {

/// Applies overrides from some more local config blob, to self.

fn apply_input(&mut self, input: $input) {

$(

if let Some(value) = input.$field {

)*

}

fn clone_with_overrides(&self, input: $input) -> Self {

Self {$(

$field: input.$field.unwrap_or_else(|| self.$field.clone()),

}

}

impl $input {

fn from_json(json: &mut serde_json::Value, error_sink: &mut Vec<(String, serde_json::Error)>) -> Self {

Self {$(

$field: get_field(

)*}

}

Self {$(

$field: get_field_toml::<$ty>(

toml,

}

};

}

use _config_data as config_data;

#[derive(Default, Debug, Clone)]

}

/// All of the config levels, all fields `Option<T>`, to describe fields that are actually set by

/// some rust-analyzer.toml file or JSON blob. An empty rust-analyzer.toml corresponds to

/// all fields being None.

global: GlobalConfigInput,

local: LocalConfigInput,

client: ClientConfigInput,

}

fn from_json(

mut json: serde_json::Value,

error_sink: &mut Vec<(String, serde_json::Error)>,

global: GlobalConfigInput::from_json(&mut json, error_sink),

local: LocalConfigInput::from_json(&mut json, error_sink),

client: ClientConfigInput::from_json(&mut json, error_sink),

}

}

fn schema_fields() -> Vec<SchemaField> {

let mut fields = Vec::new();

GlobalConfigInput::schema_fields(&mut fields);

}

}

fn get_field_toml<T: DeserializeOwned>(

val: &toml::Table,

error_sink: &mut Vec<(String, toml::de::Error)>,

#[test]

fn generate_config_documentation() {

let docs_path = project_root().join("docs/user/generated_config.adoc");

ensure_file_contents(&docs_path, &expected);

}