feat(language_server): support workpace/diagnostic

Author: Sysix

crates/oxc_language_server/fixtures/linter/multi_file_analysis/.oxlintrc.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "no-console": "error"
+  }
+}

crates/oxc_language_server/fixtures/linter/multi_file_analysis/console.js

@@ -0,0 +1 @@
+console.log("Hello, world!");

crates/oxc_language_server/fixtures/linter/multi_file_analysis/debugger.ts

@@ -0,0 +1,2 @@
+// Debugger should be shown as a warning
+debugger;

crates/oxc_language_server/src/capabilities.rs

@@ -1,8 +1,9 @@
 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};
@@ -99,6 +100,10 @@ impl From<Capabilities> for ServerCapabilities {
             } else {
                 None
             },
+            diagnostic_provider: Some(DiagnosticServerCapabilities::Options(DiagnosticOptions {
+                workspace_diagnostics: true,
+                ..Default::default()
+            })),
             ..ServerCapabilities::default()
         }
     }

crates/oxc_language_server/src/linter/isolated_lint_handler.rs

@@ -1,22 +1,25 @@
 use std::{
+    ffi::OsString,
     path::{Path, PathBuf},
     sync::{Arc, OnceLock},
 };
 
 use log::debug;
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 use tower_lsp_server::{
     UriExt,
     lsp_types::{self, DiagnosticRelatedInformation, DiagnosticSeverity, Uri},
 };
 
 use oxc_allocator::Allocator;
-use oxc_linter::RuntimeFileSystem;
+use oxc_linter::{FileWalker, FileWalkerOptions, RuntimeFileSystem};
 use oxc_linter::{
     LINTABLE_EXTENSIONS, LintService, LintServiceOptions, Linter, MessageWithPosition,
     loader::Loader, read_to_string,
 };
 
+use crate::uri_ext::path_to_uri;
+
 use super::error_with_position::{
     DiagnosticReport, PossibleFixContent, message_with_position_to_lsp_diagnostic_report,
 };
@@ -73,49 +76,71 @@ impl IsolatedLintHandler {
         let allocator = Allocator::default();
 
         Some(self.lint_path(&allocator, &path, content).map_or(vec![], |errors| {
-            let mut diagnostics: Vec<DiagnosticReport> = errors
-                .iter()
-                .map(|e| message_with_position_to_lsp_diagnostic_report(e, uri))
-                .collect();
-
-            // a diagnostics connected from related_info to original diagnostic
-            let mut inverted_diagnostics = vec![];
-            for d in &diagnostics {
-                let Some(related_info) = &d.diagnostic.related_information else {
+            Self::messages_with_position_to_diagnostics_report(&errors, uri)
+        }))
+    }
+
+    pub fn run_all(&self) -> Vec<(Uri, Vec<DiagnosticReport>)> {
+        let allocator = Allocator::default();
+        let mut diagnostics = Vec::new();
+
+        for (path, messages) in self.lint_all_files(&allocator) {
+            let uri = path_to_uri(&path);
+            diagnostics.push((
+                uri.clone(),
+                Self::messages_with_position_to_diagnostics_report(&messages, &uri),
+            ));
+        }
+
+        diagnostics
+    }
+
+    fn messages_with_position_to_diagnostics_report(
+        messages: &[MessageWithPosition<'_>],
+        uri: &Uri,
+    ) -> Vec<DiagnosticReport> {
+        let mut diagnostics: Vec<DiagnosticReport> = messages
+            .iter()
+            .map(|e| message_with_position_to_lsp_diagnostic_report(e, uri))
+            .collect();
+
+        // a diagnostics connected from related_info to original diagnostic
+        let mut inverted_diagnostics = vec![];
+        for d in &diagnostics {
+            let Some(related_info) = &d.diagnostic.related_information else {
+                continue;
+            };
+            let related_information = Some(vec![DiagnosticRelatedInformation {
+                location: lsp_types::Location { uri: uri.clone(), range: d.diagnostic.range },
+                message: "original diagnostic".to_string(),
+            }]);
+            for r in related_info {
+                if r.location.range == d.diagnostic.range {
                     continue;
-                };
-                let related_information = Some(vec![DiagnosticRelatedInformation {
-                    location: lsp_types::Location { uri: uri.clone(), range: d.diagnostic.range },
-                    message: "original diagnostic".to_string(),
-                }]);
-                for r in related_info {
-                    if r.location.range == d.diagnostic.range {
-                        continue;
-                    }
-                    // If there is no message content for this span, then don't produce an additional diagnostic
-                    // which also has no content. This prevents issues where editors expect diagnostics to have messages.
-                    if r.message.is_empty() {
-                        continue;
-                    }
-                    inverted_diagnostics.push(DiagnosticReport {
-                        diagnostic: lsp_types::Diagnostic {
-                            range: r.location.range,
-                            severity: Some(DiagnosticSeverity::HINT),
-                            code: None,
-                            message: r.message.clone(),
-                            source: d.diagnostic.source.clone(),
-                            code_description: None,
-                            related_information: related_information.clone(),
-                            tags: None,
-                            data: None,
-                        },
-                        fixed_content: PossibleFixContent::None,
-                    });
                 }
+                // If there is no message content for this span, then don't produce an additional diagnostic
+                // which also has no content. This prevents issues where editors expect diagnostics to have messages.
+                if r.message.is_empty() {
+                    continue;
+                }
+                inverted_diagnostics.push(DiagnosticReport {
+                    diagnostic: lsp_types::Diagnostic {
+                        range: r.location.range,
+                        severity: Some(DiagnosticSeverity::HINT),
+                        code: None,
+                        message: r.message.clone(),
+                        source: d.diagnostic.source.clone(),
+                        code_description: None,
+                        related_information: related_information.clone(),
+                        tags: None,
+                        data: None,
+                    },
+                    fixed_content: PossibleFixContent::None,
+                });
             }
-            diagnostics.append(&mut inverted_diagnostics);
-            diagnostics
-        }))
+        }
+        diagnostics.append(&mut inverted_diagnostics);
+        diagnostics
     }
 
     fn lint_path<'a>(
@@ -146,6 +171,25 @@ impl IsolatedLintHandler {
         result.remove(path)
     }
 
+    fn lint_all_files<'a>(
+        &self,
+        allocator: &'a Allocator,
+    ) -> FxHashMap<PathBuf, Vec<MessageWithPosition<'a>>> {
+        let walker = FileWalker::new(
+            &[self.options.root_path.clone()],
+            &FileWalkerOptions { no_ignore: false, symlinks: false, ignore_path: OsString::new() },
+            None,
+        );
+
+        let lint_service_options =
+            LintServiceOptions::new(self.options.root_path.clone(), walker.paths())
+                .with_cross_module(self.options.use_cross_module);
+
+        let mut lint_service = LintService::new(&self.linter, lint_service_options);
+
+        lint_service.run_source(allocator)
+    }
+
     fn should_lint_path(path: &Path) -> bool {
         static WANTED_EXTENSIONS: OnceLock<FxHashSet<&'static str>> = OnceLock::new();
         let wanted_exts =

crates/oxc_language_server/src/linter/server_linter.rs

@@ -204,6 +204,10 @@ impl ServerLinter {
 
         self.isolated_linter.run_single(uri, content)
     }
+
+    pub fn run_all(&self) -> Vec<(Uri, Vec<DiagnosticReport>)> {
+        self.isolated_linter.run_all()
+    }
 }
 
 /// Normalize a path by removing `.` and resolving `..` components,
@@ -365,4 +369,9 @@ mod test {
         )
         .test_and_snapshot_single_file("forward_ref.ts");
     }
+
+    #[test]
+    fn test_multi_file_analyse() {
+        Tester::new("fixtures/linter/multi_file_analysis", None).test_and_snapshot();
+    }
 }

crates/oxc_language_server/src/main.rs

@@ -16,7 +16,9 @@ use tower_lsp_server::{
         DocumentDiagnosticParams, DocumentDiagnosticReport, DocumentDiagnosticReportResult,
         ExecuteCommandParams, FullDocumentDiagnosticReport, InitializeParams, InitializeResult,
         InitializedParams, Registration, RelatedFullDocumentDiagnosticReport, ServerInfo,
-        Unregistration, Uri, WorkspaceEdit,
+        Unregistration, Uri, WorkspaceDiagnosticParams, WorkspaceDiagnosticReport,
+        WorkspaceDiagnosticReportResult, WorkspaceDocumentDiagnosticReport, WorkspaceEdit,
+        WorkspaceFullDocumentDiagnosticReport,
     },
 };
 // #
@@ -32,7 +34,6 @@ mod linter;
 mod options;
 #[cfg(test)]
 mod tester;
-#[cfg(test)]
 mod uri_ext;
 mod worker;
 
@@ -630,6 +631,30 @@ impl LanguageServer for Backend {
 
         Err(Error::invalid_request())
     }
+
+    async fn workspace_diagnostic(
+        &self,
+        _params: WorkspaceDiagnosticParams,
+    ) -> Result<WorkspaceDiagnosticReportResult> {
+        let workers = self.workspace_workers.read().await;
+        let mut items = Vec::new();
+        for worker in workers.iter() {
+            for (uri, reports) in worker.lint_workspace().await {
+                items.push(WorkspaceDocumentDiagnosticReport::Full(
+                    WorkspaceFullDocumentDiagnosticReport {
+                        uri: uri.clone(),
+                        version: None,
+                        full_document_diagnostic_report: FullDocumentDiagnosticReport {
+                            result_id: None,
+                            items: reports.into_iter().map(|d| d.diagnostic).collect(),
+                        },
+                    },
+                ));
+            }
+        }
+
+        Ok(WorkspaceDiagnosticReportResult::Report(WorkspaceDiagnosticReport { items }))
+    }
 }
 
 impl Backend {

crates/oxc_language_server/src/snapshots/fixtures_linter_multi_file_analysis@all.snap

@@ -0,0 +1,30 @@
+---
+source: crates/oxc_language_server/src/tester.rs
+---
+/home/sysix/dev/oxc/crates/oxc_language_server/fixtures/linter/multi_file_analysis/debugger.ts:
+
+code: "eslint(no-debugger)"
+code_description.href: "https://oxc.rs/docs/guide/usage/linter/rules/eslint/no-debugger.html"
+message: "`debugger` statement is not allowed\nhelp: Remove the debugger statement"
+range: Range { start: Position { line: 1, character: 0 }, end: Position { line: 1, character: 9 } }
+related_information[0].message: ""
+related_information[0].location.uri: "file://<variable>/fixtures/linter/multi_file_analysis/debugger.ts"
+related_information[0].location.range: Range { start: Position { line: 1, character: 0 }, end: Position { line: 1, character: 9 } }
+severity: Some(Warning)
+source: Some("oxc")
+tags: None
+fixed: Single(FixedContent { message: Some("Remove the debugger statement"), code: "", range: Range { start: Position { line: 1, character: 0 }, end: Position { line: 1, character: 9 } } })
+
+/home/sysix/dev/oxc/crates/oxc_language_server/fixtures/linter/multi_file_analysis/console.js:
+
+code: "eslint(no-console)"
+code_description.href: "https://oxc.rs/docs/guide/usage/linter/rules/eslint/no-console.html"
+message: "Unexpected console statement.\nhelp: Delete this console statement."
+range: Range { start: Position { line: 0, character: 0 }, end: Position { line: 0, character: 11 } }
+related_information[0].message: ""
+related_information[0].location.uri: "file://<variable>/fixtures/linter/multi_file_analysis/console.js"
+related_information[0].location.range: Range { start: Position { line: 0, character: 0 }, end: Position { line: 0, character: 11 } }
+severity: Some(Error)
+source: Some("oxc")
+tags: None
+fixed: None

crates/oxc_language_server/src/tester.rs

@@ -1,5 +1,6 @@
 use std::fmt::Write;
 
+use cow_utils::CowUtils;
 use tower_lsp_server::{
     UriExt,
     lsp_types::{CodeDescription, NumberOrString, Uri},
@@ -109,7 +110,6 @@ impl Tester<'_> {
 
     /// Given a relative file path (relative to `oxc_language_server` crate root), run the linter
     /// and return the resulting diagnostics in a custom snapshot format.
-    #[expect(clippy::disallowed_methods)]
     pub fn test_and_snapshot_single_file(&self, relative_file_path: &str) {
         let uri = get_file_uri(&format!("{}/{}", self.relative_root_dir, relative_file_path));
         let reports = tokio::runtime::Runtime::new().unwrap().block_on(async {
@@ -125,16 +125,49 @@ impl Tester<'_> {
             reports.iter().map(get_snapshot_from_report).collect::<Vec<_>>().join("\n")
         };
 
-        let snapshot_name = self.relative_root_dir.replace('/', "_");
+        let snapshot_name = self.relative_root_dir.cow_replace('/', "_");
         let mut settings = insta::Settings::clone_current();
         settings.set_prepend_module_to_snapshot(false);
         settings.set_omit_expression(true);
         if let Some(path) = uri.to_file_path() {
             settings.set_input_file(path.as_ref());
         }
-        settings.set_snapshot_suffix(relative_file_path.replace('/', "_"));
+        settings.set_snapshot_suffix(relative_file_path.cow_replace('/', "_"));
         settings.bind(|| {
-            insta::assert_snapshot!(snapshot_name, snapshot);
+            insta::assert_snapshot!(snapshot_name.to_string(), snapshot);
+        });
+    }
+
+    pub fn test_and_snapshot(&self) {
+        let reports = tokio::runtime::Runtime::new()
+            .unwrap()
+            .block_on(async { self.create_workspace_worker().await.lint_workspace().await });
+        let snapshot = if reports.is_empty() {
+            "No diagnostic reports".to_string()
+        } else {
+            reports
+                .iter()
+                .map(|(uri, messages)| {
+                    format!(
+                        "{}:\n{}",
+                        uri.to_file_path().unwrap_or_default().display(),
+                        messages
+                            .iter()
+                            .map(get_snapshot_from_report)
+                            .collect::<Vec<_>>()
+                            .join("\n")
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join("\n")
+        };
+        let snapshot_name = self.relative_root_dir.cow_replace('/', "_");
+        let mut settings = insta::Settings::clone_current();
+        settings.set_prepend_module_to_snapshot(false);
+        settings.set_omit_expression(true);
+        settings.set_snapshot_suffix("all");
+        settings.bind(|| {
+            insta::assert_snapshot!(snapshot_name.to_string(), snapshot);
         });
     }
 }

crates/oxc_language_server/src/worker.rs

@@ -155,6 +155,16 @@ impl WorkspaceWorker {
         diagnostics
     }
 
+    pub async fn lint_workspace(&self) -> Vec<(Uri, Vec<DiagnosticReport>)> {
+        let server_linter = self.server_linter.read().await;
+        let Some(server_linter) = &*server_linter else {
+            debug!("no server_linter initialized in the worker");
+            return vec![];
+        };
+
+        server_linter.run_all()
+    }
+
     async fn lint_file_internal(&self, uri: &Uri) -> Option<Vec<DiagnosticReport>> {
         let Some(server_linter) = &*self.server_linter.read().await else {
             return None;