fix: cleanup

Author: dkattan

crates/oxc_language_server/src/linter/isolated_lint_handler.rs

@@ -7,12 +7,14 @@ use log::{debug, info};
 use oxc_data_structures::rope::Rope;
 use rustc_hash::FxHashSet;
 use tower_lsp_server::{UriExt, lsp_types::Uri};
+use std::collections::HashMap;
+use oxc_linter::read_to_string;
 
 use oxc_allocator::Allocator;
 use oxc_linter::{
     AllowWarnDeny, ConfigStore, DirectivesStore, DisableDirectives, Fix, LINTABLE_EXTENSIONS,
     LintOptions, LintService, LintServiceOptions, Linter, Message, PossibleFixes, RuleCommentType,
-    RuntimeFileSystem, read_to_arena_str, read_to_string,
+    RuntimeFileSystem, read_to_arena_str
 };
 
 use super::error_with_position::{
@@ -142,9 +144,6 @@ impl IsolatedLintHandler {
     /// Batch lint multiple paths using the underlying parallel runtime.
     /// Returns a vector of (Uri, DiagnosticReport list). Ignores non-lintable paths silently.
     pub fn run_workspace(&mut self, paths: &[PathBuf]) -> Vec<(Uri, Vec<DiagnosticReport>)> {
-        use oxc_data_structures::rope::Rope;
-        use oxc_linter::read_to_string;
-        use std::collections::HashMap;
 
 
         // Filter to lintable extensions first.

crates/oxc_language_server/src/log_bridge.rs

@@ -34,7 +34,7 @@ impl log::Log for LspForwardingLogger {
                 log::Level::Info => MessageType::INFO,
                 _ => MessageType::LOG,
             };
-            let _ = client.log_message(level, format!("{}", record.args()));
+            let _ = client.log_message(level, record.args().to_string());
         }
         // Always emit via fallback (stdout/stderr formatting, filtering, etc.).
         self.fallback.log(record);

crates/oxc_language_server/src/worker.rs

@@ -586,7 +586,10 @@ impl WorkspaceWorker {
         // Extract, sort deterministically.
         let mut files: Vec<Uri> = match collected.lock() {
             Ok(guard) => guard.clone(),
-            Err(poisoned) => poisoned.into_inner().clone(),
+            Err(poisoned) => {
+                log::warn!("Poisoned mutex encountered while collecting workspace files. Recovering inner value.");
+                poisoned.into_inner().clone()
+            },
         };
         files.sort_unstable_by(|a, b| a.as_str().cmp(b.as_str()));
         debug!(

crates/oxc_linter/src/tsgolint.rs

@@ -353,7 +353,13 @@ impl TsGoLintState {
                                 } else if let Some(st) = source_text_cache.get(&path) {
                                     st
                                 } else {
-                                    let st = read_to_string(&path).unwrap_or_default();
+                                    let st = match read_to_string(&path) {
+                                        Ok(content) => content,
+                                        Err(e) => {
+                                            eprintln!("Failed to read file '{}': {}", path.display(), e);
+                                            String::new()
+                                        }
+                                    };
                                     source_text_cache.insert(path.clone(), st);
                                     source_text_cache.get(&path).unwrap()
                                 };

editors/vscode/client/extension.ts

@@ -16,6 +16,7 @@ import {
   ExecuteCommandRequest,
   MessageType,
   ShowMessageNotification,
+  State,
 } from 'vscode-languageclient';
 
 import { Executable, LanguageClient, LanguageClientOptions, ServerOptions, StreamInfo } from 'vscode-languageclient/node';
@@ -29,6 +30,8 @@ const languageClientName = 'oxc';
 const outputChannelName = 'Oxc';
 const commandPrefix = 'oxc';
 
+const RESTART_DELAY_MS = 50;
+
 const enum OxcCommands {
   RestartServer = `${commandPrefix}.restartServer`,
   ApplyAllFixesFile = `${commandPrefix}.applyAllFixesFile`,
@@ -63,13 +66,9 @@ export async function activate(context: ExtensionContext) {
       }
 
       try {
-        // Guard against invoking restart while the client is in a transitional state.
-        // The languageclient exposes isRunning(), but we can also infer starting/stopping
-        // via internal state; here we only act if it is fully running or fully stopped.
-        // If starting, we bail out with a message to avoid race with initialize.
-        // Access internal _state (not part of public API) for finer grained restart guarding.
-        const state: string | undefined = (client as any)._state;
-        if (state === 'starting') {
+
+        const state = (client as LanguageClient)?.state;
+        if (state === State.Starting) {
           window.showWarningMessage('oxc server is still starting; try restart again in a moment.');
           return;
         }
@@ -80,7 +79,7 @@ export async function activate(context: ExtensionContext) {
           if (externalSocketSpec) {
             // External socket: stop sends shutdown/exit internally; wait a tick for server loop.
             await client.stop();
-            await new Promise(r => setTimeout(r, 50));
+            await new Promise(r => setTimeout(r, RESTART_DELAY_MS));
             await client.start();
           } else {
             // Spawned process: restart() is sufficient, but guard against transitional state.
@@ -217,7 +216,7 @@ export async function activate(context: ExtensionContext) {
         socket.on('error', (err) => {
           socket.destroy();
           if (attempt < maxAttempts) {
-            const delay = baseDelayMs * Math.pow(2, attempt - 1);
+            const delay = baseDelayMs * (2 ** (attempt - 1));
             outputChannel.info(`Language server not ready (attempt ${attempt}/${maxAttempts}). Retrying in ${delay}ms...`);
             setTimeout(tryConnect, delay);
           } else {

external/tsgolint

@@ -0,0 +1 @@
+Subproject commit 1a61b63a8b59d6f76269bc32d8a9254cf88751c1