feat(language_server): support textDocument/diagnostic

Sysix · Sysix · commit d0fbfb45ac9d · 2025-06-02T19:35:40.000+02:00
diff --git a/crates/oxc_language_server/src/capabilities.rs b/crates/oxc_language_server/src/capabilities.rs
@@ -14,6 +14,7 @@ pub struct Capabilities {
     pub workspace_execute_command: bool,
     pub workspace_configuration: bool,
     pub dynamic_watchers: bool,
+    pub pull_diagnostics: bool,
 }
 
 impl From<ClientCapabilities> for Capabilities {
@@ -40,12 +41,18 @@ impl From<ClientCapabilities> for Capabilities {
             })
         });
 
+        let pull_diagnostics = value
+            .text_document
+            .as_ref()
+            .is_some_and(|text_document| text_document.diagnostic.is_some());
+
         Self {
             code_action_provider,
             workspace_apply_edit,
             workspace_execute_command,
             workspace_configuration,
             dynamic_watchers,
+            pull_diagnostics,
         }
     }
 }
diff --git a/crates/oxc_language_server/src/main.rs b/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,
     },
 };
 // #
@@ -466,7 +468,11 @@ 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 {
+
+        // we no longer need the cached document, as it is saved to disk
+        worker.remove_cached_document(uri);
+
+        if let Some(diagnostics) = worker.lint_file(uri).await {
             self.client
                 .publish_diagnostics(
                     uri.clone(),
@@ -489,7 +495,13 @@ 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 {
+
+        if let Some(content) = content {
+            // cache the document content for later use
+            worker.cache_document(uri, content);
+        }
+
+        if let Some(diagnostics) = worker.lint_file(uri).await {
             self.client
                 .publish_diagnostics(
                     uri.clone(),
@@ -507,8 +519,10 @@ impl LanguageServer for Backend {
             return;
         };
 
-        let content = params.text_document.text;
-        if let Some(diagnostics) = worker.lint_file(uri, Some(content)).await {
+        // cache the document content for later use
+        worker.cache_document(uri, params.text_document.text);
+
+        if let Some(diagnostics) = worker.lint_file(uri).await {
             self.client
                 .publish_diagnostics(
                     uri.clone(),
@@ -525,7 +539,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>> {
diff --git a/crates/oxc_language_server/src/tester.rs b/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")
         });
diff --git a/crates/oxc_language_server/src/worker.rs b/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() {

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ pub struct Capabilities {`
`14`	`14`	`pub workspace_execute_command: bool,`
`15`	`15`	`pub workspace_configuration: bool,`
`16`	`16`	`pub dynamic_watchers: bool,`
	`17`	`+ pub pull_diagnostics: bool,`
`17`	`18`	`}`
`18`	`19`
`19`	`20`	`impl From<ClientCapabilities> for Capabilities {`
`@@ -40,12 +41,18 @@ impl From<ClientCapabilities> for Capabilities {`
`40`	`41`	`})`
`41`	`42`	`});`
`42`	`43`
	`44`	`+ let pull_diagnostics = value`
	`45`	`+ .text_document`
	`46`	`+ .as_ref()`
	`47`	`+ .is_some_and(\|text_document\| text_document.diagnostic.is_some());`
	`48`	`+`
`43`	`49`	`Self {`
`44`	`50`	`code_action_provider,`
`45`	`51`	`workspace_apply_edit,`
`46`	`52`	`workspace_execute_command,`
`47`	`53`	`workspace_configuration,`
`48`	`54`	`dynamic_watchers,`
	`55`	`+ pull_diagnostics,`
`49`	`56`	`}`
`50`	`57`	`}`
`51`	`58`	`}`