}

#[derive(Debug)]

errors: Vec<(String, serde_json::Error)>,

}

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

let errors = self.errors.iter().format_with("\n", |(key, e), f| {

f(key)?;

});

write!(

f,

if self.errors.len() == 1 { "" } else { "s" },

errors

)

self.workspace_roots.extend(paths);

}

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

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

return Ok(());

if errors.is_empty() {

Ok(())

} else {

}

}

use vfs::AnchoredPathBuf;

use crate::{

diagnostics::{CheckFixes, DiagnosticCollection},

from_proto,

line_index::{LineEndings, LineIndex},

pub(crate) struct GlobalState {

sender: Sender<lsp_server::Message>,

req_queue: ReqQueue,

pub(crate) task_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,

pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,

pub(crate) shutdown_requested: bool,

pub(crate) last_reported_status: Option<lsp_ext::ServerStatusParams>,

pub(crate) proc_macro_changed: bool,

pub(crate) proc_macro_clients: Arc<[anyhow::Result<ProcMacroServer>]>,

pub(crate) flycheck: Arc<[FlycheckHandle]>,

pub(crate) flycheck_sender: Sender<flycheck::Message>,

pub(crate) flycheck_receiver: Receiver<flycheck::Message>,

pub(crate) vfs: Arc<RwLock<(vfs::Vfs, IntMap<FileId, LineEndings>)>>,

pub(crate) vfs_config_version: u32,

pub(crate) vfs_progress_config_version: u32,

/// the user just adds comments or whitespace to Cargo.toml, we do not want

/// to invalidate any salsa caches.

pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,

pub(crate) fetch_workspaces_queue: OpQueue<(), Option<Vec<anyhow::Result<ProjectWorkspace>>>>,

pub(crate) fetch_build_data_queue:

OpQueue<(), (Arc<Vec<ProjectWorkspace>>, Vec<anyhow::Result<WorkspaceBuildScripts>>)>,

pub(crate) fetch_proc_macros_queue: OpQueue<Vec<ProcMacroPaths>, bool>,

pub(crate) prime_caches_queue: OpQueue,

}

shutdown_requested: false,

last_reported_status: None,

source_root_config: SourceRootConfig::default(),

proc_macro_changed: false,

// FIXME: use `Arc::from_iter` when it becomes available

flycheck: Arc::from(Vec::new()),

flycheck_sender,

flycheck_receiver,

vfs: Arc::new(RwLock::new((vfs::Vfs::default(), IntMap::default()))),

vfs_config_version: 0,

// Note that json can be null according to the spec if the client can't

// provide a configuration. This is handled in Config::update below.

let mut config = Config::clone(&*this.config);

this.update_configuration(config);

}

}

impl fmt::Debug for Event {

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

f.debug_struct("Notification").field("method", &not.method).finish()

};

if notification_is::<lsp_types::notification::DidOpenTextDocument>(not)

|| notification_is::<lsp_types::notification::DidChangeTextDocument>(not)

{

}

}

Event::Task(Task::Response(resp)) => {

self.update_status_or_notify();

if self.config.did_save_text_document_dynamic_registration() {

}

self.fetch_workspaces_queue.request_op("startup".to_string(), ());

}

while let Some(event) = self.next_event(&inbox) {

}

}

Err("client exited without proper shutdown sequence".into())

}

fn next_event(&self, inbox: &Receiver<lsp_server::Message>) -> Option<Event> {

select! {

recv(inbox) -> msg =>

// NOTE: don't count blocking select! call as a loop-turn time

let _p = profile::span("GlobalState::handle_event");

}

let was_quiescent = self.is_quiescent();

match event {

Event::Lsp(msg) => match msg {

lsp_server::Message::Request(req) => self.on_new_request(loop_start, req),

lsp_server::Message::Response(resp) => self.complete_request(resp),

},

Event::Task(task) => {

}

}

// Refresh semantic tokens if the client supports it.

if self.config.semantic_tokens_refresh() {

self.semantic_tokens_cache.lock().clear();

}

}

self.update_diagnostics()

}

}

}

if let Some((cause, ())) = self.prime_caches_queue.should_start_op() {

}

self.update_status_or_notify();

let loop_duration = loop_start.elapsed();

if loop_duration > Duration::from_millis(100) && was_quiescent {

self.poke_rust_analyzer_developer(format!(

));

}

Ok(())

}

fn update_status_or_notify(&mut self) {

let status = self.current_status();

if self.last_reported_status.as_ref() != Some(&status) {

if self.config.server_status_notification() {

self.send_notification::<lsp_ext::ServerStatusNotification>(status);

let open_log_button = tracing::enabled!(tracing::Level::ERROR)

&& (self.fetch_build_data_error().is_err()

|| self.fetch_workspace_error().is_err());

(Progress::Begin, None)

}

flycheck::Progress::DidCheckCrate(target) => (Progress::Report, Some(target)),

flycheck::Progress::DidFailToRestart(err) => {

return;

}

flycheck::Progress::DidFinish(result) => {

(Progress::End, None)

}

};

use itertools::Itertools;

use proc_macro_api::{MacroDylib, ProcMacroServer};

use project_model::{PackageRoot, ProjectWorkspace, WorkspaceBuildScripts};

use syntax::SmolStr;

use triomphe::Arc;

use vfs::{file_set::FileSetConfig, AbsPath, AbsPathBuf, ChangeKind};

message.push_str("Failed to discover workspace.\n");

message.push_str("Consider adding the `Cargo.toml` of the workspace to the [`linkedProjects`](https://rust-analyzer.github.io/manual.html#rust-analyzer.linkedProjects) setting.\n\n");

}

for ws in self.workspaces.iter() {

let (ProjectWorkspace::Cargo { sysroot, .. }