use lsp_server::Connection;

use rust_analyzer::{

cli::flags,

from_json,

};

use semver::Version;

let mut change = ConfigChange::default();

change.change_client_config(json);

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

if !error_sink.is_empty() {

//! 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 cfg::{CfgAtom, CfgDiff};

use dirs::config_dir;

snippets: Vec<Snippet>,

visual_studio_code_version: Option<Version>,

/// Config node that obtains its initial value during the server initialization and

/// by receiving a `lsp_types::notification::DidChangeConfiguration`.

/// Path to the root configuration file. This can be seen as a generic way to define what would be `$XDG_CONFIG_HOME/rust-analyzer/rust-analyzer.toml` in Linux.

/// If not specified by init of a `Config` object this value defaults to :

/// FIXME @alibektas : Change this to sth better.

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

/// A special file for this session whose path is set to `self.root_path.join("rust-analyzer.toml")`

root_ratoml_path: VfsPath,

/// This file can be used to make global changes while having only a workspace-wide scope.

/// For every `SourceRoot` there can be at most one RATOML file.

/// Clone of the value that is stored inside a `GlobalState`.

source_root_parent_map: Arc<FxHashMap<SourceRootId, SourceRootId>>,

// FIXME @alibektas : Server's health uses error sink but in other places it is not used atm.

/// Changes made to client and global configurations will partially not be reflected even after `.apply_change()` was called.

/// The return tuple's bool component signals whether the `GlobalState` should call its `update_configuration()` method.

let mut config = self.clone();

let mut should_update = false;

if let Some(change) = change.user_config_change {

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

validate_toml_table(

GlobalLocalConfigInput::FIELDS,

&table,

&mut String::new(),

&mut toml_errors,

);

should_update = true;

}

}

if let Some(mut json) = change.client_config_change {

tracing::info!("updating config from JSON: {:#}", json);

if !(json.is_null() || json.as_object().map_or(false, |it| it.is_empty())) {

let detached_files = get_field::<Vec<Utf8PathBuf>>(

&mut json,

&mut json_errors,

patch_old_style::patch_json_for_outdated_configs(&mut json);

config.detached_files = detached_files;

}

should_update = true;

}

if let Some(change) = change.root_ratoml_change {

match toml::from_str(&change) {

Ok(table) => {

validate_toml_table(

GlobalLocalConfigInput::FIELDS,

&table,

&mut String::new(),

&mut toml_errors,

);

should_update = true;

}

}

}

if let Some(change) = change.ratoml_file_change {

for (source_root_id, (_, text)) in change {

if let Some(text) = text {

match toml::from_str(&text) {

Ok(table) => {

validate_toml_table(

);

config.ratoml_files.insert(

source_root_id,

);

}

}

}

}

SnippetScopeDef::Type => SnippetScope::Type,

SnippetScopeDef::Item => SnippetScope::Item,

};

match Snippet::new(

&def.prefix,

&def.postfix,

scope,

) {

Some(snippet) => config.snippets.push(snippet),

}

}

(config, should_update)

}

/// Given `change` this generates a new `Config`, thereby collecting errors of type `ConfigError`.

/// If there are changes that have global/client level effect, the last component of the return type

/// will be set to `true`, which should be used by the `GlobalState` to update itself.

(config, e, should_update)

}

}

#[derive(Debug)]

pub enum ConfigErrorInner {

}

pub fn is_empty(&self) -> bool {

self.0.is_empty()

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

f(key)?;

f(&": ")?;

f(e)

}

f(key)?;

f(&": ")?;

f(e)

}

}

impl Config {

pub fn new(

visual_studio_code_version: Option<Version>,

user_config_path: Option<Utf8PathBuf>,

) -> Self {

let user_config_path = if let Some(user_config_path) = user_config_path {

user_config_path.join("rust-analyzer").join("rust-analyzer.toml")

} else {

snippets: Default::default(),

workspace_roots,

visual_studio_code_version,

user_config: None,

ratoml_files: FxHashMap::default(),

source_root_parent_map: Arc::new(FxHashMap::default()),

user_config_path,

root_ratoml: None,

let mut par: Option<SourceRootId> = source_root;

while let Some(source_root_id) = par {

par = self.source_root_parent_map.get(&source_root_id).copied();

if let Some(value) = config.$field.as_ref() {

return value;

}

}

}

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

return &v;

}

}

return &v;

}

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

return &v;

}

#[allow(non_snake_case)]

$vis fn $field(&self) -> &$ty {

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

return &v;

}

}

return &v;

}

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

return &v;

}

$($doc)*

#[allow(non_snake_case)]

$vis fn $field(&self) -> &$ty {

return &v;

}

}

}

field: &'static str,

alias: Option<&'static str>,

) -> Option<T> {

alias

.into_iter()

.chain(iter::once(field))

.filter_map(move |field| {

})

.find(Result::is_ok)

.and_then(|res| match res {

Ok(it) => Some(it),

Err((e, pointer)) => {

None

}

})

}

field: &'static str,

alias: Option<&'static str>,

) -> Option<T> {

.filter_map(move |field| {

let mut pointer = field.replace('_', "/");

pointer.insert(0, '/');

})

.find(Result::is_ok)

.and_then(|res| match res {

})

}

type SchemaField = (&'static str, &'static str, &'static [&'static str], String);

fn schema(fields: &[SchemaField]) -> serde_json::Value {

// This is a table config, any entry in it is therefor valid

toml::Value::Table(_) if verify(ptr) => (),

toml::Value::Table(table) => validate_toml_table(known_ptrs, table, ptr, error_sink),

_ => (),

}

.to_string(),

));

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

expect_test::expect![[r#"

[

inner: Error {

inner: TomlError {

message: "unexpected field",

},

},

},

],

)

"#]]

//!

//! Each tick provides an immutable snapshot of the state as `WorldSnapshot`.

use crossbeam_channel::{unbounded, Receiver, Sender};

use flycheck::FlycheckHandle;

use vfs::{AnchoredPathBuf, Vfs, VfsPath};

use crate::{

diagnostics::{CheckFixes, DiagnosticCollection},

line_index::{LineEndings, LineIndex},

lsp::{

pub(crate) fmt_pool: Handle<TaskPool<Task>, Receiver<Task>>,

pub(crate) config: Arc<Config>,

pub(crate) analysis_host: AnalysisHost,

pub(crate) diagnostics: DiagnosticCollection,

pub(crate) mem_docs: MemDocs,

change

};

if should_update {

self.update_configuration(config);

//! This module is responsible for implementing handlers for Language Server

//! Protocol. This module specifically handles notifications.

use itertools::Itertools;

use lsp_types::{

}

(None, Some(mut configs)) => {

if let Some(json) = configs.get_mut(0) {

let mut change = ConfigChange::default();

change.change_client_config(json.take());

// Client config changes neccesitates .update_config method to be called.

this.update_configuration(config);

//! project is currently loading and we don't have a full project model, we

//! still want to respond to various requests.

// FIXME: This is a mess that needs some untangling work

use flycheck::{FlycheckConfig, FlycheckHandle};

use hir::{db::DefDatabase, ChangeWithProcMacros, ProcMacros};

let mut config_change = ConfigChange::default();

config_change.change_source_root_parent_map(self.local_roots_parent_map.clone());

self.config = Arc::new(config);

use lsp_types::{notification::Exit, request::Shutdown, TextDocumentIdentifier, Url};

use paths::{Utf8Path, Utf8PathBuf};

use rust_analyzer::{

lsp, main_loop,

};

use serde::Serialize;

change.change_client_config(self.config);

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

assert!(error_sink.is_empty(), "{error_sink:?}");