feat(language_server): use linter runtime

Sysix · Sysix · commit c12bf895f9f6 · 2025-04-08T21:39:29.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/oxc_language_server/Cargo.toml b/crates/oxc_language_server/Cargo.toml
@@ -22,12 +22,9 @@ test = true
 doctest = false
 
 [dependencies]
-oxc_allocator = { workspace = true }
 oxc_data_structures = { workspace = true, features = ["rope"] }
 oxc_diagnostics = { workspace = true }
 oxc_linter = { workspace = true }
-oxc_parser = { workspace = true }
-oxc_semantic = { workspace = true }
 
 cow-utils = { workspace = true }
 env_logger = { workspace = true, features = ["humantime"] }
diff --git a/crates/oxc_language_server/src/linter/isolated_lint_handler.rs b/crates/oxc_language_server/src/linter/isolated_lint_handler.rs
@@ -1,35 +1,34 @@
 use std::{
     fs,
-    path::Path,
-    rc::Rc,
-    sync::{Arc, OnceLock},
+    path::{Path, PathBuf},
+    sync::{Arc, OnceLock, mpsc},
 };
 
 use log::debug;
 use rustc_hash::FxHashSet;
-use tower_lsp::lsp_types::{self, DiagnosticRelatedInformation, DiagnosticSeverity, Range};
+use tower_lsp::lsp_types::{self, DiagnosticRelatedInformation, DiagnosticSeverity};
 
-use oxc_allocator::Allocator;
 use oxc_diagnostics::{Error, NamedSource};
-use oxc_linter::{
-    LINTABLE_EXTENSIONS, Linter, ModuleRecord,
-    loader::{JavaScriptSource, Loader},
-};
-use oxc_parser::{ParseOptions, Parser};
-use oxc_semantic::SemanticBuilder;
+use oxc_linter::{LINTABLE_EXTENSIONS, LintService, LintServiceOptions, Linter, loader::Loader};
 
 use crate::DiagnosticReport;
-use crate::linter::error_with_position::{ErrorReport, ErrorWithPosition, FixedContent};
-use crate::linter::offset_to_position;
+use crate::linter::error_with_position::{ErrorReport, ErrorWithPosition};
+
+/// smaller subset of LintServiceOptions, which is used by IsolatedLintHandler
+#[derive(Debug, Clone)]
+pub struct IsolatedLintHandlerOptions {
+    pub use_cross_module: bool,
+    pub root_path: PathBuf,
+}
 
 pub struct IsolatedLintHandler {
     linter: Arc<Linter>,
-    loader: Loader,
+    options: Arc<IsolatedLintHandlerOptions>,
 }
 
 impl IsolatedLintHandler {
-    pub fn new(linter: Arc<Linter>) -> Self {
-        Self { linter, loader: Loader }
+    pub fn new(linter: Arc<Linter>, options: Arc<IsolatedLintHandlerOptions>) -> Self {
+        Self { linter, options }
     }
 
     pub fn run_single(
@@ -100,89 +99,31 @@ impl IsolatedLintHandler {
             return None;
         }
         let source_text = source_text.or_else(|| fs::read_to_string(path).ok())?;
-        let javascript_sources = match self.loader.load_str(path, &source_text) {
-            Ok(s) => s,
-            Err(e) => {
-                debug!("failed to load {path:?}: {e}");
-                return None;
-            }
-        };
 
         debug!("lint {path:?}");
-        let mut diagnostics = vec![];
-        for source in javascript_sources {
-            let JavaScriptSource {
-                source_text: javascript_source_text, source_type, start, ..
-            } = source;
-            let allocator = Allocator::default();
-            let ret = Parser::new(&allocator, javascript_source_text, source_type)
-                .with_options(ParseOptions {
-                    allow_return_outside_function: true,
-                    parse_regular_expression: true,
-                    ..ParseOptions::default()
-                })
-                .parse();
-
-            if !ret.errors.is_empty() {
-                let reports = ret
-                    .errors
-                    .into_iter()
-                    .map(|diagnostic| ErrorReport {
-                        error: Error::from(diagnostic),
-                        fixed_content: None,
-                    })
-                    .collect();
-                return Some(Self::wrap_diagnostics(path, &source_text, reports, start));
+        let mut diagnostics_result = vec![];
+
+        let (sender, receiver) = mpsc::channel();
+        let lint_service_options = LintServiceOptions::new(
+            self.options.root_path.clone(),
+            vec![Arc::from(path.as_os_str())],
+        )
+        .with_cross_module(self.options.use_cross_module);
+        // ToDo: do not clone the linter
+        let mut lint_service = LintService::new((*self.linter).clone(), lint_service_options);
+        tokio::task::block_in_place(move || {
+            lint_service.run(&sender);
+        });
+
+        while let Ok(Some((path, diagnostics))) = receiver.recv() {
+            for diagnostic in diagnostics {
+                // ToDo: reimplement fixed_content
+                let report = ErrorReport { error: Error::from(diagnostic), fixed_content: None };
+                diagnostics_result.push(Self::wrap_diagnostics(&path, &source_text, report));
             }
-
-            let semantic_ret = SemanticBuilder::new()
-                .with_cfg(true)
-                .with_scope_tree_child_ids(true)
-                .with_check_syntax_error(true)
-                .build(&ret.program);
-
-            if !semantic_ret.errors.is_empty() {
-                let reports = semantic_ret
-                    .errors
-                    .into_iter()
-                    .map(|diagnostic| ErrorReport {
-                        error: Error::from(diagnostic),
-                        fixed_content: None,
-                    })
-                    .collect();
-                return Some(Self::wrap_diagnostics(path, &source_text, reports, start));
-            }
-
-            let mut semantic = semantic_ret.semantic;
-            semantic.set_irregular_whitespaces(ret.irregular_whitespaces);
-            let module_record = Arc::new(ModuleRecord::new(path, &ret.module_record, &semantic));
-            let result = self.linter.run(path, Rc::new(semantic), module_record);
-
-            let reports = result
-                .into_iter()
-                .map(|msg| {
-                    let fixed_content = msg.fix.map(|f| FixedContent {
-                        message: f.message.map(|m| m.to_string()),
-                        code: f.content.to_string(),
-                        range: Range {
-                            start: offset_to_position(
-                                (f.span.start + start) as usize,
-                                source_text.as_str(),
-                            ),
-                            end: offset_to_position(
-                                (f.span.end + start) as usize,
-                                source_text.as_str(),
-                            ),
-                        },
-                    });
-
-                    ErrorReport { error: Error::from(msg.error), fixed_content }
-                })
-                .collect::<Vec<ErrorReport>>();
-            diagnostics.extend(Self::wrap_diagnostics(path, &source_text, reports, start));
         }
 
-        Some(diagnostics)
+        Some(diagnostics_result)
     }
 
     fn should_lint_path(path: &Path) -> bool {
@@ -195,24 +136,14 @@ impl IsolatedLintHandler {
             .is_some_and(|ext| wanted_exts.contains(ext))
     }
 
-    fn wrap_diagnostics(
-        path: &Path,
-        source_text: &str,
-        reports: Vec<ErrorReport>,
-        start: u32,
-    ) -> Vec<ErrorWithPosition> {
+    fn wrap_diagnostics(path: &Path, source_text: &str, report: ErrorReport) -> ErrorWithPosition {
         let source = Arc::new(NamedSource::new(path.to_string_lossy(), source_text.to_owned()));
 
-        reports
-            .into_iter()
-            .map(|report| {
-                ErrorWithPosition::new(
-                    report.error.with_source_code(Arc::clone(&source)),
-                    source_text,
-                    report.fixed_content,
-                    start as usize,
-                )
-            })
-            .collect()
+        ErrorWithPosition::new(
+            report.error.with_source_code(Arc::clone(&source)),
+            source_text,
+            report.fixed_content,
+            0,
+        )
     }
 }
diff --git a/crates/oxc_language_server/src/linter/mod.rs b/crates/oxc_language_server/src/linter/mod.rs
@@ -3,7 +3,7 @@ use tower_lsp::lsp_types::Position;
 
 pub mod config_walker;
 pub mod error_with_position;
-mod isolated_lint_handler;
+pub mod isolated_lint_handler;
 pub mod server_linter;
 
 #[cfg(test)]
diff --git a/crates/oxc_language_server/src/linter/server_linter.rs b/crates/oxc_language_server/src/linter/server_linter.rs
@@ -2,29 +2,32 @@ use std::sync::Arc;
 
 use tower_lsp::lsp_types::Url;
 
-use oxc_linter::{ConfigStoreBuilder, FixKind, LintOptions, Linter};
+use oxc_linter::{ConfigStoreBuilder, LintOptions, Linter};
 
 use crate::linter::error_with_position::DiagnosticReport;
 use crate::linter::isolated_lint_handler::IsolatedLintHandler;
 
+use super::isolated_lint_handler::IsolatedLintHandlerOptions;
+
 pub struct ServerLinter {
     linter: Arc<Linter>,
+    options: Arc<IsolatedLintHandlerOptions>,
 }
 
 impl ServerLinter {
-    pub fn new() -> Self {
+    pub fn new(options: IsolatedLintHandlerOptions) -> Self {
         let config_store =
             ConfigStoreBuilder::default().build().expect("Failed to build config store");
-        let linter = Linter::new(LintOptions::default(), config_store).with_fix(FixKind::SafeFix);
-        Self { linter: Arc::new(linter) }
+        let linter = Linter::new(LintOptions::default(), config_store);
+        Self { linter: Arc::new(linter), options: Arc::new(options) }
     }
 
-    pub fn new_with_linter(linter: Linter) -> Self {
-        Self { linter: Arc::new(linter) }
+    pub fn new_with_linter(linter: Linter, options: IsolatedLintHandlerOptions) -> Self {
+        Self { linter: Arc::new(linter), options: Arc::new(options) }
     }
 
     pub fn run_single(&self, uri: &Url, content: Option<String>) -> Option<Vec<DiagnosticReport>> {
-        IsolatedLintHandler::new(Arc::clone(&self.linter))
+        IsolatedLintHandler::new(Arc::clone(&self.linter), Arc::clone(&self.options))
             .run_single(&uri.to_file_path().unwrap(), content)
     }
 }
@@ -50,7 +53,7 @@ mod test {
             .with_filter(&LintFilter::deny(LintFilterKind::parse("no-console".into()).unwrap()))
             .build()
             .unwrap();
-        let linter = Linter::new(LintOptions::default(), config_store).with_fix(FixKind::SafeFix);
+        let linter = Linter::new(LintOptions::default(), config_store);
 
         Tester::new_with_linter(linter)
             .with_snapshot_suffix("deny_no_console")
@@ -68,7 +71,7 @@ mod test {
         .unwrap()
         .build()
         .unwrap();
-        let linter = Linter::new(LintOptions::default(), config_store).with_fix(FixKind::SafeFix);
+        let linter = Linter::new(LintOptions::default(), config_store);
 
         Tester::new_with_linter(linter)
             .test_and_snapshot_single_file("fixtures/linter/issue_9958/issue.ts");
@@ -85,7 +88,7 @@ mod test {
         .unwrap()
         .build()
         .unwrap();
-        let linter = Linter::new(LintOptions::default(), config_store).with_fix(FixKind::SafeFix);
+        let linter = Linter::new(LintOptions::default(), config_store);
 
         Tester::new_with_linter(linter)
             .test_and_snapshot_single_file("fixtures/linter/regexp_feature/index.ts");
diff --git a/crates/oxc_language_server/src/linter/tester.rs b/crates/oxc_language_server/src/linter/tester.rs
@@ -3,7 +3,10 @@ use std::fmt::Write;
 use oxc_linter::Linter;
 use tower_lsp::lsp_types::{CodeDescription, NumberOrString, Url};
 
-use super::{error_with_position::DiagnosticReport, server_linter::ServerLinter};
+use super::{
+    error_with_position::DiagnosticReport, isolated_lint_handler::IsolatedLintHandlerOptions,
+    server_linter::ServerLinter,
+};
 
 /// Given a file path relative to the crate root directory, return the URI of the file.
 pub fn get_file_uri(relative_file_path: &str) -> Url {
@@ -86,11 +89,26 @@ pub struct Tester<'t> {
 
 impl Tester<'_> {
     pub fn new() -> Self {
-        Self { snapshot_suffix: None, server_linter: ServerLinter::new() }
+        Self {
+            snapshot_suffix: None,
+            server_linter: ServerLinter::new(IsolatedLintHandlerOptions {
+                use_cross_module: false,
+                root_path: std::env::current_dir().expect("could not get current dir"),
+            }),
+        }
     }
 
     pub fn new_with_linter(linter: Linter) -> Self {
-        Self { snapshot_suffix: None, server_linter: ServerLinter::new_with_linter(linter) }
+        Self {
+            snapshot_suffix: None,
+            server_linter: ServerLinter::new_with_linter(
+                linter,
+                IsolatedLintHandlerOptions {
+                    use_cross_module: false,
+                    root_path: std::env::current_dir().expect("could not get current dir"),
+                },
+            ),
+        }
     }
 
     pub fn with_snapshot_suffix(mut self, suffix: &'static str) -> Self {
diff --git a/crates/oxc_language_server/src/main.rs b/crates/oxc_language_server/src/main.rs
@@ -2,7 +2,7 @@ use commands::LSP_COMMANDS;
 use futures::future::join_all;
 use globset::Glob;
 use ignore::gitignore::Gitignore;
-use linter::config_walker::ConfigWalker;
+use linter::{config_walker::ConfigWalker, isolated_lint_handler::IsolatedLintHandlerOptions};
 use log::{debug, error, info};
 use oxc_linter::{ConfigStore, ConfigStoreBuilder, FixKind, LintOptions, Linter, Oxlintrc};
 use rustc_hash::{FxBuildHasher, FxHashMap};
@@ -580,22 +580,29 @@ impl Backend {
             .build()
             .expect("failed to build config");
 
-        let lint_options =
-            LintOptions { fix: self.options.lock().await.fix_kind(), ..Default::default() };
+        // ToDo: add support for tsconfig
+        // ToDo: fix-kind should be applied when running code action or commands -- fix: self.options.lock().await.fix_kind()
+        let lint_options = LintOptions { fix: FixKind::None, ..Default::default() };
 
-        let linter = if self.options.lock().await.disable_nested_configs() {
-            Linter::new(lint_options, config_store)
+        let (linter, use_cross_module) = if self.options.lock().await.disable_nested_configs() {
+            (Linter::new(lint_options, config_store), oxlintrc.plugins.has_import())
         } else {
             let nested_configs = self.nested_configs.pin();
             let nested_configs_copy: FxHashMap<PathBuf, ConfigStore> = nested_configs
                 .iter()
                 .map(|(key, value)| (key.clone(), value.clone()))
                 .collect::<FxHashMap<_, _>>();
 
-            Linter::new_with_nested_configs(lint_options, config_store, nested_configs_copy)
+            (
+                Linter::new_with_nested_configs(lint_options, config_store, nested_configs_copy),
+                nested_configs.values().any(|config| config.plugins().has_import()),
+            )
         };
 
-        *self.server_linter.write().await = ServerLinter::new_with_linter(linter);
+        *self.server_linter.write().await = ServerLinter::new_with_linter(
+            linter,
+            IsolatedLintHandlerOptions { use_cross_module, root_path },
+        );
 
         Some(oxlintrc.clone())
     }
@@ -649,7 +656,10 @@ async fn main() {
     let stdin = tokio::io::stdin();
     let stdout = tokio::io::stdout();
 
-    let server_linter = ServerLinter::new();
+    let server_linter = ServerLinter::new(IsolatedLintHandlerOptions {
+        use_cross_module: false,
+        root_path: PathBuf::new(),
+    });
     let diagnostics_report_map = ConcurrentHashMap::default();
 
     let (service, socket) = LspService::build(|client| Backend {
diff --git a/crates/oxc_linter/src/lib.rs b/crates/oxc_linter/src/lib.rs
