fix(oxlint/lsp): report diagnostics referencing another file

Sysix · Sysix · commit bf998de5f488 · 2025-12-12T15:07:45.000+01:00
diff --git a/crates/oxc_language_server/src/linter/isolated_lint_handler.rs b/crates/oxc_language_server/src/linter/isolated_lint_handler.rs
@@ -3,7 +3,7 @@ use std::{
     sync::{Arc, OnceLock},
 };
 
-use log::{debug, warn};
+use log::{debug, error, warn};
 use oxc_data_structures::rope::Rope;
 use rustc_hash::{FxHashMap, FxHashSet};
 use tower_lsp_server::ls_types::Uri;
@@ -111,34 +111,46 @@ impl IsolatedLintHandler {
         let source_text =
             if let Some(content) = content { content } else { &read_to_string(&path).ok()? };
 
-        let mut diagnostics = self.lint_path(&path, uri, source_text);
+        let mut diagnostics = self.lint_path(&path, source_text);
         diagnostics.append(&mut generate_inverted_diagnostics(&diagnostics, uri));
         Some(diagnostics)
     }
 
-    fn lint_path(&self, path: &Path, uri: &Uri, source_text: &str) -> Vec<DiagnosticReport> {
+    fn lint_path(&self, path: &Path, source_text: &str) -> Vec<DiagnosticReport> {
         debug!("lint {}", path.display());
         let rope = &Rope::from_str(source_text);
 
         let mut fs = IsolatedLintHandlerFileSystem::default();
         fs.add_file(path.to_path_buf(), Arc::from(source_text));
 
-        let mut messages: Vec<DiagnosticReport> = self
-            .runner
-            .run_source(&[Arc::from(path.as_os_str())], &fs)
-            .into_iter()
-            .map(|message| message_to_lsp_diagnostic(message, uri, source_text, rope))
-            .collect();
+        let results = self.runner.run_source(&[Arc::from(path.as_os_str())], &fs);
 
-        // Add unused directives if configured
-        if let Some(severity) = self.unused_directives_severity
-            && let Some(directives) = self.runner.directives_coordinator().get(path)
-        {
+        let mut messages: Vec<DiagnosticReport> = Vec::new();
+
+        for (msg_path_os, msgs) in results {
+            // Convert Arc<OsStr> to &Path for coordinator lookup
+            let msg_path = Path::new(msg_path_os.as_ref());
+            let Some(uri) = Uri::from_file_path(msg_path) else {
+                error!("Failed to convert path to URI: {}", msg_path.display());
+                continue;
+            };
+
+            // Map rule diagnostics to LSP diagnostics
             messages.extend(
-                create_unused_directives_messages(&directives, severity, source_text)
-                    .into_iter()
-                    .map(|message| message_to_lsp_diagnostic(message, uri, source_text, rope)),
+                msgs.into_iter()
+                    .map(|message| message_to_lsp_diagnostic(message, &uri, source_text, rope)),
             );
+
+            // Add unused directives for this file if configured
+            if let Some(severity) = self.unused_directives_severity
+                && let Some(directives) = self.runner.directives_coordinator().get(msg_path)
+            {
+                messages.extend(
+                    create_unused_directives_messages(&directives, severity, source_text)
+                        .into_iter()
+                        .map(|message| message_to_lsp_diagnostic(message, &uri, source_text, rope)),
+                );
+            }
         }
 
         messages
diff --git a/crates/oxc_language_server/src/linter/server_linter.rs b/crates/oxc_language_server/src/linter/server_linter.rs
@@ -555,11 +555,15 @@ impl ServerLinter {
     }
 
     fn get_code_actions_for_uri(&self, uri: &Uri) -> Option<Vec<LinterCodeAction>> {
-        if let Some(cached_code_actions) = self.code_actions.pin().get(uri) {
+        // for code actions we need to make a roundtrip to `from_file_path` and `to_file_path`.
+        // The editor URI schema might differ from our own produced URIs.
+        let uri = Uri::from_file_path(uri.to_file_path()?)?;
+
+        if let Some(cached_code_actions) = self.code_actions.pin().get(&uri) {
             cached_code_actions.clone()
         } else {
-            self.run_file(uri, None);
-            self.code_actions.pin().get(uri).and_then(std::clone::Clone::clone)
+            self.run_file(&uri, None);
+            self.code_actions.pin().get(&uri).and_then(std::clone::Clone::clone)
         }
     }
 
diff --git a/crates/oxc_linter/src/lint_runner.rs b/crates/oxc_linter/src/lint_runner.rs
@@ -237,7 +237,9 @@ impl LintRunner {
         &self,
         files: &[Arc<OsStr>],
         file_system: &(dyn crate::RuntimeFileSystem + Sync + Send),
-    ) -> Vec<Message> {
+    ) -> Vec<(Arc<OsStr>, Vec<crate::Message>)> {
+        debug_assert!(!files.is_empty());
+
         let mut messages = self.lint_service.run_source(file_system, files.to_owned());
 
         if let Some(type_aware_linter) = &self.type_aware_linter {
@@ -248,9 +250,15 @@ impl LintRunner {
             ) {
                 Ok(msgs) => msgs,
                 Err(err) => {
-                    vec![Message::new(
-                        OxcDiagnostic::warn(format!("Failed to run type-aware linting: `{err}`",)),
-                        PossibleFixes::None,
+                    vec![(
+                        // Report error for the first file only
+                        Arc::clone(&files[0]),
+                        vec![Message::new(
+                            OxcDiagnostic::warn(format!(
+                                "Failed to run type-aware linting: `{err}`",
+                            )),
+                            PossibleFixes::None,
+                        )],
                     )]
                 }
             };
diff --git a/crates/oxc_linter/src/service/mod.rs b/crates/oxc_linter/src/service/mod.rs
@@ -91,7 +91,7 @@ impl LintService {
         &self,
         file_system: &(dyn RuntimeFileSystem + Sync + Send),
         paths: Vec<Arc<OsStr>>,
-    ) -> Vec<crate::Message> {
+    ) -> Vec<(Arc<OsStr>, Vec<crate::Message>)> {
         self.runtime.run_source(file_system, paths)
     }
 
diff --git a/crates/oxc_linter/src/service/runtime.rs b/crates/oxc_linter/src/service/runtime.rs
@@ -659,13 +659,13 @@ impl Runtime {
         &self,
         file_system: &(dyn RuntimeFileSystem + Sync + Send),
         paths: Vec<Arc<OsStr>>,
-    ) -> Vec<Message> {
+    ) -> Vec<(Arc<OsStr>, Vec<crate::Message>)> {
         use std::sync::Mutex;
 
         self.modules_by_path.pin().reserve(paths.len());
         let paths_set: IndexSet<Arc<OsStr>, FxBuildHasher> = paths.into_iter().collect();
 
-        let messages = Mutex::new(Vec::<Message>::new());
+        let messages = Mutex::new(Vec::<(Arc<OsStr>, Vec<crate::Message>)>::new());
         rayon::scope(|scope| {
             self.resolve_modules(
                 file_system,
@@ -696,11 +696,12 @@ impl Runtime {
                                 }
                                 Err(diagnostics) => {
                                     if !diagnostics.is_empty() {
-                                        messages.lock().unwrap().extend(
+                                        messages.lock().unwrap().push((
+                                            Arc::clone(&module_to_lint.path),
                                             diagnostics.into_iter().map(|diagnostic| {
                                                 Message::new(diagnostic, PossibleFixes::None)
-                                            }),
-                                        );
+                                            }).collect(),
+                                        ));
                                     }
                                     None
                                 }
@@ -715,17 +716,19 @@ impl Runtime {
                         let (section_messages, disable_directives) = me
                             .linter
                             .run_with_disable_directives(path, context_sub_hosts, allocator_guard);
-
                         if let Some(disable_directives) = disable_directives {
                             me.disable_directives_map
                                 .lock()
                                 .expect("disable_directives_map mutex poisoned")
                                 .insert(path.to_path_buf(), disable_directives);
                         }
 
-                        messages.lock().unwrap().extend(
-                            section_messages
-                        );
+                        if !section_messages.is_empty() {
+                            messages.lock().unwrap().push((
+                                Arc::clone(&module_to_lint.path),
+                                section_messages
+                            ));
+                        }
                     },
                 );
                 },
diff --git a/crates/oxc_linter/src/tsgolint.rs b/crates/oxc_linter/src/tsgolint.rs

Original file line number	Diff line number	Diff line change
`@@ -555,11 +555,15 @@ impl ServerLinter {`
`555`	`555`	`}`
`556`	`556`
`557`	`557`	`fn get_code_actions_for_uri(&self, uri: &Uri) -> Option<Vec<LinterCodeAction>> {`
`558`		`- if let Some(cached_code_actions) = self.code_actions.pin().get(uri) {`
	`558`	+ // for code actions we need to make a roundtrip to `from_file_path` and `to_file_path`.
	`559`	`+ // The editor URI schema might differ from our own produced URIs.`
	`560`	`+ let uri = Uri::from_file_path(uri.to_file_path()?)?;`
	`561`	`+`
	`562`	`+ if let Some(cached_code_actions) = self.code_actions.pin().get(&uri) {`
`559`	`563`	`cached_code_actions.clone()`
`560`	`564`	`} else {`
`561`		`- self.run_file(uri, None);`
`562`		`- self.code_actions.pin().get(uri).and_then(std::clone::Clone::clone)`
	`565`	`+ self.run_file(&uri, None);`
	`566`	`+ self.code_actions.pin().get(&uri).and_then(std::clone::Clone::clone)`
`563`	`567`	`}`
`564`	`568`	`}`
`565`	`569`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ impl LintService {`
`91`	`91`	`&self,`
`92`	`92`	`file_system: &(dyn RuntimeFileSystem + Sync + Send),`
`93`	`93`	`paths: Vec<Arc<OsStr>>,`
`94`		`- ) -> Vec<crate::Message> {`
	`94`	`+ ) -> Vec<(Arc<OsStr>, Vec<crate::Message>)> {`
`95`	`95`	`self.runtime.run_source(file_system, paths)`
`96`	`96`	`}`
`97`	`97`