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)
-            },
         }
     }
 
@@ -336,10 +315,7 @@ impl ServerLinter {
             (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)
-            }
+            (ServerLinterRun::OnSave, Run::OnType) => (false, true),
         };
 
         // return `None` when both tools do not want to be used
@@ -359,13 +335,6 @@ impl ServerLinter {
             self.diagnostics.isolated_linter.pin().insert(uri.to_string(), diagnostics);
         }
 
-        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.get_diagnostics(&uri.to_string())
     }
 
@@ -466,31 +435,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);
 
         // 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);

crates/oxc_language_server/src/linter/tsgo_linter.rs

@@ -13,6 +13,9 @@ use crate::{
     AllowWarnDeny, DisableDirectives, LintService, LintServiceOptions, Linter, TsGoLintState,
 };
 
+#[cfg(feature = "language_server")]
+use crate::Message;
+
 /// Unified runner that orchestrates both regular (oxc) and type-aware (tsgolint) linting
 /// with centralized disable directives handling.
 pub struct LintRunner {
@@ -217,6 +220,30 @@ impl LintRunner {
         Ok(self)
     }
 
+    /// Run both regular and type-aware linting on files
+    /// # Errors
+    /// Returns an error if type-aware linting fails.
+    #[cfg(feature = "language_server")]
+    pub fn run_source(
+        &mut self,
+        file: &Arc<OsStr>,
+        source_text: String,
+        file_system: Box<dyn crate::RuntimeFileSystem + Sync + Send>,
+    ) -> Vec<Message> {
+        self.lint_service.with_paths(vec![Arc::clone(file)]);
+        self.lint_service.with_file_system(file_system);
+
+        let mut messages = self.lint_service.run_source();
+
+        if let Some(type_aware_linter) = self.type_aware_linter.take()
+            && let Ok(tso_messages) = type_aware_linter.lint_source(file, source_text)
+        {
+            messages.extend(tso_messages);
+        }
+
+        messages
+    }
+
     /// Report unused disable directives
     pub fn report_unused_directives(
         &self,