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

rustc_source: Option<String> = None,

/// Enables automatic discovery of projects using [`DiscoverWorkspaceConfig::command`].

///

}

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

client: struct ClientDefaultConfigData <- ClientConfigInput -> {

#[derive(Debug, Clone)]

#[allow(clippy::large_enum_variant)]

enum RatomlFile {

Crate(LocalConfigInput),

}

client_config: (FullConfigInput, ConfigErrors),

/// Config node whose values apply to **every** Rust project.

ratoml_file: FxHashMap<SourceRootId, (RatomlFile, ConfigErrors)>,

if let Ok(table) = toml::from_str(&change) {

let mut toml_errors = vec![];

validate_toml_table(

&table,

&mut String::new(),

&mut toml_errors,

);

config.user_config = Some((

ConfigErrors(

toml_errors

.into_iter()

match toml::from_str(&text) {

Ok(table) => {

validate_toml_table(

&table,

&mut String::new(),

&mut toml_errors,

source_root_id,

(

RatomlFile::Workspace(

table,

&mut toml_errors,

),

config.source_root_parent_map = source_root_map;

}

config.validation_errors.0.push(Arc::new(ConfigErrorInner::Json {

config_key: "/check/command".to_owned(),

error: serde_json::Error::custom("expected a non-empty string"),

pub fn diagnostics(&self, source_root: Option<SourceRootId>) -> DiagnosticsConfig {

DiagnosticsConfig {

proc_attr_macros_enabled: self.expand_proc_attr_macros(),

proc_macros_enabled: *self.procMacro_enable(),

expr_fill_default: match self.assist_expressionFillDefault(source_root) {

ExprFillDefaultDef::Todo => ExprFillDefaultMode::Todo,

ExprFillDefaultDef::Default => ExprFillDefaultMode::Default,

prefer_no_std: self.imports_preferNoStd(source_root).to_owned(),

prefer_prelude: self.imports_preferPrelude(source_root).to_owned(),

prefer_absolute: self.imports_prefixExternPrelude(source_root).to_owned(),

term_search_fuel: self.assist_termSearch_fuel(source_root).to_owned() as u64,

term_search_borrowck: self.assist_termSearch_borrowcheck(source_root).to_owned(),

}

}

pub fn has_linked_projects(&self) -> bool {

}

pub fn linked_manifests(&self) -> impl Iterator<Item = &Utf8Path> + '_ {

ManifestOrProjectJson::Manifest(p) => Some(&**p),

// despite having a buildfile, using this variant as a manifest

// will fail.

}

pub fn has_linked_project_jsons(&self) -> bool {

.iter()

.any(|it| matches!(it, ManifestOrProjectJson::ProjectJson { .. }))

}

pub fn discover_workspace_config(&self) -> Option<&DiscoverWorkspaceConfig> {

}

pub fn linked_or_discovered_projects(&self) -> Vec<LinkedProject> {

[] => {

let exclude_dirs: Vec<_> =

self.discovered_projects

.iter()

.filter(|project| {

}

pub fn prefill_caches(&self) -> bool {

}

pub fn publish_diagnostics(&self) -> bool {

}

pub fn diagnostics_map(&self) -> DiagnosticsMapConfig {

DiagnosticsMapConfig {

}

}

pub fn extra_args(&self) -> &Vec<String> {

}

pub fn extra_env(&self) -> &FxHashMap<String, String> {

}

pub fn check_extra_args(&self) -> Vec<String> {

let mut extra_args = self.extra_args().clone();

extra_args

}

pub fn check_extra_env(&self) -> FxHashMap<String, String> {

extra_env

}

pub fn lru_parse_query_capacity(&self) -> Option<u16> {

}

pub fn lru_query_capacities_config(&self) -> Option<&FxHashMap<Box<str>, u16>> {

}

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

}

pub fn ignored_proc_macros(&self) -> &FxHashMap<Box<str>, Box<[Box<str>]>> {

}

pub fn expand_proc_macros(&self) -> bool {

}

_ => FilesWatcher::Server,

},

}

}

}

pub fn cargo_autoreload_config(&self) -> bool {

}

pub fn run_build_scripts(&self) -> bool {

}

pub fn cargo(&self) -> CargoConfig {

if rustc_src == "discover" {

RustLibSource::Discover

} else {

RustLibSource::Path(self.root_path.join(rustc_src))

}

});

if sysroot == "discover" {

RustLibSource::Discover

} else {

}

});

let sysroot_src =

CargoConfig {

CargoFeaturesDef::All => CargoFeatures::All,

CargoFeaturesDef::Selected(features) => CargoFeatures::Selected {

features: features.clone(),

},

},

sysroot,

sysroot_src,

rustc_source,

cfg_overrides: project_model::CfgOverrides {

global: CfgDiff::new(

.iter()

.map(|(key, val)| match val {

Some(val) => CfgAtom::KeyValue {

.unwrap(),

selective: Default::default(),

},

InvocationStrategy::Once => project_model::InvocationStrategy::Once,

InvocationStrategy::PerWorkspace => project_model::InvocationStrategy::PerWorkspace,

},

target_dir: self.target_dir_from_config(),

}

}

}

pub fn flycheck_workspace(&self) -> bool {

}

pub(crate) fn cargo_test_options(&self) -> CargoOptions {

CargoOptions {

all_targets: false,

CargoFeaturesDef::All => vec![],

CargoFeaturesDef::Selected(it) => it,

},

}

pub(crate) fn flycheck(&self) -> FlycheckConfig {

Some(args) if !args.is_empty() => {

let mut args = args.clone();

let command = args.remove(0);

command,

args,

extra_env: self.check_extra_env(),

InvocationStrategy::Once => crate::flycheck::InvocationStrategy::Once,

InvocationStrategy::PerWorkspace => {

crate::flycheck::InvocationStrategy::PerWorkspace

}

}

Some(_) | None => FlycheckConfig::CargoCommand {

options: CargoOptions {

target_triples: self

.clone()

.and_then(|targets| match &targets.0[..] {

[] => None,

targets => Some(targets.into()),

})

no_default_features: self

all_features: matches!(

CargoFeaturesDef::All

),

features: match self

.clone()

{

CargoFeaturesDef::All => vec![],

CargoFeaturesDef::Selected(it) => it,

}

fn target_dir_from_config(&self) -> Option<Utf8PathBuf> {

TargetDirectory::UseSubdirectory(true) => {

Some(Utf8PathBuf::from("target/rust-analyzer"))

}

}

pub fn check_on_save(&self) -> bool {

}

pub fn script_rebuild_on_save(&self) -> bool {

}

pub fn runnables(&self) -> RunnablesConfig {

RunnablesConfig {

}

}

}

pub fn prime_caches_num_threads(&self) -> usize {

NumThreads::Concrete(0) | NumThreads::Physical => num_cpus::get_physical(),

&NumThreads::Concrete(n) => n,

NumThreads::Logical => num_cpus::get(),

)*

}

};

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

$vis:vis $field:ident : $ty:ty = $default:expr,

)*

$(

$($doc)*

#[allow(non_snake_case)]

let mut source_root = source_root.as_ref();

while let Some(sr) = source_root {

if let Some((RatomlFile::Workspace(config), _)) = self.ratoml_file.get(&sr) {

return &v;

}

}

source_root = self.source_root_parent_map.get(&sr);

}

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

return &v;

}

#[derive(Default, Debug, Clone)]

struct DefaultConfigData {

global: GlobalDefaultConfigData,

local: LocalDefaultConfigData,

client: ClientDefaultConfigData,

}

#[derive(Debug, Clone, Default)]

struct FullConfigInput {

global: GlobalConfigInput,

local: LocalConfigInput,

client: ClientConfigInput,

}

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

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

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

}

}

GlobalConfigInput::schema_fields(&mut fields);

LocalConfigInput::schema_fields(&mut fields);

ClientConfigInput::schema_fields(&mut fields);

fields.sort_by_key(|&(x, ..)| x);

fields

.iter()

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

/// all fields being None.

#[derive(Debug, Clone, Default)]

global: GlobalConfigInput,

local: LocalConfigInput,

}

const FIELDS: &'static [&'static [&'static str]] =

&[GlobalConfigInput::FIELDS, LocalConfigInput::FIELDS];

fn from_toml(

toml: toml::Table,

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

global: GlobalConfigInput::from_toml(&toml, error_sink),

local: LocalConfigInput::from_toml(&toml, error_sink),

}

}

}

}));

(config, _, _) = config.apply_change(change);

assert!(

matches!(config.flycheck(), FlycheckConfig::CargoCommand { options, .. } if options.target_dir.is_none())

);

(config, _, _) = config.apply_change(change);

assert!(

matches!(config.flycheck(), FlycheckConfig::CargoCommand { options, .. } if options.target_dir == Some(Utf8PathBuf::from("target/rust-analyzer")))

);

(config, _, _) = config.apply_change(change);

assert_eq!(

&Some(TargetDirectory::Directory(Utf8PathBuf::from("other_folder")))

);

assert!(

let edition = editions.iter().copied().max();

let line_index = snap.file_line_index(file_id)?;

RustfmtConfig::Rustfmt { extra_args, enable_range_formatting } => {

// FIXME: Set RUSTUP_TOOLCHAIN

let mut cmd = process::Command::new(toolchain::Tool::Rustfmt.path());

.transpose()?;

serde_json::to_value(match &*params.config {

"local" => state.config.assist(source_root).assist_emit_must_use,

state.config.rustfmt(source_root),

RustfmtConfig::Rustfmt { enable_range_formatting: true, .. }

),

};

let mut message = String::new();

&& self.is_quiescent()

&& self.fetch_workspaces_queue.op_requested()

&& self.config.discover_workspace_config().is_none()

/// A query whose config key is a part of the global configs, so that

/// testing for changes to this config means testing if global changes

/// take affect.

}

struct RatomlTest {

fn query(&self, query: QueryType, source_file_idx: usize) -> bool {

let config = match query {

QueryType::Local => "local".to_owned(),

};

let res = self.server.send_request::<InternalTestingFetchConfig>(

InternalTestingFetchConfigParams {

// assert!(!server.query(QueryType::AssistEmitMustUse, 5));

// }

#[test]

if skip_slow_tests() {

return;

}

None,

);

}

#[test]

None,

);

server.edit(1, "rustfmt.rangeFormatting.enable = false".to_owned());

}

#[test]

None,

);

server.delete(1);

}