feat(language_server): support textDocument/diagnostic

Author: Sysix

crates/oxc_language_server/src/capabilities.rs

@@ -1,19 +1,36 @@
 use tower_lsp_server::lsp_types::{
     ClientCapabilities, CodeActionKind, CodeActionOptions, CodeActionProviderCapability,
-    ExecuteCommandOptions, OneOf, SaveOptions, ServerCapabilities, TextDocumentSyncCapability,
-    TextDocumentSyncKind, TextDocumentSyncOptions, TextDocumentSyncSaveOptions,
-    WorkDoneProgressOptions, WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities,
+    DiagnosticOptions, DiagnosticServerCapabilities, ExecuteCommandOptions, OneOf, SaveOptions,
+    ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
+    TextDocumentSyncSaveOptions, WorkDoneProgressOptions, WorkspaceFoldersServerCapabilities,
+    WorkspaceServerCapabilities,
 };
 
 use crate::{code_actions::CODE_ACTION_KIND_SOURCE_FIX_ALL_OXC, commands::FIX_ALL_COMMAND_ID};
 
+/// Represents the capabilities of the client that the server can use to determine
+/// which features to enable or disable.
 #[derive(Clone, Default)]
 pub struct Capabilities {
     pub code_action_provider: bool,
     pub workspace_apply_edit: bool,
     pub workspace_execute_command: bool,
     pub workspace_configuration: bool,
+    /// Whether the client supports dynamic registration of file watchers.
     pub dynamic_watchers: bool,
+    /// Whether the client supports pull diagnostics.
+    pub pull_diagnostics: bool,
+    /// Whether the client supports the `workspace/diagnostic/refresh` request.
+    pub refresh_diagnostics: bool,
+}
+
+impl Capabilities {
+    /// The server supports pull and push diagnostics.
+    /// Only use push diagnostics if the client does not support pull diagnostics,
+    /// or we can not the client to refresh diagnostics.
+    pub fn use_push_diagnostics(&self) -> bool {
+        !self.pull_diagnostics || !self.refresh_diagnostics
+    }
 }
 
 impl From<ClientCapabilities> for Capabilities {
@@ -34,18 +51,32 @@ impl From<ClientCapabilities> for Capabilities {
             .workspace
             .as_ref()
             .is_some_and(|workspace| workspace.configuration.is_some_and(|config| config));
-        let dynamic_watchers = value.workspace.is_some_and(|workspace| {
-            workspace.did_change_watched_files.is_some_and(|watched_files| {
+        let dynamic_watchers = value.workspace.as_ref().is_some_and(|workspace| {
+            workspace.did_change_watched_files.as_ref().is_some_and(|watched_files| {
                 watched_files.dynamic_registration.is_some_and(|dynamic| dynamic)
             })
         });
 
+        let pull_diagnostics = value
+            .text_document
+            .as_ref()
+            .is_some_and(|text_document| text_document.diagnostic.is_some());
+
+        let refresh_diagnostics = value.workspace.as_ref().is_some_and(|workspace| {
+            workspace
+                .diagnostic
+                .as_ref()
+                .is_some_and(|diagnostic| diagnostic.refresh_support.is_some_and(|refresh| refresh))
+        });
+
         Self {
             code_action_provider,
             workspace_apply_edit,
             workspace_execute_command,
             workspace_configuration,
             dynamic_watchers,
+            pull_diagnostics,
+            refresh_diagnostics,
         }
     }
 }
@@ -92,6 +123,11 @@ impl From<Capabilities> for ServerCapabilities {
             } else {
                 None
             },
+            diagnostic_provider: if value.pull_diagnostics {
+                Some(DiagnosticServerCapabilities::Options(DiagnosticOptions::default()))
+            } else {
+                None
+            },
             ..ServerCapabilities::default()
         }
     }

crates/oxc_language_server/src/main.rs

@@ -13,8 +13,10 @@ use tower_lsp_server::{
         DidChangeConfigurationParams, DidChangeTextDocumentParams, DidChangeWatchedFilesParams,
         DidChangeWatchedFilesRegistrationOptions, DidChangeWorkspaceFoldersParams,
         DidCloseTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams,
-        ExecuteCommandParams, InitializeParams, InitializeResult, InitializedParams, Registration,
-        ServerInfo, Unregistration, Uri, WorkspaceEdit,
+        DocumentDiagnosticParams, DocumentDiagnosticReport, DocumentDiagnosticReportResult,
+        ExecuteCommandParams, FullDocumentDiagnosticReport, InitializeParams, InitializeResult,
+        InitializedParams, Registration, RelatedFullDocumentDiagnosticReport, ServerInfo,
+        Unregistration, Uri, WorkspaceEdit,
     },
 };
 // #
@@ -464,14 +466,22 @@ impl LanguageServer for Backend {
         if !worker.should_lint_on_run_type(Run::OnSave).await {
             return;
         }
-        if let Some(diagnostics) = worker.lint_file(uri, None).await {
-            self.client
-                .publish_diagnostics(
-                    uri.clone(),
-                    diagnostics.clone().into_iter().map(|d| d.diagnostic).collect(),
-                    None,
-                )
-                .await;
+
+        // we no longer need the cached document, as it is saved to disk
+        worker.remove_cached_document(uri);
+
+        // if the client supports pull diagnostics, we should not lint the file immediately,
+        // instead wait for the client to request diagnostics
+        if self.capabilities.get().is_some_and(Capabilities::use_push_diagnostics) {
+            if let Some(diagnostics) = worker.lint_file(uri).await {
+                self.client
+                    .publish_diagnostics(
+                        uri.clone(),
+                        diagnostics.clone().into_iter().map(|d| d.diagnostic).collect(),
+                        None,
+                    )
+                    .await;
+            }
         }
     }
 
@@ -487,14 +497,24 @@ impl LanguageServer for Backend {
             return;
         }
         let content = params.content_changes.first().map(|c| c.text.clone());
-        if let Some(diagnostics) = worker.lint_file(uri, content).await {
-            self.client
-                .publish_diagnostics(
-                    uri.clone(),
-                    diagnostics.clone().into_iter().map(|d| d.diagnostic).collect(),
-                    Some(params.text_document.version),
-                )
-                .await;
+
+        if let Some(content) = content {
+            // cache the document content for later use
+            worker.cache_document(uri, content);
+        }
+
+        // if the client supports pull diagnostics, we should not lint the file immediately,
+        // instead wait for the client to request diagnostics
+        if self.capabilities.get().is_some_and(Capabilities::use_push_diagnostics) {
+            if let Some(diagnostics) = worker.lint_file(uri).await {
+                self.client
+                    .publish_diagnostics(
+                        uri.clone(),
+                        diagnostics.clone().into_iter().map(|d| d.diagnostic).collect(),
+                        Some(params.text_document.version),
+                    )
+                    .await;
+            }
         }
     }
 
@@ -505,15 +525,21 @@ impl LanguageServer for Backend {
             return;
         };
 
-        let content = params.text_document.text;
-        if let Some(diagnostics) = worker.lint_file(uri, Some(content)).await {
-            self.client
-                .publish_diagnostics(
-                    uri.clone(),
-                    diagnostics.clone().into_iter().map(|d| d.diagnostic).collect(),
-                    Some(params.text_document.version),
-                )
-                .await;
+        // cache the document content for later use
+        worker.cache_document(uri, params.text_document.text);
+
+        // if the client supports pull diagnostics, we should not lint the file immediately,
+        // instead wait for the client to request diagnostics
+        if self.capabilities.get().is_some_and(Capabilities::use_push_diagnostics) {
+            if let Some(diagnostics) = worker.lint_file(uri).await {
+                self.client
+                    .publish_diagnostics(
+                        uri.clone(),
+                        diagnostics.clone().into_iter().map(|d| d.diagnostic).collect(),
+                        Some(params.text_document.version),
+                    )
+                    .await;
+            }
         }
     }
 
@@ -523,7 +549,38 @@ impl LanguageServer for Backend {
         let Some(worker) = workers.iter().find(|worker| worker.is_responsible_for_uri(uri)) else {
             return;
         };
-        worker.remove_diagnostics(&params.text_document.uri);
+        worker.remove_cached_document(uri);
+        worker.remove_diagnostics(uri);
+    }
+
+    async fn diagnostic(
+        &self,
+        params: DocumentDiagnosticParams,
+    ) -> Result<DocumentDiagnosticReportResult> {
+        let uri = &params.text_document.uri;
+        let workers = self.workspace_workers.read().await;
+        let Some(worker) = workers.iter().find(|worker| worker.is_responsible_for_uri(uri)) else {
+            return Ok(DocumentDiagnosticReportResult::Report(DocumentDiagnosticReport::Full(
+                RelatedFullDocumentDiagnosticReport::default(),
+            )));
+        };
+        let diagnostics = worker.lint_file(uri).await;
+
+        if let Some(diagnostics) = diagnostics {
+            Ok(DocumentDiagnosticReportResult::Report(DocumentDiagnosticReport::Full(
+                RelatedFullDocumentDiagnosticReport {
+                    full_document_diagnostic_report: FullDocumentDiagnosticReport {
+                        items: diagnostics.into_iter().map(|d| d.diagnostic).collect(),
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+            )))
+        } else {
+            Ok(DocumentDiagnosticReportResult::Report(DocumentDiagnosticReport::Full(
+                RelatedFullDocumentDiagnosticReport::default(),
+            )))
+        }
     }
 
     async fn code_action(&self, params: CodeActionParams) -> Result<Option<CodeActionResponse>> {

crates/oxc_language_server/src/tester.rs

@@ -115,7 +115,7 @@ impl Tester<'_> {
         let reports = tokio::runtime::Runtime::new().unwrap().block_on(async {
             self.create_workspace_worker()
                 .await
-                .lint_file(&uri, None)
+                .lint_file(&uri)
                 .await
                 .expect("lint file is ignored")
         });

crates/oxc_language_server/src/worker.rs

@@ -27,6 +27,7 @@ pub struct WorkspaceWorker {
     root_uri: Uri,
     server_linter: RwLock<Option<ServerLinter>>,
     diagnostics_report_map: Arc<ConcurrentHashMap<String, Vec<DiagnosticReport>>>,
+    document_cache: Arc<ConcurrentHashMap<String, String>>,
     options: Mutex<Options>,
 }
 
@@ -36,6 +37,7 @@ impl WorkspaceWorker {
             root_uri,
             server_linter: RwLock::new(None),
             diagnostics_report_map: Arc::new(ConcurrentHashMap::default()),
+            document_cache: Arc::new(ConcurrentHashMap::default()),
             options: Mutex::new(Options::default()),
         }
     }
@@ -56,6 +58,14 @@ impl WorkspaceWorker {
         *self.server_linter.write().await = Some(ServerLinter::new(&self.root_uri, options));
     }
 
+    pub fn cache_document(&self, uri: &Uri, content: String) {
+        self.document_cache.pin().insert(uri.to_string(), content);
+    }
+
+    pub fn remove_cached_document(&self, uri: &Uri) {
+        self.document_cache.pin().remove(&uri.to_string());
+    }
+
     // WARNING: start all programs (linter, formatter) before calling this function
     // each program can tell us customized file watcher patterns
     pub async fn init_watchers(&self) -> Vec<FileSystemWatcher> {
@@ -135,12 +145,8 @@ impl WorkspaceWorker {
         run_level == current_run
     }
 
-    pub async fn lint_file(
-        &self,
-        uri: &Uri,
-        content: Option<String>,
-    ) -> Option<Vec<DiagnosticReport>> {
-        let diagnostics = self.lint_file_internal(uri, content).await;
+    pub async fn lint_file(&self, uri: &Uri) -> Option<Vec<DiagnosticReport>> {
+        let diagnostics = self.lint_file_internal(uri).await;
 
         if let Some(diagnostics) = &diagnostics {
             self.update_diagnostics(uri, diagnostics);
@@ -149,16 +155,15 @@ impl WorkspaceWorker {
         diagnostics
     }
 
-    async fn lint_file_internal(
-        &self,
-        uri: &Uri,
-        content: Option<String>,
-    ) -> Option<Vec<DiagnosticReport>> {
+    async fn lint_file_internal(&self, uri: &Uri) -> Option<Vec<DiagnosticReport>> {
         let Some(server_linter) = &*self.server_linter.read().await else {
             return None;
         };
 
-        server_linter.run_single(uri, content)
+        let cache = self.document_cache.pin();
+        let content = cache.get(&uri.to_string());
+
+        server_linter.run_single(uri, content.cloned())
     }
 
     fn update_diagnostics(&self, uri: &Uri, diagnostics: &[DiagnosticReport]) {
@@ -208,7 +213,7 @@ impl WorkspaceWorker {
             Some(value) => value,
             // code actions / commands can be requested without opening the file
             // we just internally lint and provide the code actions / commands without refreshing the diagnostic map.
-            None => &self.lint_file_internal(uri, None).await.unwrap_or_default(),
+            None => &self.lint_file_internal(uri).await.unwrap_or_default(),
         };
 
         if value.is_empty() {
@@ -250,7 +255,7 @@ impl WorkspaceWorker {
             Some(value) => value,
             // code actions / commands can be requested without opening the file
             // we just internally lint and provide the code actions / commands without refreshing the diagnostic map.
-            None => &self.lint_file_internal(uri, None).await.unwrap_or_default(),
+            None => &self.lint_file_internal(uri).await.unwrap_or_default(),
         };
 
         if value.is_empty() {

editors/vscode/client/ConfigService.ts

@@ -1,4 +1,5 @@
 import { ConfigurationChangeEvent, Uri, workspace, WorkspaceFolder } from 'vscode';
+import { DiagnosticPullMode } from 'vscode-languageclient';
 import { IDisposable } from './types';
 import { VSCodeConfig } from './VSCodeConfig';
 import { WorkspaceConfig, WorkspaceConfigInterface } from './WorkspaceConfig';
@@ -79,6 +80,24 @@ export class ConfigService implements IDisposable {
     }
   }
 
+  public shouldRequestDiagnostics(
+    textDocumentUri: Uri,
+    diagnosticPullMode: DiagnosticPullMode,
+  ): boolean {
+    if (!this.vsCodeConfig.enable) {
+      return false;
+    }
+
+    const textDocumentPath = textDocumentUri.path;
+
+    for (const [workspaceUri, workspaceConfig] of this.workspaceConfigs.entries()) {
+      if (textDocumentPath.startsWith(workspaceUri)) {
+        return workspaceConfig.shouldRequestDiagnostics(diagnosticPullMode);
+      }
+    }
+    return false;
+  }
+
   dispose() {
     for (const disposable of this._disposables) {
       disposable.dispose();