feat(oxc_language_server): Support nested configs

crates/oxc_language_server/src/main.rs

@@ -5,7 +5,8 @@ use futures::future::join_all;
 use globset::Glob;
 use ignore::gitignore::Gitignore;
 use log::{debug, error, info};
-use rustc_hash::FxBuildHasher;
+use oxc_linter::{ConfigStore, ConfigStoreBuilder, FixKind, LintOptions, Linter, Oxlintrc};
+use rustc_hash::{FxBuildHasher, FxHashMap};
 use serde::{Deserialize, Serialize};
 use tokio::sync::{Mutex, OnceCell, RwLock, SetError};
 use tower_lsp::{
@@ -15,14 +16,12 @@ use tower_lsp::{
         CodeAction, CodeActionKind, CodeActionOrCommand, CodeActionParams, CodeActionResponse,
         ConfigurationItem, Diagnostic, DidChangeConfigurationParams, DidChangeTextDocumentParams,
         DidChangeWatchedFilesParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams,
-        DidSaveTextDocumentParams, ExecuteCommandParams, InitializeParams, InitializeResult,
-        InitializedParams, NumberOrString, Position, Range, ServerInfo, TextEdit, Url,
-        WorkspaceEdit,
+        DidSaveTextDocumentParams, ExecuteCommandParams, FileChangeType, InitializeParams,
+        InitializeResult, InitializedParams, NumberOrString, Position, Range, ServerInfo, TextEdit,
+        Url, WorkspaceEdit,
     },
 };
 
-use oxc_linter::{ConfigStoreBuilder, FixKind, LintOptions, Linter, Oxlintrc};
-
 use crate::capabilities::{CODE_ACTION_KIND_SOURCE_FIX_ALL_OXC, Capabilities};
 use crate::linter::error_with_position::DiagnosticReport;
 use crate::linter::server_linter::ServerLinter;
@@ -33,13 +32,16 @@ mod linter;
 
 type ConcurrentHashMap<K, V> = papaya::HashMap<K, V, FxBuildHasher>;
 
+const OXC_CONFIG_FILE: &str = ".oxlintrc.json";
+
 struct Backend {
     client: Client,
     root_uri: OnceCell<Option<Url>>,
     server_linter: RwLock<ServerLinter>,
     diagnostics_report_map: ConcurrentHashMap<String, Vec<DiagnosticReport>>,
     options: Mutex<Options>,
     gitignore_glob: Mutex<Vec<Gitignore>>,
+    nested_configs: RwLock<FxHashMap<PathBuf, ConfigStore>>,
 }
 #[derive(Debug, Serialize, Deserialize, Default, PartialEq, PartialOrd, Clone, Copy)]
 #[serde(rename_all = "camelCase")]
@@ -54,11 +56,17 @@ struct Options {
     run: Run,
     enable: bool,
     config_path: String,
+    use_nested_configs: bool,
 }
 
 impl Default for Options {
     fn default() -> Self {
-        Self { enable: true, run: Run::default(), config_path: ".oxlintrc.json".into() }
+        Self {
+            enable: true,
+            run: Run::default(),
+            config_path: OXC_CONFIG_FILE.into(),
+            use_nested_configs: false,
+        }
     }
 }
 
@@ -180,8 +188,38 @@ impl LanguageServer for Backend {
         }
     }
 
-    async fn did_change_watched_files(&self, _params: DidChangeWatchedFilesParams) {
+    async fn did_change_watched_files(&self, params: DidChangeWatchedFilesParams) {
         debug!("watched file did change");
+        if self.options.lock().await.use_nested_configs {
+            let mut config_files = FxHashMap::default();
+            let existing_nested_configs = (*self.nested_configs.read().await).clone();
+            for (key, value) in existing_nested_configs {
+                config_files.insert(key.clone(), value.clone());
+            }
+
+            params.changes.iter().for_each(|x| {
+                if x.uri.to_file_path().unwrap().file_name().unwrap() != OXC_CONFIG_FILE {
+                    return;
+                }
+                // spellchecker:off -- "typ" is accurate
+                if x.typ == FileChangeType::CREATED || x.typ == FileChangeType::CHANGED {
+                    // spellchecker:on
+                    let file_path = x.uri.to_file_path().unwrap();
+                    let dir_path = file_path.parent().unwrap();
+                    let oxlintrc = Oxlintrc::from_file(&dir_path.join(OXC_CONFIG_FILE)).unwrap();
+                    let config_store_builder =
+                        ConfigStoreBuilder::from_oxlintrc(false, oxlintrc).unwrap();
+                    let config_store = config_store_builder.build().unwrap();
+                    config_files.insert(dir_path.to_path_buf(), config_store);
+                // spellchecker:off -- "typ" is accurate
+                } else if x.typ == FileChangeType::DELETED {
+                    // spellchecker:on
+                    config_files.remove(&x.uri.to_file_path().unwrap());
+                }
+            });
+            *self.nested_configs.write().await = config_files;
+        }
+
         self.init_linter_config().await;
         self.revalidate_open_files().await;
     }
@@ -492,21 +530,46 @@ impl Backend {
         if config.exists() {
             config_path = Some(config);
         }
+
+        let mut oxlintrc = None;
+        let mut config_store = None;
+        let mut linter = self.server_linter.write().await;
         if let Some(config_path) = config_path {
-            let mut linter = self.server_linter.write().await;
-            let config = Oxlintrc::from_file(&config_path)
-                .expect("should have initialized linter with new options");
-            let config_store = ConfigStoreBuilder::from_oxlintrc(true, config.clone())
-                .expect("failed to build config")
-                .build()
-                .expect("failed to build config");
+            oxlintrc = Some(
+                Oxlintrc::from_file(&config_path)
+                    .expect("should have initialized linter with new options"),
+            );
+            config_store = Some(
+                ConfigStoreBuilder::from_oxlintrc(true, oxlintrc.clone().unwrap())
+                    .expect("failed to build config")
+                    .build()
+                    .expect("failed to build config"),
+            );
+        }
+
+        if self.options.lock().await.use_nested_configs {
+            let mut config_files: FxHashMap<PathBuf, ConfigStore> = FxHashMap::default();
+            let existing_nested_configs = (*self.nested_configs.read().await).clone();
+            for (key, value) in existing_nested_configs {
+                config_files.insert(key.clone(), value.clone());
+            }
+
+            *linter = ServerLinter::new_with_linter(
+                Linter::new_with_nested_configs(
+                    LintOptions::default(),
+                    config_store.unwrap(),
+                    config_files,
+                )
+                .with_fix(FixKind::SafeFix),
+            );
+        } else {
             *linter = ServerLinter::new_with_linter(
-                Linter::new(LintOptions::default(), config_store).with_fix(FixKind::SafeFix),
+                Linter::new(LintOptions::default(), config_store.unwrap())
+                    .with_fix(FixKind::SafeFix),
             );
-            return Some(config);
         }
 
-        None
+        Some(oxlintrc.clone().unwrap())
     }
 
     async fn handle_file_update(&self, uri: Url, content: Option<String>, version: Option<i32>) {
@@ -568,6 +631,7 @@ async fn main() {
         diagnostics_report_map,
         options: Mutex::new(Options::default()),
         gitignore_glob: Mutex::new(vec![]),
+        nested_configs: RwLock::new(FxHashMap::default()),
     })
     .finish();
 

crates/oxc_linter/src/config/config_store.rs

@@ -19,7 +19,7 @@ impl Clone for ResolvedLinterState {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct Config {
     /// The basic linter state for this configuration.
     base: ResolvedLinterState,
@@ -29,7 +29,7 @@ struct Config {
 }
 
 /// Resolves a lint configuration for a given file, by applying overrides based on the file's path.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ConfigStore {
     base: Config,
 }

editors/vscode/client/Config.ts

@@ -8,6 +8,7 @@ export class Config implements ConfigInterface {
   private _trace!: TraceLevel;
   private _configPath!: string;
   private _binPath: string | undefined;
+  private _useNestedConfigs!: boolean;
 
   constructor() {
     this.refresh();
@@ -21,6 +22,7 @@ export class Config implements ConfigInterface {
     this._trace = conf.get<TraceLevel>('trace.server') || 'off';
     this._configPath = conf.get<string>('configPath') || '.oxlintrc.json';
     this._binPath = conf.get<string>('path.server');
+    this._useNestedConfigs = conf.get<boolean>('useNestedConfigs') ?? false;
   }
 
   get runTrigger(): Trigger {
@@ -78,11 +80,23 @@ export class Config implements ConfigInterface {
       .update('path.server', value);
   }
 
+  get useNestedConfigs(): boolean {
+    return this._useNestedConfigs;
+  }
+
+  updateUseNestedConfigs(value: boolean): PromiseLike<void> {
+    this._useNestedConfigs = value;
+    return workspace
+      .getConfiguration(Config._namespace)
+      .update('useNestedConfigs', value);
+  }
+
   public toLanguageServerConfig(): LanguageServerConfig {
     return {
       run: this.runTrigger,
       enable: this.enable,
       configPath: this.configPath,
+      useNestedConfigs: this.useNestedConfigs,
     };
   }
 }
@@ -91,6 +105,7 @@ interface LanguageServerConfig {
   configPath: string;
   enable: boolean;
   run: Trigger;
+  useNestedConfigs: boolean;
 }
 
 export type Trigger = 'onSave' | 'onType';

editors/vscode/client/config.spec.ts

@@ -5,7 +5,7 @@ import { Config } from './Config.js';
 suite('Config', () => {
   setup(async () => {
     const wsConfig = workspace.getConfiguration('oxc');
-    const keys = ['lint.run', 'enable', 'trace.server', 'configPath', 'path.server'];
+    const keys = ['lint.run', 'enable', 'trace.server', 'configPath', 'path.server', 'useNestedConfigs'];
 
     await Promise.all(keys.map(key => wsConfig.update(key, undefined)));
   });
@@ -18,6 +18,7 @@ suite('Config', () => {
     strictEqual(config.trace, 'off');
     strictEqual(config.configPath, '.oxlintrc.json');
     strictEqual(config.binPath, '');
+    strictEqual(config.useNestedConfigs, true);
   });
 
   test('updating values updates the workspace configuration', async () => {
@@ -29,6 +30,7 @@ suite('Config', () => {
       config.updateTrace('messages'),
       config.updateConfigPath('./somewhere'),
       config.updateBinPath('./binary'),
+      config.updateUseNestedConfigs(false),
     ]);
 
     const wsConfig = workspace.getConfiguration('oxc');
@@ -38,5 +40,6 @@ suite('Config', () => {
     strictEqual(wsConfig.get('trace.server'), 'messages');
     strictEqual(wsConfig.get('configPath'), './somewhere');
     strictEqual(wsConfig.get('path.server'), './binary');
+    strictEqual(wsConfig.get('useNestedConfigs'), false);
   });
 });

editors/vscode/client/extension.ts

@@ -1,8 +1,23 @@
 import { promises as fsPromises } from 'node:fs';
 
-import { commands, ExtensionContext, StatusBarAlignment, StatusBarItem, ThemeColor, window, workspace } from 'vscode';
+import {
+  commands,
+  ExtensionContext,
+  RelativePattern,
+  StatusBarAlignment,
+  StatusBarItem,
+  ThemeColor,
+  window,
+  workspace,
+} from 'vscode';
 
-import { ExecuteCommandRequest, MessageType, ShowMessageNotification } from 'vscode-languageclient';
+import {
+  DidChangeWatchedFilesNotification,
+  ExecuteCommandRequest,
+  FileChangeType,
+  MessageType,
+  ShowMessageNotification,
+} from 'vscode-languageclient';
 
 import { Executable, LanguageClient, LanguageClientOptions, ServerOptions } from 'vscode-languageclient/node';
 
@@ -12,6 +27,7 @@ import { ConfigService } from './ConfigService';
 const languageClientName = 'oxc';
 const outputChannelName = 'Oxc';
 const commandPrefix = 'oxc';
+const oxlintConfigFileGlob = '**/.oxlintrc.json';
 
 const enum OxcCommands {
   RestartServer = `${commandPrefix}.restartServer`,
@@ -98,6 +114,10 @@ export async function activate(context: ExtensionContext) {
     configService,
   );
 
+  const workspaceConfigPatterns = (workspace.workspaceFolders || []).map((workspaceFolder) =>
+    new RelativePattern(workspaceFolder, configService.config.configPath)
+  );
+
   const outputChannel = window.createOutputChannel(outputChannelName, { log: true });
 
   async function findBinary(): Promise<string> {
@@ -171,8 +191,10 @@ export async function activate(context: ExtensionContext) {
     synchronize: {
       // Notify the server about file config changes in the workspace
       fileEvents: [
-        workspace.createFileSystemWatcher('**/.oxlint{.json,rc.json}'),
-        workspace.createFileSystemWatcher('**/oxlint{.json,rc.json}'),
+        workspace.createFileSystemWatcher(oxlintConfigFileGlob),
+        ...workspaceConfigPatterns.map((workspaceConfigPattern) => {
+          return workspace.createFileSystemWatcher(workspaceConfigPattern);
+        }),
       ],
     },
     initializationOptions: {
@@ -242,7 +264,17 @@ export async function activate(context: ExtensionContext) {
     myStatusBarItem.backgroundColor = bgColor;
   }
   updateStatsBar(configService.config.enable);
-  client.start();
+  await client.start();
+
+  const initialConfigFiles =
+    (await Promise.all([oxlintConfigFileGlob, ...workspaceConfigPatterns].map(async globPattern => {
+      return workspace.findFiles(globPattern);
+    }))).flat();
+  await client.sendNotification(DidChangeWatchedFilesNotification.type, {
+    changes: initialConfigFiles.map(file => {
+      return { uri: file.toString(), type: FileChangeType.Created };
+    }),
+  });
 }
 
 export function deactivate(): Thenable<void> | undefined {

editors/vscode/package.json

@@ -104,6 +104,12 @@
           "type": "string",
           "scope": "window",
           "description": "Path to Oxc language server binary."
+        },
+        "oxc.useNestedConfigs": {
+          "type": "boolean",
+          "scope": "window",
+          "default": false,
+          "description": "Whether to enable experimental nested config resolution for Oxc."
         }
       }
     },
@@ -139,7 +145,7 @@
     "install-extension": "code --install-extension oxc_language_server.vsix --force",
     "server:build:debug": "cargo build -p oxc_language_server",
     "server:build:release": "cross-env CARGO_TARGET_DIR=./target cargo build -p oxc_language_server --release",
-    "lint": "npx oxlint --config=oxlint.json --tsconfig=tsconfig.json",
+    "lint": "npx oxlint --config=.oxlintrc.json --tsconfig=tsconfig.json",
     "test": "esbuild client/config.spec.ts --bundle --outfile=out/config.spec.js --external:vscode --format=cjs --platform=node --target=node16 --minify --sourcemap && vscode-test",
     "type-check": "tsc --noEmit"
   },