From 3f74f22e4a85ae4cca0abf5c5a29b18e35dafb6a Mon Sep 17 00:00:00 2001 From: Wilfred Hughes Date: Fri, 28 Nov 2025 11:58:30 +0000 Subject: [PATCH] Use 'deferred task' terminology consistently --- crates/rust-analyzer/src/global_state.rs | 18 +++++++------- .../src/handlers/notification.rs | 2 +- crates/rust-analyzer/src/main_loop.rs | 24 +++++++++---------- crates/rust-analyzer/src/task_pool.rs | 14 +++++------ 4 files changed, 29 insertions(+), 29 deletions(-) diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs index 91f7db785440..9f58c17ac029 100644 --- a/crates/rust-analyzer/src/global_state.rs +++ b/crates/rust-analyzer/src/global_state.rs @@ -45,7 +45,7 @@ use crate::{ op_queue::{Cause, OpQueue}, reload, target_spec::{CargoTargetSpec, ProjectJsonTargetSpec, TargetSpec}, - task_pool::{TaskPool, TaskQueue}, + task_pool::{DeferredTaskQueue, TaskPool}, test_runner::{CargoTestHandle, CargoTestMessage}, }; @@ -186,7 +186,8 @@ pub(crate) struct GlobalState { /// For certain features, such as [`GlobalState::handle_discover_msg`], /// this queue should run only *after* [`GlobalState::process_changes`] has /// been called. - pub(crate) deferred_task_queue: TaskQueue, + pub(crate) deferred_task_queue: DeferredTaskQueue, + /// HACK: Workaround for https://github.com/rust-lang/rust-analyzer/issues/19709 /// This is marked true if we failed to load a crate root file at crate graph creation, /// which will usually end up causing a bunch of incorrect diagnostics on startup. @@ -241,9 +242,9 @@ impl GlobalState { }; let cancellation_pool = thread::Pool::new(1); - let task_queue = { + let deferred_task_queue = { let (sender, receiver) = unbounded(); - TaskQueue { sender, receiver } + DeferredTaskQueue { sender, receiver } }; let mut analysis_host = AnalysisHost::new(config.lru_parse_query_capacity()); @@ -314,7 +315,7 @@ impl GlobalState { prime_caches_queue: OpQueue::default(), discover_workspace_queue: OpQueue::default(), - deferred_task_queue: task_queue, + deferred_task_queue, incomplete_crate_graph: false, minicore: MiniCoreRustAnalyzerInternalOnly::default(), @@ -540,10 +541,9 @@ impl GlobalState { // didn't find anything (to make up for the lack of precision). { if !matches!(&workspace_structure_change, Some((.., true))) { - _ = self - .deferred_task_queue - .sender - .send(crate::main_loop::QueuedTask::CheckProcMacroSources(modified_rust_files)); + _ = self.deferred_task_queue.sender.send( + crate::main_loop::DeferredTask::CheckProcMacroSources(modified_rust_files), + ); } // FIXME: ideally we should only trigger a workspace fetch for non-library changes // but something's going wrong with the source root business when we add a new local diff --git a/crates/rust-analyzer/src/handlers/notification.rs b/crates/rust-analyzer/src/handlers/notification.rs index 87be09dcbd27..4a6544508ff4 100644 --- a/crates/rust-analyzer/src/handlers/notification.rs +++ b/crates/rust-analyzer/src/handlers/notification.rs @@ -91,7 +91,7 @@ pub(crate) fn handle_did_open_text_document( let _ = state .deferred_task_queue .sender - .send(crate::main_loop::QueuedTask::CheckIfIndexed(params.text_document.uri)); + .send(crate::main_loop::DeferredTask::CheckIfIndexed(params.text_document.uri)); } } Ok(()) diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs index 8b4748ddb3d7..04c416267f41 100644 --- a/crates/rust-analyzer/src/main_loop.rs +++ b/crates/rust-analyzer/src/main_loop.rs @@ -74,7 +74,7 @@ pub fn main_loop(config: Config, connection: Connection) -> anyhow::Result<()> { enum Event { Lsp(lsp_server::Message), Task(Task), - QueuedTask(QueuedTask), + DeferredTask(DeferredTask), Vfs(vfs::loader::Message), Flycheck(FlycheckMessage), TestResult(CargoTestMessage), @@ -89,7 +89,7 @@ impl fmt::Display for Event { Event::Task(_) => write!(f, "Event::Task"), Event::Vfs(_) => write!(f, "Event::Vfs"), Event::Flycheck(_) => write!(f, "Event::Flycheck"), - Event::QueuedTask(_) => write!(f, "Event::QueuedTask"), + Event::DeferredTask(_) => write!(f, "Event::DeferredTask"), Event::TestResult(_) => write!(f, "Event::TestResult"), Event::DiscoverProject(_) => write!(f, "Event::DiscoverProject"), Event::FetchWorkspaces(_) => write!(f, "Event::SwitchWorkspaces"), @@ -98,7 +98,7 @@ impl fmt::Display for Event { } #[derive(Debug)] -pub(crate) enum QueuedTask { +pub(crate) enum DeferredTask { CheckIfIndexed(lsp_types::Url), CheckProcMacroSources(Vec), } @@ -164,7 +164,7 @@ impl fmt::Debug for Event { match self { Event::Lsp(it) => fmt::Debug::fmt(it, f), Event::Task(it) => fmt::Debug::fmt(it, f), - Event::QueuedTask(it) => fmt::Debug::fmt(it, f), + Event::DeferredTask(it) => fmt::Debug::fmt(it, f), Event::Vfs(it) => fmt::Debug::fmt(it, f), Event::Flycheck(it) => fmt::Debug::fmt(it, f), Event::TestResult(it) => fmt::Debug::fmt(it, f), @@ -279,7 +279,7 @@ impl GlobalState { task.map(Event::Task), recv(self.deferred_task_queue.receiver) -> task => - task.map(Event::QueuedTask), + task.map(Event::DeferredTask), recv(self.fmt_pool.receiver) -> task => task.map(Event::Task), @@ -323,12 +323,12 @@ impl GlobalState { lsp_server::Message::Notification(not) => self.on_notification(not), lsp_server::Message::Response(resp) => self.complete_request(resp), }, - Event::QueuedTask(task) => { + Event::DeferredTask(task) => { let _p = tracing::info_span!("GlobalState::handle_event/queued_task").entered(); - self.handle_queued_task(task); - // Coalesce multiple task events into one loop turn + self.handle_deferred_task(task); + // Coalesce multiple deferred task events into one loop turn while let Ok(task) = self.deferred_task_queue.receiver.try_recv() { - self.handle_queued_task(task); + self.handle_deferred_task(task); } } Event::Task(task) => { @@ -981,9 +981,9 @@ impl GlobalState { } } - fn handle_queued_task(&mut self, task: QueuedTask) { + fn handle_deferred_task(&mut self, task: DeferredTask) { match task { - QueuedTask::CheckIfIndexed(uri) => { + DeferredTask::CheckIfIndexed(uri) => { let snap = self.snapshot(); self.task_pool.handle.spawn_with_sender(ThreadIntent::Worker, move |sender| { @@ -1007,7 +1007,7 @@ impl GlobalState { } }); } - QueuedTask::CheckProcMacroSources(modified_rust_files) => { + DeferredTask::CheckProcMacroSources(modified_rust_files) => { let analysis = AssertUnwindSafe(self.snapshot().analysis); self.task_pool.handle.spawn_with_sender(stdx::thread::ThreadIntent::Worker, { move |sender| { diff --git a/crates/rust-analyzer/src/task_pool.rs b/crates/rust-analyzer/src/task_pool.rs index c5de69bb9fc8..ef0feb179698 100644 --- a/crates/rust-analyzer/src/task_pool.rs +++ b/crates/rust-analyzer/src/task_pool.rs @@ -6,7 +6,7 @@ use std::panic::UnwindSafe; use crossbeam_channel::Sender; use stdx::thread::{Pool, ThreadIntent}; -use crate::main_loop::QueuedTask; +use crate::main_loop::DeferredTask; pub(crate) struct TaskPool { sender: Sender, @@ -45,11 +45,11 @@ impl TaskPool { } } -/// `TaskQueue`, like its name suggests, queues tasks. +/// `DeferredTaskQueue` holds deferred tasks. /// -/// This should only be used if a task must run after [`GlobalState::process_changes`] -/// has been called. -pub(crate) struct TaskQueue { - pub(crate) sender: crossbeam_channel::Sender, - pub(crate) receiver: crossbeam_channel::Receiver, +/// These are tasks that must be run after +/// [`GlobalState::process_changes`] has been called. +pub(crate) struct DeferredTaskQueue { + pub(crate) sender: crossbeam_channel::Sender, + pub(crate) receiver: crossbeam_channel::Receiver, }