More robust status notifications

Author: matklad

crates/rust-analyzer/src/config.rs

@@ -445,8 +445,8 @@ impl Config {
     pub fn hover_actions(&self) -> bool {
         self.experimental("hoverActions")
     }
-    pub fn status_notification(&self) -> bool {
-        self.experimental("statusNotification")
+    pub fn server_status_notification(&self) -> bool {
+        self.experimental("serverStatusNotification")
     }
 
     pub fn publish_diagnostics(&self) -> bool {

crates/rust-analyzer/src/global_state.rs

@@ -23,6 +23,7 @@ use crate::{
     document::DocumentData,
     from_proto,
     line_index::{LineEndings, LineIndex},
+    lsp_ext,
     main_loop::Task,
     op_queue::OpQueue,
     reload::SourceRootConfig,
@@ -32,20 +33,6 @@ use crate::{
     Result,
 };
 
-#[derive(Eq, PartialEq, Copy, Clone)]
-pub(crate) enum Status {
-    Loading,
-    Ready { partial: bool },
-    Invalid,
-    NeedsReload,
-}
-
-impl Default for Status {
-    fn default() -> Self {
-        Status::Loading
-    }
-}
-
 // Enforces drop order
 pub(crate) struct Handle<H, C> {
     pub(crate) handle: H,
@@ -73,7 +60,7 @@ pub(crate) struct GlobalState {
     pub(crate) mem_docs: FxHashMap<VfsPath, DocumentData>,
     pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,
     pub(crate) shutdown_requested: bool,
-    pub(crate) status: Status,
+    pub(crate) last_reported_status: Option<lsp_ext::ServerStatusParams>,
     pub(crate) source_root_config: SourceRootConfig,
     pub(crate) proc_macro_client: Option<ProcMacroClient>,
 
@@ -83,6 +70,7 @@ pub(crate) struct GlobalState {
 
     pub(crate) vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,
     pub(crate) vfs_config_version: u32,
+    pub(crate) vfs_progress_config_version: u32,
     pub(crate) vfs_progress_n_total: usize,
     pub(crate) vfs_progress_n_done: usize,
 
@@ -141,7 +129,7 @@ impl GlobalState {
             mem_docs: FxHashMap::default(),
             semantic_tokens_cache: Arc::new(Default::default()),
             shutdown_requested: false,
-            status: Status::default(),
+            last_reported_status: None,
             source_root_config: SourceRootConfig::default(),
             proc_macro_client: None,
 
@@ -151,14 +139,15 @@ impl GlobalState {
 
             vfs: Arc::new(RwLock::new((vfs::Vfs::default(), FxHashMap::default()))),
             vfs_config_version: 0,
+            vfs_progress_config_version: 0,
             vfs_progress_n_total: 0,
             vfs_progress_n_done: 0,
 
             workspaces: Arc::new(Vec::new()),
             fetch_workspaces_queue: OpQueue::default(),
             workspace_build_data: None,
-            fetch_build_data_queue: OpQueue::default(),
 
+            fetch_build_data_queue: OpQueue::default(),
             latest_requests: Default::default(),
         }
     }

crates/rust-analyzer/src/lsp_ext.rs

@@ -241,26 +241,26 @@ pub struct SsrParams {
     pub selections: Vec<lsp_types::Range>,
 }
 
-pub enum StatusNotification {}
+pub enum ServerStatusNotification {}
 
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum Status {
-    Loading,
-    ReadyPartial,
-    Ready,
-    NeedsReload,
-    Invalid,
+impl Notification for ServerStatusNotification {
+    type Params = ServerStatusParams;
+    const METHOD: &'static str = "experimental/serverStatus";
 }
 
-#[derive(Deserialize, Serialize)]
-pub struct StatusParams {
-    pub status: Status,
+#[derive(Deserialize, Serialize, PartialEq, Eq, Clone)]
+pub struct ServerStatusParams {
+    pub health: Health,
+    pub quiescent: bool,
+    pub message: Option<String>,
 }
 
-impl Notification for StatusNotification {
-    type Params = StatusParams;
-    const METHOD: &'static str = "rust-analyzer/status";
+#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub enum Health {
+    Ok,
+    Warning,
+    Error,
 }
 
 pub enum CodeActionRequest {}

crates/rust-analyzer/src/main_loop.rs

@@ -21,7 +21,7 @@ use crate::{
     dispatch::{NotificationDispatcher, RequestDispatcher},
     document::DocumentData,
     from_proto,
-    global_state::{file_id_to_url, url_to_file_id, GlobalState, Status},
+    global_state::{file_id_to_url, url_to_file_id, GlobalState},
     handlers, lsp_ext,
     lsp_utils::{apply_document_changes, is_canceled, notification_is, Progress},
     reload::{BuildDataProgress, ProjectWorkspaceProgress},
@@ -189,7 +189,7 @@ impl GlobalState {
             log::info!("task queue len: {}", task_queue_len);
         }
 
-        let mut new_status = self.status;
+        let was_quiescent = self.is_quiescent();
         match event {
             Event::Lsp(msg) => match msg {
                 lsp_server::Message::Request(req) => self.on_request(loop_start, req)?,
@@ -314,9 +314,12 @@ impl GlobalState {
                             }
                         }
                         vfs::loader::Message::Progress { n_total, n_done, config_version } => {
+                            always!(config_version <= self.vfs_config_version);
+
+                            self.vfs_progress_config_version = config_version;
                             self.vfs_progress_n_total = n_total;
                             self.vfs_progress_n_done = n_done;
-                            always!(config_version <= self.vfs_config_version);
+
                             let state = if n_done == 0 {
                                 Progress::Begin
                             } else if n_done < n_total {
@@ -406,18 +409,14 @@ impl GlobalState {
         }
 
         let state_changed = self.process_changes();
-        let prev_status = self.status;
-        if prev_status != new_status {
-            self.transition(new_status);
-        }
-        let is_ready = matches!(self.status, Status::Ready { .. });
-        if prev_status == Status::Loading && is_ready {
+
+        if self.is_quiescent() && !was_quiescent {
             for flycheck in &self.flycheck {
                 flycheck.update();
             }
         }
 
-        if is_ready && (state_changed || prev_status == Status::Loading) {
+        if self.is_quiescent() && (!was_quiescent || state_changed) {
             self.update_file_notifications_on_threadpool();
 
             // Refresh semantic tokens if the client supports it.
@@ -451,6 +450,8 @@ impl GlobalState {
         }
         self.fetch_build_data_if_needed();
 
+        self.report_new_status_if_needed();
+
         let loop_duration = loop_start.elapsed();
         if loop_duration > Duration::from_millis(100) {
             log::warn!("overly long loop turn: {:?}", loop_duration);
@@ -477,7 +478,8 @@ impl GlobalState {
             return Ok(());
         }
 
-        if self.status == Status::Loading && req.method != "shutdown" {
+        // Avoid flashing a bunch of unresolved references during initial load.
+        if self.workspaces.is_empty() && !self.is_quiescent() {
             self.respond(lsp_server::Response::new_err(
                 req.id,
                 // FIXME: i32 should impl From<ErrorCode> (from() guarantees lossless conversion)

crates/rust-analyzer/src/op_queue.rs

@@ -2,27 +2,27 @@
 //! at a time.
 
 pub(crate) struct OpQueue<Args, Output> {
-    op_scheduled: Option<Args>,
+    op_requested: Option<Args>,
     op_in_progress: bool,
     last_op_result: Output,
 }
 
 impl<Args, Output: Default> Default for OpQueue<Args, Output> {
     fn default() -> Self {
-        Self { op_scheduled: None, op_in_progress: false, last_op_result: Default::default() }
+        Self { op_requested: None, op_in_progress: false, last_op_result: Default::default() }
     }
 }
 
 impl<Args, Output> OpQueue<Args, Output> {
     pub(crate) fn request_op(&mut self, data: Args) {
-        self.op_scheduled = Some(data);
+        self.op_requested = Some(data);
     }
     pub(crate) fn should_start_op(&mut self) -> Option<Args> {
         if self.op_in_progress {
             return None;
         }
-        self.op_in_progress = self.op_scheduled.is_some();
-        self.op_scheduled.take()
+        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);
@@ -34,4 +34,10 @@ impl<Args, Output> OpQueue<Args, Output> {
     pub(crate) fn last_op_result(&self) -> &Output {
         &self.last_op_result
     }
+    pub(crate) fn op_in_progress(&self) -> bool {
+        self.op_in_progress
+    }
+    pub(crate) fn op_requested(&self) -> bool {
+        self.op_requested.is_some()
+    }
 }