feat(language_server): search for nested configurations by initialization (#10120)

Now the client does not need to send a second request after initialization.
The initialization part is done on the server side. The client only needs to send future changes because file-watchers on servers are not recommended: https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workspace_didChangeWatchedFiles

Author: Sysix

crates/oxc_language_server/src/linter/config_walker.rs

@@ -0,0 +1,90 @@
+use std::{
+    ffi::OsStr,
+    path::PathBuf,
+    sync::{Arc, mpsc},
+};
+
+use ignore::DirEntry;
+
+use crate::OXC_CONFIG_FILE;
+
+pub struct ConfigWalker {
+    inner: ignore::WalkParallel,
+}
+
+struct WalkBuilder {
+    sender: mpsc::Sender<Vec<Arc<OsStr>>>,
+}
+
+impl<'s> ignore::ParallelVisitorBuilder<'s> for WalkBuilder {
+    fn build(&mut self) -> Box<dyn ignore::ParallelVisitor + 's> {
+        Box::new(WalkCollector { paths: vec![], sender: self.sender.clone() })
+    }
+}
+
+struct WalkCollector {
+    paths: Vec<Arc<OsStr>>,
+    sender: mpsc::Sender<Vec<Arc<OsStr>>>,
+}
+
+impl Drop for WalkCollector {
+    fn drop(&mut self) {
+        let paths = std::mem::take(&mut self.paths);
+        self.sender.send(paths).unwrap();
+    }
+}
+
+impl ignore::ParallelVisitor for WalkCollector {
+    fn visit(&mut self, entry: Result<ignore::DirEntry, ignore::Error>) -> ignore::WalkState {
+        match entry {
+            Ok(entry) => {
+                if Self::is_wanted_entry(&entry) {
+                    self.paths.push(entry.path().as_os_str().into());
+                }
+                ignore::WalkState::Continue
+            }
+            Err(_err) => ignore::WalkState::Skip,
+        }
+    }
+}
+
+impl WalkCollector {
+    fn is_wanted_entry(entry: &DirEntry) -> bool {
+        let Some(file_type) = entry.file_type() else { return false };
+        if file_type.is_dir() {
+            return false;
+        }
+        let Some(file_name) = entry.path().file_name() else { return false };
+
+        file_name == OXC_CONFIG_FILE
+    }
+}
+
+impl ConfigWalker {
+    /// Will not canonicalize paths.
+    /// # Panics
+    pub fn new(path: &PathBuf) -> Self {
+        // Turning off `follow_links` because:
+        // * following symlinks is a really slow syscall
+        // * it is super rare to have symlinked source code
+        let inner: ignore::WalkParallel = ignore::WalkBuilder::new(path)
+            // disable skip hidden, which will not not search for files starting with a dot
+            .hidden(false)
+            // disable all gitignore features
+            .parents(false)
+            .ignore(false)
+            .git_global(false)
+            .follow_links(false)
+            .build_parallel();
+
+        Self { inner }
+    }
+
+    pub fn paths(self) -> Vec<Arc<OsStr>> {
+        let (sender, receiver) = mpsc::channel::<Vec<Arc<OsStr>>>();
+        let mut builder = WalkBuilder { sender };
+        self.inner.visit(&mut builder);
+        drop(builder);
+        receiver.into_iter().flatten().collect()
+    }
+}

crates/oxc_language_server/src/linter/mod.rs

@@ -1,6 +1,7 @@
 use oxc_data_structures::rope::{Rope, get_line_column};
 use tower_lsp::lsp_types::Position;
 
+pub mod config_walker;
 pub mod error_with_position;
 mod isolated_lint_handler;
 pub mod server_linter;

crates/oxc_language_server/src/main.rs

@@ -1,13 +1,17 @@
-use std::{fmt::Debug, path::PathBuf, str::FromStr};
-
 use commands::LSP_COMMANDS;
 use futures::future::join_all;
 use globset::Glob;
 use ignore::gitignore::Gitignore;
+use linter::config_walker::ConfigWalker;
 use log::{debug, error, info};
 use oxc_linter::{ConfigStore, ConfigStoreBuilder, FixKind, LintOptions, Linter, Oxlintrc};
 use rustc_hash::{FxBuildHasher, FxHashMap};
 use serde::{Deserialize, Serialize};
+use std::{
+    fmt::Debug,
+    path::{Path, PathBuf},
+    str::FromStr,
+};
 use tokio::sync::{Mutex, OnceCell, RwLock, SetError};
 use tower_lsp::{
     Client, LanguageServer, LspService, Server,
@@ -79,6 +83,7 @@ impl LanguageServer for Backend {
             *self.options.lock().await = value;
         }
 
+        self.init_nested_configs().await;
         let oxlintrc = self.init_linter_config().await;
         self.init_ignore_glob(oxlintrc).await;
         Ok(InitializeResult {
@@ -121,8 +126,9 @@ impl LanguageServer for Backend {
         "
         );
 
-        if changed_options.disable_nested_configs() {
+        if changed_options.disable_nested_configs() != current_option.disable_nested_configs() {
             self.nested_configs.pin().clear();
+            self.init_nested_configs().await;
         }
 
         *self.options.lock().await = changed_options.clone();
@@ -501,6 +507,38 @@ impl Backend {
         .await;
     }
 
+    /// Searches inside root_uri recursively for the default oxlint config files
+    /// and insert them inside the nested configuration
+    async fn init_nested_configs(&self) {
+        let Some(Some(uri)) = self.root_uri.get() else {
+            return;
+        };
+        let Ok(root_path) = uri.to_file_path() else {
+            return;
+        };
+
+        // nested config is disabled, no need to search for configs
+        if self.options.lock().await.disable_nested_configs() {
+            return;
+        }
+
+        let paths = ConfigWalker::new(&root_path).paths();
+        let nested_configs = self.nested_configs.pin();
+
+        for path in paths {
+            let file_path = Path::new(&path);
+            let Some(dir_path) = file_path.parent() else {
+                continue;
+            };
+
+            let oxlintrc = Oxlintrc::from_file(file_path).expect("Failed to parse config file");
+            let config_store_builder = ConfigStoreBuilder::from_oxlintrc(false, oxlintrc)
+                .expect("Failed to create config store builder");
+            let config_store = config_store_builder.build().expect("Failed to build config store");
+            nested_configs.insert(dir_path.to_path_buf(), config_store);
+        }
+    }
+
     async fn init_linter_config(&self) -> Option<Oxlintrc> {
         let Some(Some(uri)) = self.root_uri.get() else {
             return None;

editors/vscode/client/extension.ts

@@ -7,18 +7,11 @@ import {
   StatusBarAlignment,
   StatusBarItem,
   ThemeColor,
-  Uri,
   window,
   workspace,
 } from 'vscode';
 
-import {
-  DidChangeWatchedFilesNotification,
-  ExecuteCommandRequest,
-  FileChangeType,
-  MessageType,
-  ShowMessageNotification,
-} from 'vscode-languageclient';
+import { ExecuteCommandRequest, MessageType, ShowMessageNotification } from 'vscode-languageclient';
 
 import { Executable, LanguageClient, LanguageClientOptions, ServerOptions } from 'vscode-languageclient/node';
 
@@ -58,14 +51,9 @@ export async function activate(context: ExtensionContext) {
       try {
         if (client.isRunning()) {
           await client.restart();
-          // ToDo: refactor it on the server side.
-          // Do not touch watchers on client side, just simplify the restart of the server.
-          const configFiles = await findOxlintrcConfigFiles();
-          await sendDidChangeWatchedFilesNotificationWith(client, configFiles);
-
           window.showInformationMessage('oxc server restarted.');
         } else {
-          await startClient(client);
+          await client.start();
         }
       } catch (err) {
         client.error('Restarting client failed', err, 'force');
@@ -95,7 +83,7 @@ export async function activate(context: ExtensionContext) {
         }
       } else {
         if (configService.config.enable) {
-          await startClient(client);
+          await client.start();
         }
       }
     },
@@ -187,6 +175,10 @@ export async function activate(context: ExtensionContext) {
     run,
     debug: run,
   };
+
+  const fileWatchers = createFileEventWatchers(configService.config.configPath);
+  context.subscriptions.push(...fileWatchers);
+
   // If the extension is launched in debug mode then the debug server options are used
   // Otherwise the run options are used
   // Options to control the language client
@@ -205,7 +197,7 @@ export async function activate(context: ExtensionContext) {
     })),
     synchronize: {
       // Notify the server about file config changes in the workspace
-      fileEvents: createFileEventWatchers(configService.config.configPath),
+      fileEvents: fileWatchers,
     },
     initializationOptions: {
       settings: configService.config.toLanguageServerConfig(),
@@ -269,8 +261,6 @@ export async function activate(context: ExtensionContext) {
 
       if (client.isRunning()) {
         await client.restart();
-        const configFiles = await findOxlintrcConfigFiles();
-        await sendDidChangeWatchedFilesNotificationWith(client, configFiles);
       }
     }
   };
@@ -297,52 +287,28 @@ export async function activate(context: ExtensionContext) {
   updateStatsBar(configService.config.enable);
 
   if (configService.config.enable) {
-    await startClient(client);
-  }
-}
-
-// Starts the client, it does not check if it is already started
-async function startClient(client: LanguageClient | undefined) {
-  if (client === undefined) {
-    return;
+    await client.start();
   }
-  await client.start();
-  // ToDo: refactor it on the server side.
-  // Do not touch watchers on client side, just simplify the start of the server.
-  const configFiles = await findOxlintrcConfigFiles();
-  await sendDidChangeWatchedFilesNotificationWith(client, configFiles);
 }
 
-export function deactivate(): Thenable<void> | undefined {
+export async function deactivate(): Promise<void> {
   if (!client) {
     return undefined;
   }
-  return client.stop();
+  await client.stop();
+  client = undefined;
 }
 
+// FileSystemWatcher are not ready on the start and can take some seconds on bigger repositories
+// ToDo: create test to make sure this will never break
 function createFileEventWatchers(configRelativePath: string | null) {
-  const workspaceConfigPatterns = configRelativePath !== null
-    ? (workspace.workspaceFolders || []).map((workspaceFolder) =>
-      new RelativePattern(workspaceFolder, configRelativePath)
-    )
-    : [];
+  if (configRelativePath !== null) {
+    return (workspace.workspaceFolders || []).map((workspaceFolder) =>
+      workspace.createFileSystemWatcher(new RelativePattern(workspaceFolder, configRelativePath))
+    );
+  }
 
   return [
     workspace.createFileSystemWatcher(`**/${oxlintConfigFileName}`),
-    ...workspaceConfigPatterns.map((pattern) => {
-      return workspace.createFileSystemWatcher(pattern);
-    }),
   ];
 }
-
-async function findOxlintrcConfigFiles() {
-  return workspace.findFiles(`**/${oxlintConfigFileName}`);
-}
-
-async function sendDidChangeWatchedFilesNotificationWith(languageClient: LanguageClient, files: Uri[]) {
-  await languageClient.sendNotification(DidChangeWatchedFilesNotification.type, {
-    changes: files.map(file => {
-      return { uri: file.toString(), type: FileChangeType.Created };
-    }),
-  });
-}