refactor(language_server): use LintRunner

Author: Sysix

crates/oxc_language_server/src/linter/isolated_lint_handler.rs

@@ -11,8 +11,8 @@ use tower_lsp_server::{UriExt, lsp_types::Uri};
 use oxc_allocator::Allocator;
 use oxc_linter::{
     AllowWarnDeny, ConfigStore, DirectivesStore, DisableDirectives, LINTABLE_EXTENSIONS,
-    LintOptions, LintService, LintServiceOptions, Linter, Message, RuntimeFileSystem,
-    create_unused_directives_diagnostics, read_to_arena_str, read_to_string,
+    LintOptions, LintRunner, LintRunnerBuilder, LintServiceOptions, Linter, Message,
+    RuntimeFileSystem, create_unused_directives_diagnostics, read_to_arena_str, read_to_string,
 };
 
 use super::error_with_position::{
@@ -23,12 +23,13 @@ use super::error_with_position::{
 #[derive(Debug, Clone)]
 pub struct IsolatedLintHandlerOptions {
     pub use_cross_module: bool,
+    pub type_aware: bool,
     pub root_path: PathBuf,
     pub tsconfig_path: Option<PathBuf>,
 }
 
 pub struct IsolatedLintHandler {
-    service: LintService,
+    runner: LintRunner,
     directives_coordinator: DirectivesStore,
     unused_directives_severity: Option<AllowWarnDeny>,
 }
@@ -81,11 +82,11 @@ impl IsolatedLintHandler {
             lint_service_options = lint_service_options.with_tsconfig(tsconfig_path);
         }
 
-        let mut service = LintService::new(linter, lint_service_options);
-        service.set_disable_directives_map(directives_coordinator.map());
-
         Self {
-            service,
+            runner: LintRunnerBuilder::new(lint_service_options, linter)
+                .with_type_aware(options.type_aware)
+                .build()
+                .unwrap(),
             directives_coordinator,
             unused_directives_severity: lint_options.report_unused_directive,
         }
@@ -113,14 +114,14 @@ impl IsolatedLintHandler {
         debug!("lint {}", path.display());
         let rope = &Rope::from_str(source_text);
 
+        let fs = Box::new(IsolatedLintHandlerFileSystem::new(
+            path.to_path_buf(),
+            Arc::from(source_text),
+        ));
+
         let mut messages: Vec<DiagnosticReport> = self
-            .service
-            .with_file_system(Box::new(IsolatedLintHandlerFileSystem::new(
-                path.to_path_buf(),
-                Arc::from(source_text),
-            )))
-            .with_paths(vec![Arc::from(path.as_os_str())])
-            .run_source()
+            .runner
+            .run_source(&Arc::from(path.as_os_str()), source_text.to_string(), fs)
             .iter()
             .map(|message| message_to_lsp_diagnostic(message, uri, source_text, rope))
             .collect();

crates/oxc_language_server/src/linter/mod.rs

@@ -3,4 +3,3 @@ pub mod error_with_position;
 pub mod isolated_lint_handler;
 pub mod options;
 pub mod server_linter;
-pub mod tsgo_linter;

crates/oxc_language_server/src/linter/server_linter.rs

@@ -19,7 +19,6 @@ use crate::linter::{
     error_with_position::DiagnosticReport,
     isolated_lint_handler::{IsolatedLintHandler, IsolatedLintHandlerOptions},
     options::{LintOptions as LSPLintOptions, Run},
-    tsgo_linter::TsgoLinter,
 };
 use crate::utils::normalize_path;
 use crate::{ConcurrentHashMap, LINT_CONFIG_FILE};
@@ -35,7 +34,6 @@ pub enum ServerLinterRun {
 
 pub struct ServerLinter {
     isolated_linter: Arc<Mutex<IsolatedLintHandler>>,
-    tsgo_linter: Arc<Option<TsgoLinter>>,
     ignore_matcher: LintIgnoreMatcher,
     gitignore_glob: Vec<Gitignore>,
     lint_on_run: Run,
@@ -46,7 +44,6 @@ pub struct ServerLinter {
 #[derive(Debug, Default)]
 struct ServerLinterDiagnostics {
     isolated_linter: Arc<ConcurrentHashMap<String, Option<Vec<DiagnosticReport>>>>,
-    tsgo_linter: Arc<ConcurrentHashMap<String, Option<Vec<DiagnosticReport>>>>,
 }
 
 impl ServerLinterDiagnostics {
@@ -59,29 +56,15 @@ impl ServerLinterDiagnostics {
                 reports.extend(diagnostics.clone());
             }
         }
-        if let Some(entry) = self.tsgo_linter.pin().get(path) {
-            found = true;
-            if let Some(diagnostics) = entry {
-                reports.extend(diagnostics.clone());
-            }
-        }
         if found { Some(reports) } else { None }
     }
 
     pub fn remove_diagnostics(&self, path: &str) {
         self.isolated_linter.pin().remove(path);
-        self.tsgo_linter.pin().remove(path);
     }
 
     pub fn get_cached_files_of_diagnostics(&self) -> Vec<String> {
-        let isolated_files = self.isolated_linter.pin().keys().cloned().collect::<Vec<_>>();
-        let tsgo_files = self.tsgo_linter.pin().keys().cloned().collect::<Vec<_>>();
-
-        let mut files = Vec::with_capacity(isolated_files.len() + tsgo_files.len());
-        files.extend(isolated_files);
-        files.extend(tsgo_files);
-        files.dedup();
-        files
+        self.isolated_linter.pin().keys().cloned().collect::<Vec<_>>()
     }
 }
 
@@ -153,9 +136,10 @@ impl ServerLinter {
 
         let isolated_linter = IsolatedLintHandler::new(
             lint_options,
-            config_store.clone(), // clone because tsgo linter needs it
+            config_store,
             &IsolatedLintHandlerOptions {
                 use_cross_module,
+                type_aware: options.type_aware,
                 root_path: root_path.to_path_buf(),
                 tsconfig_path: options.ts_config_path.as_ref().map(|path| {
                     let path = Path::new(path).to_path_buf();
@@ -175,11 +159,6 @@ impl ServerLinter {
             extended_paths,
             lint_on_run: options.run,
             diagnostics: ServerLinterDiagnostics::default(),
-            tsgo_linter: if options.type_aware {
-                Arc::new(Some(TsgoLinter::new(&root_path, config_store)))
-            } else {
-                Arc::new(None)
-            },
         }
     }
 
@@ -326,45 +305,26 @@ impl ServerLinter {
         content: Option<String>,
         run_type: ServerLinterRun,
     ) -> Option<Vec<DiagnosticReport>> {
-        let (oxlint, tsgolint) = match (run_type, self.lint_on_run) {
-            // run everything on save, or when it is forced
-            (ServerLinterRun::Always, _) | (ServerLinterRun::OnSave, Run::OnSave) => (true, true),
-            // run only oxlint on type
-            // tsgolint does not support memory source_text
-            (ServerLinterRun::OnType, Run::OnType) => (true, false),
-            // it does not match, run nothing
-            (ServerLinterRun::OnType, Run::OnSave) => (false, false),
-            // In onType mode, only TypeScript type checking runs on save
-            // If type_aware is disabled (tsgo_linter is None), skip everything to preserve diagnostics
-            (ServerLinterRun::OnSave, Run::OnType) => {
-                let should_run_tsgo = self.tsgo_linter.as_ref().is_some();
-                (false, should_run_tsgo)
-            }
-        };
+        let run = !matches!(
+            (run_type, self.lint_on_run),
+            (ServerLinterRun::OnType, Run::OnSave) | (ServerLinterRun::OnSave, Run::OnType)
+        );
 
         // return `None` when both tools do not want to be used
-        if !oxlint && !tsgolint {
+        if !run {
             return None;
         }
 
         if self.is_ignored(uri) {
             return None;
         }
 
-        if oxlint {
-            let diagnostics = {
-                let mut isolated_linter = self.isolated_linter.lock().await;
-                isolated_linter.run_single(uri, content.clone())
-            };
-            self.diagnostics.isolated_linter.pin().insert(uri.to_string(), diagnostics);
-        }
+        let diagnostics = {
+            let mut isolated_linter = self.isolated_linter.lock().await;
+            isolated_linter.run_single(uri, content.clone())
+        };
 
-        if tsgolint && let Some(tsgo_linter) = self.tsgo_linter.as_ref() {
-            self.diagnostics
-                .tsgo_linter
-                .pin()
-                .insert(uri.to_string(), tsgo_linter.lint_file(uri, content.clone()));
-        }
+        self.diagnostics.isolated_linter.pin().insert(uri.to_string(), diagnostics);
 
         self.diagnostics.get_diagnostics(&uri.to_string())
     }
@@ -466,31 +426,23 @@ mod test {
     fn test_get_diagnostics_found_and_none_entries() {
         let key = "file:///test.js".to_string();
 
-        // Case 1: Both entries present, Some diagnostics
+        // Case 1: Entry present, Some diagnostics
         let diag = DiagnosticReport::default();
         let diag_map = ConcurrentHashMap::default();
-        diag_map.pin().insert(key.clone(), Some(vec![diag.clone()]));
-        let tsgo_map = ConcurrentHashMap::default();
-        tsgo_map.pin().insert(key.clone(), Some(vec![diag]));
+        diag_map.pin().insert(key.clone(), Some(vec![diag]));
 
-        let server_diag = super::ServerLinterDiagnostics {
-            isolated_linter: std::sync::Arc::new(diag_map),
-            tsgo_linter: std::sync::Arc::new(tsgo_map),
-        };
+        let server_diag =
+            super::ServerLinterDiagnostics { isolated_linter: std::sync::Arc::new(diag_map) };
         let result = server_diag.get_diagnostics(&key);
         assert!(result.is_some());
-        assert_eq!(result.unwrap().len(), 2);
+        assert_eq!(result.unwrap().len(), 1);
 
         // Case 2: Entry present, but value is None
         let diag_map_none = ConcurrentHashMap::default();
         diag_map_none.pin().insert(key.clone(), None);
-        let tsgo_map_none = ConcurrentHashMap::default();
-        tsgo_map_none.pin().insert(key.clone(), None);
 
-        let server_diag_none = ServerLinterDiagnostics {
-            isolated_linter: std::sync::Arc::new(diag_map_none),
-            tsgo_linter: std::sync::Arc::new(tsgo_map_none),
-        };
+        let server_diag_none =
+            ServerLinterDiagnostics { isolated_linter: std::sync::Arc::new(diag_map_none) };
         let result_none = server_diag_none.get_diagnostics(&key);
         assert!(result_none.is_some());
         assert_eq!(result_none.unwrap().len(), 0);
@@ -535,7 +487,7 @@ mod test {
     #[cfg(not(target_endian = "big"))]
     fn test_lint_on_run_on_save_on_save() {
         Tester::new(
-            "fixtures/linter/lint_on_run/on_type",
+            "fixtures/linter/lint_on_run/on_save",
             Some(LintOptions { type_aware: true, run: Run::OnSave, ..Default::default() }),
         )
         .test_and_snapshot_single_file_with_run_type("on-save.ts", Run::OnSave);

crates/oxc_language_server/src/linter/tsgo_linter.rs

@@ -5,6 +5,70 @@ source: crates/oxc_language_server/src/tester.rs
 file: fixtures/linter/lint_on_run/on_save/on-save.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/lint_on_run/on_save/on-save.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: Multiple(
+    [
+        FixedContent {
+            message: Some(
+                "Remove the debugger statement",
+            ),
+            code: "",
+            range: Range {
+                start: Position {
+                    line: 1,
+                    character: 0,
+                },
+                end: Position {
+                    line: 1,
+                    character: 9,
+                },
+            },
+        },
+        FixedContent {
+            message: Some(
+                "Disable no-debugger for this line",
+            ),
+            code: "// oxlint-disable-next-line no-debugger\n",
+            range: Range {
+                start: Position {
+                    line: 1,
+                    character: 0,
+                },
+                end: Position {
+                    line: 1,
+                    character: 0,
+                },
+            },
+        },
+        FixedContent {
+            message: Some(
+                "Disable no-debugger for this file",
+            ),
+            code: "// oxlint-disable no-debugger\n",
+            range: Range {
+                start: Position {
+                    line: 0,
+                    character: 0,
+                },
+                end: Position {
+                    line: 0,
+                    character: 0,
+                },
+            },
+        },
+    ],
+)
+
+
 code: "typescript-eslint(no-floating-promises)"
 code_description.href: "None"
 message: "Promises must be awaited.\nhelp: The promise must end with a call to .catch, or end with a call to .then with a rejection handler, or be explicitly marked as ignored with the `void` operator."