support workspace/diagnostic

Author: CppCXY

crates/emmylua_ls/src/context/client.rs

@@ -156,4 +156,8 @@ impl ClientProxy {
         let request_id = self.next_id();
         self.send_request_no_wait(request_id, method, params);
     }
+
+    pub fn refresh_workspace_diagnostics(&self) {
+        self.send_request_no_response("workspace/diagnostic/refresh", ());
+    }
 }

crates/emmylua_ls/src/context/file_diagnostic.rs

@@ -86,7 +86,7 @@ impl FileDiagnostic {
     }
 
     /// 清除指定文件的诊断信息
-    pub fn clear_file_diagnostics(&self, uri: lsp_types::Uri) {
+    pub fn clear_push_file_diagnostics(&self, uri: lsp_types::Uri) {
         let diagnostic_param = lsp_types::PublishDiagnosticsParams {
             uri,
             diagnostics: vec![],
@@ -112,7 +112,7 @@ impl FileDiagnostic {
         tokio::spawn(async move {
             tokio::select! {
                 _ = tokio::time::sleep(Duration::from_millis(interval)) => {
-                    workspace_diagnostic(analysis, client_proxy, status_bar, silent, cancel_token).await
+                    push_workspace_diagnostic(analysis, client_proxy, status_bar, silent, cancel_token).await
                 }
                 _ = cancel_token.cancelled() => {
                     log::info!("cancel workspace diagnostic");
@@ -130,6 +130,15 @@ impl FileDiagnostic {
         tokens.clear();
     }
 
+    pub async fn cancel_workspace_diagnostic(&self) {
+        let mut token = self.workspace_diagnostic_token.lock().await;
+        if let Some(token) = token.as_ref() {
+            token.cancel();
+            debug!("cancel workspace diagnostic");
+        }
+        token.take();
+    }
+
     pub async fn pull_file_diagnostics(
         &self,
         uri: Uri,
@@ -140,14 +149,137 @@ impl FileDiagnostic {
             return vec![];
         };
 
-        self.clear_file_diagnostics(uri);
-
         let diagnostics = analysis.diagnose_file(file_id, cancel_token);
         diagnostics.unwrap_or_default()
     }
+
+    pub async fn pull_workspace_diagnostics_slow(
+        &self,
+        cancel_token: CancellationToken,
+    ) -> Vec<(Uri, Vec<Diagnostic>)> {
+        let mut token = self.workspace_diagnostic_token.lock().await;
+        if let Some(token) = token.as_ref() {
+            token.cancel();
+            debug!("cancel workspace diagnostic");
+        }
+        token.replace(cancel_token.clone());
+        drop(token);
+
+        let mut result = Vec::new();
+        let analysis = self.analysis.read().await;
+        let main_workspace_file_ids = analysis
+            .compilation
+            .get_db()
+            .get_module_index()
+            .get_main_workspace_file_ids();
+        drop(analysis);
+
+        for file_id in main_workspace_file_ids {
+            if cancel_token.is_cancelled() {
+                break;
+            }
+            let analysis = self.analysis.read().await;
+            if let Some(uri) = analysis.get_uri(file_id) {
+                let diagnostics = analysis.diagnose_file(file_id, cancel_token.clone());
+                if let Some(diagnostics) = diagnostics {
+                    result.push((uri, diagnostics));
+                }
+            }
+        }
+
+        result
+    }
+
+    pub async fn pull_workspace_diagnostics_fast(
+        &self,
+        cancel_token: CancellationToken,
+    ) -> Vec<(Uri, Vec<Diagnostic>)> {
+        let mut token = self.workspace_diagnostic_token.lock().await;
+        if let Some(token) = token.as_ref() {
+            token.cancel();
+            debug!("cancel workspace diagnostic");
+        }
+        token.replace(cancel_token.clone());
+        drop(token);
+
+        let mut result = Vec::new();
+        let analysis = self.analysis.read().await;
+        let main_workspace_file_ids = analysis
+            .compilation
+            .get_db()
+            .get_module_index()
+            .get_main_workspace_file_ids();
+        drop(analysis);
+
+        let status_bar = self.status_bar.clone();
+        status_bar
+            .create_progress_task(ProgressTask::DiagnoseWorkspace)
+            .await;
+
+        let (tx, mut rx) = tokio::sync::mpsc::channel::<Option<(Vec<Diagnostic>, Uri)>>(100);
+        let valid_file_count = main_workspace_file_ids.len();
+        if valid_file_count == 0 {
+            return result;
+        }
+
+        let analysis = self.analysis.clone();
+        for file_id in main_workspace_file_ids {
+            let analysis = analysis.clone();
+            let token = cancel_token.clone();
+            let tx = tx.clone();
+            tokio::spawn(async move {
+                let analysis = analysis.read().await;
+                let diagnostics = analysis.diagnose_file(file_id, token);
+                if let Some(diagnostics) = diagnostics {
+                    let uri = analysis.get_uri(file_id).unwrap();
+                    let _ = tx.send(Some((diagnostics, uri))).await;
+                } else {
+                    let _ = tx.send(None).await;
+                }
+            });
+        }
+
+        let mut count = 0;
+        if valid_file_count != 0 {
+            let text = format!("diagnose {} files", valid_file_count);
+            let _p = Profile::new(text.as_str());
+            let mut last_percentage = 0;
+            while let Some(file_diagnostic_result) = rx.recv().await {
+                if cancel_token.is_cancelled() {
+                    break;
+                }
+
+                if let Some((diagnostics, uri)) = file_diagnostic_result {
+                    result.push((uri, diagnostics));
+                }
+
+                count += 1;
+                let percentage_done = ((count as f32 / valid_file_count as f32) * 100.0) as u32;
+                if last_percentage != percentage_done {
+                    last_percentage = percentage_done;
+                    let message = format!("diagnostic {}%", percentage_done);
+                    status_bar.update_progress_task(
+                        ProgressTask::DiagnoseWorkspace,
+                        Some(percentage_done),
+                        Some(message),
+                    );
+                }
+                if count == valid_file_count {
+                    break;
+                }
+            }
+        }
+
+        status_bar.finish_progress_task(
+            ProgressTask::DiagnoseWorkspace,
+            Some("Diagnosis complete".to_string()),
+        );
+
+        result
+    }
 }
 
-async fn workspace_diagnostic(
+async fn push_workspace_diagnostic(
     analysis: Arc<RwLock<EmmyLuaAnalysis>>,
     client_proxy: Arc<ClientProxy>,
     status_bar: Arc<StatusBar>,
@@ -217,13 +349,16 @@ async fn workspace_diagnostic(
                     );
                 }
                 if count == valid_file_count {
-                    status_bar.finish_progress_task(
-                        ProgressTask::DiagnoseWorkspace,
-                        Some("Diagnosis complete".to_string()),
-                    );
                     break;
                 }
             }
         }
     }
+
+    if !silent {
+        status_bar.finish_progress_task(
+            ProgressTask::DiagnoseWorkspace,
+            Some("Diagnosis complete".to_string()),
+        );
+    }
 }

crates/emmylua_ls/src/context/lsp_features.rs

@@ -33,10 +33,25 @@ impl LspFeatures {
         false
     }
 
-    pub fn supports_pull_diagnostics(&self) -> bool {
+    pub fn supports_pull_diagnostic(&self) -> bool {
         if let Some(text_document) = &self.client_capabilities.text_document {
             return text_document.diagnostic.is_some();
         }
         false
     }
+
+    pub fn supports_workspace_diagnostic(&self) -> bool {
+        self.supports_pull_diagnostic()
+    }
+
+    pub fn supports_refresh_diagnostic(&self) -> bool {
+        if let Some(workspace) = &self.client_capabilities.workspace {
+            if let Some(diagnostic) = &workspace.diagnostic {
+                if let Some(supports) = diagnostic.refresh_support {
+                    return supports;
+                }
+            }
+        }
+        false
+    }
 }

crates/emmylua_ls/src/context/mod.rs

@@ -10,6 +10,7 @@ pub use client::ClientProxy;
 pub use client_id::{ClientId, get_client_id};
 use emmylua_code_analysis::EmmyLuaAnalysis;
 pub use file_diagnostic::FileDiagnostic;
+pub use lsp_features::LspFeatures;
 use lsp_server::{Connection, ErrorCode, Message, RequestId, Response};
 use lsp_types::ClientCapabilities;
 pub use snapshot::ServerContextSnapshot;
@@ -18,11 +19,8 @@ pub use status_bar::StatusBar;
 use std::{collections::HashMap, future::Future, sync::Arc};
 use tokio::sync::{Mutex, RwLock};
 use tokio_util::sync::CancellationToken;
-pub use workspace_manager::WorkspaceFileMatcher;
-pub use workspace_manager::WorkspaceManager;
-pub use workspace_manager::load_emmy_config;
+pub use workspace_manager::*;
 
-use crate::context::lsp_features::LspFeatures;
 use crate::context::snapshot::ServerContextInner;
 
 pub struct ServerContext {
@@ -46,13 +44,14 @@ impl ServerContext {
             status_bar.clone(),
             client.clone(),
         ));
+        let lsp_features = Arc::new(LspFeatures::new(client_capabilities));
         let workspace_manager = Arc::new(RwLock::new(WorkspaceManager::new(
             analysis.clone(),
             client.clone(),
             status_bar.clone(),
             file_diagnostic.clone(),
+            lsp_features.clone(),
         )));
-        let lsp_features = Arc::new(LspFeatures::new(client_capabilities));
 
         ServerContext {
             conn,