if let Some(path) = vfs.file_path(file.file_id).as_path() {
let path = path.to_path_buf();
if reload::should_refresh_for_change(&path, file.change_kind) {
- self.fetch_workspaces_queue.request_op();
+ self.fetch_workspaces_queue
+ .request_op(format!("vfs file change: {}", path.display()));
}
fs_changes.push((path, file.change_kind));
if file.is_created_or_deleted() {
);
}
- self.fetch_workspaces_queue.request_op();
- if self.fetch_workspaces_queue.should_start_op() {
- self.fetch_workspaces();
+ self.fetch_workspaces_queue.request_op("startup".to_string());
+ if let Some(cause) = self.fetch_workspaces_queue.should_start_op() {
+ self.fetch_workspaces(cause);
}
while let Some(event) = self.next_event(&inbox) {
let workspaces_updated = !Arc::ptr_eq(&old, &self.workspaces);
if self.config.run_build_scripts() && workspaces_updated {
- self.fetch_build_data_queue.request_op()
+ self.fetch_build_data_queue
+ .request_op(format!("workspace updated"));
}
(Progress::End, None)
self.prime_caches_queue.op_completed(());
if cancelled {
- self.prime_caches_queue.request_op();
+ self.prime_caches_queue
+ .request_op("restart after cancelation".to_string());
}
}
};
flycheck.update();
}
if self.config.prefill_caches() {
- self.prime_caches_queue.request_op();
+ self.prime_caches_queue.request_op("became quiescent".to_string());
}
}
}
if self.config.cargo_autoreload() {
- if self.fetch_workspaces_queue.should_start_op() {
- self.fetch_workspaces();
+ if let Some(cause) = self.fetch_workspaces_queue.should_start_op() {
+ self.fetch_workspaces(cause);
}
}
- if self.fetch_build_data_queue.should_start_op() {
- self.fetch_build_data();
+ if let Some(cause) = self.fetch_build_data_queue.should_start_op() {
+ self.fetch_build_data(cause);
}
- if self.prime_caches_queue.should_start_op() {
+ if let Some(cause) = self.prime_caches_queue.should_start_op() {
+ tracing::debug!(%cause, "will prime caches");
let num_worker_threads = self.config.prime_caches_num_threads();
self.task_pool.handle.spawn_with_sender({
RequestDispatcher { req: Some(req), global_state: self }
.on_sync_mut::<lsp_ext::ReloadWorkspace>(|s, ()| {
- s.fetch_workspaces_queue.request_op();
+ s.fetch_workspaces_queue.request_op("reload workspace request".to_string());
Ok(())
})?
.on_sync_mut::<lsp_types::request::Shutdown>(|s, ()| {
}
if let Ok(abs_path) = from_proto::abs_path(¶ms.text_document.uri) {
if reload::should_refresh_for_change(&abs_path, ChangeKind::Modify) {
- this.fetch_workspaces_queue.request_op();
+ this.fetch_workspaces_queue.request_op(format!("DidSaveTextDocument {}", abs_path.display()));
}
}
Ok(())
//! Bookkeeping to make sure only one long-running operation is being executed
//! at a time.
+pub(crate) type Cause = String;
+
pub(crate) struct OpQueue<Output> {
- op_requested: bool,
+ op_requested: Option<Cause>,
op_in_progress: bool,
last_op_result: Output,
}
impl<Output: Default> Default for OpQueue<Output> {
fn default() -> Self {
- Self { op_requested: false, op_in_progress: false, last_op_result: Default::default() }
+ Self { op_requested: None, op_in_progress: false, last_op_result: Default::default() }
}
}
impl<Output> OpQueue<Output> {
- pub(crate) fn request_op(&mut self) {
- self.op_requested = true;
+ pub(crate) fn request_op(&mut self, reason: Cause) {
+ self.op_requested = Some(reason);
}
- pub(crate) fn should_start_op(&mut self) -> bool {
+ pub(crate) fn should_start_op(&mut self) -> Option<Cause> {
if self.op_in_progress {
- return false;
+ return None;
}
- self.op_in_progress = self.op_requested;
- self.op_requested = false;
- self.op_in_progress
+ self.op_in_progress = self.op_requested.is_some();
+ self.op_requested.take()
}
pub(crate) fn op_completed(&mut self, result: Output) {
assert!(self.op_in_progress);
self.op_in_progress
}
pub(crate) fn op_requested(&self) -> bool {
- self.op_requested
+ self.op_requested.is_some()
}
}
global_state::GlobalState,
lsp_ext,
main_loop::Task,
+ op_queue::Cause,
};
#[derive(Debug)]
self.analysis_host.update_lru_capacity(self.config.lru_capacity());
}
if self.config.linked_projects() != old_config.linked_projects() {
- self.fetch_workspaces_queue.request_op()
+ self.fetch_workspaces_queue.request_op("linked projects changed".to_string())
} else if self.config.flycheck() != old_config.flycheck() {
self.reload_flycheck();
}
status
}
- pub(crate) fn fetch_workspaces(&mut self) {
- tracing::info!("will fetch workspaces");
+ pub(crate) fn fetch_workspaces(&mut self, cause: Cause) {
+ tracing::info!(%cause, "will fetch workspaces");
self.task_pool.handle.spawn_with_sender({
let linked_projects = self.config.linked_projects();
});
}
- pub(crate) fn fetch_build_data(&mut self) {
+ pub(crate) fn fetch_build_data(&mut self, cause: Cause) {
+ tracing::debug!(%cause, "will fetch build data");
let workspaces = Arc::clone(&self.workspaces);
let config = self.config.cargo();
self.task_pool.handle.spawn_with_sender(move |sender| {