chore(language_server): split options for linting and formatting

Sysix · Sysix · commit 097e4b44838b · 2025-09-09T20:09:56.000+02:00
diff --git a/crates/oxc_language_server/src/linter/server_linter.rs b/crates/oxc_language_server/src/linter/server_linter.rs
@@ -20,8 +20,8 @@ use crate::linter::{
     isolated_lint_handler::{IsolatedLintHandler, IsolatedLintHandlerOptions},
     tsgo_linter::TsgoLinter,
 };
-use crate::options::{Run, UnusedDisableDirectives};
-use crate::{ConcurrentHashMap, OXC_CONFIG_FILE, Options};
+use crate::options::{LintOptions as LSPLintOptions, Run, UnusedDisableDirectives};
+use crate::{ConcurrentHashMap, OXC_CONFIG_FILE};
 
 use super::config_walker::ConfigWalker;
 
@@ -80,7 +80,7 @@ impl ServerLinterDiagnostics {
 }
 
 impl ServerLinter {
-    pub fn new(root_uri: &Uri, options: &Options) -> Self {
+    pub fn new(root_uri: &Uri, options: &LSPLintOptions) -> Self {
         let root_path = root_uri.to_file_path().unwrap();
         let mut nested_ignore_patterns = Vec::new();
         let (nested_configs, mut extended_paths) =
@@ -186,7 +186,7 @@ impl ServerLinter {
     /// and insert them inside the nested configuration
     fn create_nested_configs(
         root_path: &Path,
-        options: &Options,
+        options: &LSPLintOptions,
         nested_ignore_patterns: &mut Vec<(Vec<String>, PathBuf)>,
     ) -> (ConcurrentHashMap<PathBuf, Config>, Vec<PathBuf>) {
         let mut extended_paths = Vec::new();
@@ -394,9 +394,8 @@ mod test {
     use std::path::{Path, PathBuf};
 
     use crate::{
-        Options,
         linter::server_linter::{ServerLinter, normalize_path},
-        options::Run,
+        options::{LintOptions, Run},
         tester::{Tester, get_file_path},
     };
     use rustc_hash::FxHashMap;
@@ -417,7 +416,7 @@ mod test {
         let mut nested_ignore_patterns = Vec::new();
         let (configs, _) = ServerLinter::create_nested_configs(
             Path::new("/root/"),
-            &Options { flags, ..Options::default() },
+            &LintOptions { flags, ..LintOptions::default() },
             &mut nested_ignore_patterns,
         );
 
@@ -429,7 +428,7 @@ mod test {
         let mut nested_ignore_patterns = Vec::new();
         let (configs, _) = ServerLinter::create_nested_configs(
             &get_file_path("fixtures/linter/init_nested_configs"),
-            &Options::default(),
+            &LintOptions::default(),
             &mut nested_ignore_patterns,
         );
         let configs = configs.pin();
@@ -448,7 +447,7 @@ mod test {
     fn test_lint_on_run_on_type_on_type() {
         Tester::new(
             "fixtures/linter/lint_on_run/on_type",
-            Some(Options { type_aware: true, run: Run::OnType, ..Default::default() }),
+            Some(LintOptions { type_aware: true, run: Run::OnType, ..Default::default() }),
         )
         .test_and_snapshot_single_file_with_run_type("on-type.ts", Run::OnType);
     }
@@ -458,7 +457,7 @@ mod test {
     fn test_lint_on_run_on_type_on_save() {
         Tester::new(
             "fixtures/linter/lint_on_run/on_save",
-            Some(Options { type_aware: true, run: Run::OnType, ..Default::default() }),
+            Some(LintOptions { type_aware: true, run: Run::OnType, ..Default::default() }),
         )
         .test_and_snapshot_single_file_with_run_type("on-save.ts", Run::OnSave);
     }
@@ -468,7 +467,7 @@ mod test {
     fn test_lint_on_run_on_save_on_type() {
         Tester::new(
             "fixtures/linter/lint_on_run/on_save",
-            Some(Options { type_aware: true, run: Run::OnSave, ..Default::default() }),
+            Some(LintOptions { type_aware: true, run: Run::OnSave, ..Default::default() }),
         )
         .test_and_snapshot_single_file_with_run_type("on-type.ts", Run::OnType);
     }
@@ -478,7 +477,7 @@ mod test {
     fn test_lint_on_run_on_save_on_save() {
         Tester::new(
             "fixtures/linter/lint_on_run/on_type",
-            Some(Options { type_aware: true, run: Run::OnSave, ..Default::default() }),
+            Some(LintOptions { type_aware: true, run: Run::OnSave, ..Default::default() }),
         )
         .test_and_snapshot_single_file_with_run_type("on-save.ts", Run::OnSave);
     }
@@ -553,12 +552,12 @@ mod test {
     fn test_multiple_suggestions() {
         Tester::new(
             "fixtures/linter/multiple_suggestions",
-            Some(Options {
+            Some(LintOptions {
                 flags: FxHashMap::from_iter([(
                     "fix_kind".to_string(),
                     "safe_fix_or_suggestion".to_string(),
                 )]),
-                ..Options::default()
+                ..Default::default()
             }),
         )
         .test_and_snapshot_single_file("forward_ref.ts");
@@ -569,7 +568,7 @@ mod test {
         use crate::options::UnusedDisableDirectives;
         Tester::new(
             "fixtures/linter/unused_disabled_directives",
-            Some(Options {
+            Some(LintOptions {
                 unused_disable_directives: UnusedDisableDirectives::Deny,
                 ..Default::default()
             }),
@@ -588,7 +587,7 @@ mod test {
     fn test_ts_alias() {
         Tester::new(
             "fixtures/linter/ts_path_alias",
-            Some(Options {
+            Some(LintOptions {
                 ts_config_path: Some("./deep/tsconfig.json".to_string()),
                 ..Default::default()
             }),
@@ -601,7 +600,7 @@ mod test {
     fn test_tsgo_lint() {
         let tester = Tester::new(
             "fixtures/linter/tsgolint",
-            Some(Options { type_aware: true, run: Run::OnSave, ..Default::default() }),
+            Some(LintOptions { type_aware: true, run: Run::OnSave, ..Default::default() }),
         );
         tester.test_and_snapshot_single_file("no-floating-promises/index.ts");
     }
diff --git a/crates/oxc_language_server/src/main.rs b/crates/oxc_language_server/src/main.rs
@@ -3,6 +3,7 @@ use std::{str::FromStr, sync::Arc};
 use futures::future::join_all;
 use log::{debug, info, warn};
 use rustc_hash::FxBuildHasher;
+use serde::Deserialize;
 use serde_json::json;
 use tokio::sync::{OnceCell, RwLock, SetError};
 use tower_lsp_server::{
@@ -64,7 +65,7 @@ impl LanguageServer for Backend {
                 return Some(new_settings);
             }
 
-            let deprecated_settings = Options::try_from(value.get_mut("settings")?.take()).ok();
+            let deprecated_settings = Options::deserialize(value.get_mut("settings")?.take()).ok();
 
             // the client has deprecated settings and has a deprecated root uri.
             // handle all things like the old way
diff --git a/crates/oxc_language_server/src/options.rs b/crates/oxc_language_server/src/options.rs
@@ -22,9 +22,18 @@ pub enum UnusedDisableDirectives {
     Deny,
 }
 
-#[derive(Debug, Default, Serialize, Clone)]
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct Options {
+    #[serde(flatten)]
+    pub lint: LintOptions,
+    #[serde(flatten)]
+    pub format: FormatOptions,
+}
+
+#[derive(Debug, Default, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct LintOptions {
     pub run: Run,
     pub config_path: Option<String>,
     pub ts_config_path: Option<String>,
@@ -33,7 +42,11 @@ pub struct Options {
     pub flags: FxHashMap<String, String>,
 }
 
-impl Options {
+#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct FormatOptions;
+
+impl LintOptions {
     pub fn use_nested_configs(&self) -> bool {
         !self.flags.contains_key("disable_nested_config") && self.config_path.is_none()
     }
@@ -54,17 +67,17 @@ impl Options {
     }
 }
 
-impl<'de> Deserialize<'de> for Options {
+impl<'de> Deserialize<'de> for LintOptions {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
         let value = Value::deserialize(deserializer)?;
-        Options::try_from(value).map_err(Error::custom)
+        LintOptions::try_from(value).map_err(Error::custom)
     }
 }
 
-impl TryFrom<Value> for Options {
+impl TryFrom<Value> for LintOptions {
     type Error = String;
 
     fn try_from(value: Value) -> Result<Self, Self::Error> {
@@ -124,7 +137,9 @@ mod test {
     use rustc_hash::FxHashMap;
     use serde_json::json;
 
-    use super::{Options, Run, UnusedDisableDirectives, WorkspaceOption};
+    use crate::options::LintOptions;
+
+    use super::{Run, UnusedDisableDirectives, WorkspaceOption};
 
     #[test]
     fn test_valid_options_json() {
@@ -139,7 +154,7 @@ mod test {
             }
         });
 
-        let options = Options::try_from(json).unwrap();
+        let options = LintOptions::try_from(json).unwrap();
         assert_eq!(options.run, Run::OnSave);
         assert_eq!(options.config_path, Some("./custom.json".into()));
         assert_eq!(options.unused_disable_directives, UnusedDisableDirectives::Warn);
@@ -152,7 +167,7 @@ mod test {
     fn test_empty_options_json() {
         let json = json!({});
 
-        let options = Options::try_from(json).unwrap();
+        let options = LintOptions::try_from(json).unwrap();
         assert_eq!(options.run, Run::OnType);
         assert_eq!(options.config_path, None);
         assert_eq!(options.unused_disable_directives, UnusedDisableDirectives::Allow);
@@ -167,7 +182,7 @@ mod test {
             "configPath": "./custom.json"
         });
 
-        let options = Options::try_from(json).unwrap();
+        let options = LintOptions::try_from(json).unwrap();
         assert_eq!(options.run, Run::OnType); // fallback
         assert_eq!(options.config_path, Some("./custom.json".into()));
         assert!(options.flags.is_empty());
@@ -183,7 +198,7 @@ mod test {
             }
         });
 
-        let options = Options::try_from(json).unwrap();
+        let options = LintOptions::try_from(json).unwrap();
         assert_eq!(options.run, Run::OnType); // fallback
         assert_eq!(options.config_path, Some("./custom.json".into()));
         assert_eq!(options.flags.get("disable_nested_config"), None);
@@ -206,24 +221,24 @@ mod test {
         assert_eq!(workspace[0].workspace_uri.path().as_str(), "/root/");
 
         let options = &workspace[0].options;
-        assert_eq!(options.run, Run::OnType); // fallback
-        assert_eq!(options.config_path, Some("./custom.json".into()));
-        assert!(options.flags.is_empty());
+        assert_eq!(options.lint.run, Run::OnType); // fallback
+        assert_eq!(options.lint.config_path, Some("./custom.json".into()));
+        assert!(options.lint.flags.is_empty());
     }
 
     #[test]
     fn test_use_nested_configs() {
-        let options = Options::default();
+        let options = LintOptions::default();
         assert!(options.use_nested_configs());
 
         let options =
-            Options { config_path: Some("config.json".to_string()), ..Default::default() };
+            LintOptions { config_path: Some("config.json".to_string()), ..Default::default() };
         assert!(!options.use_nested_configs());
 
         let mut flags = FxHashMap::default();
         flags.insert("disable_nested_config".to_string(), "true".to_string());
 
-        let options = Options { flags, ..Default::default() };
+        let options = LintOptions { flags, ..Default::default() };
         assert!(!options.use_nested_configs());
     }
 }
diff --git a/crates/oxc_language_server/src/tester.rs b/crates/oxc_language_server/src/tester.rs
@@ -6,7 +6,10 @@ use tower_lsp_server::{
 };
 
 use crate::{
-    Options, linter::server_linter::ServerLinterRun, options::Run, worker::WorkspaceWorker,
+    Options,
+    linter::server_linter::ServerLinterRun,
+    options::{LintOptions, Run},
+    worker::WorkspaceWorker,
 };
 
 use super::linter::error_with_position::DiagnosticReport;
@@ -94,11 +97,11 @@ fixed: {fixed:?}
 /// Testing struct for the [linter server][crate::linter::server_linter::ServerLinter].
 pub struct Tester<'t> {
     relative_root_dir: &'t str,
-    options: Option<Options>,
+    options: Option<LintOptions>,
 }
 
 impl Tester<'_> {
-    pub fn new(relative_root_dir: &'static str, options: Option<Options>) -> Self {
+    pub fn new(relative_root_dir: &'static str, options: Option<LintOptions>) -> Self {
         Self { relative_root_dir, options }
     }
 
@@ -108,7 +111,12 @@ impl Tester<'_> {
             .join(self.relative_root_dir);
         let uri = Uri::from_file_path(absolute_path).expect("could not convert current dir to uri");
         let worker = WorkspaceWorker::new(uri);
-        worker.init_linter(&self.options.clone().unwrap_or_default()).await;
+        worker
+            .init_linter(&Options {
+                lint: self.options.clone().unwrap_or_default(),
+                ..Default::default()
+            })
+            .await;
 
         worker
     }
diff --git a/crates/oxc_language_server/src/worker.rs b/crates/oxc_language_server/src/worker.rs
@@ -20,6 +20,7 @@ use crate::{
         error_with_position::{DiagnosticReport, PossibleFixContent},
         server_linter::{ServerLinter, ServerLinterRun, normalize_path},
     },
+    options::LintOptions,
 };
 
 pub struct WorkspaceWorker {
@@ -46,7 +47,7 @@ impl WorkspaceWorker {
 
     pub async fn init_linter(&self, options: &Options) {
         *self.options.lock().await = options.clone();
-        *self.server_linter.write().await = Some(ServerLinter::new(&self.root_uri, options));
+        *self.server_linter.write().await = Some(ServerLinter::new(&self.root_uri, &options.lint));
     }
 
     // WARNING: start all programs (linter, formatter) before calling this function
@@ -56,13 +57,14 @@ impl WorkspaceWorker {
 
         // clone the options to avoid locking the mutex
         let options = self.options.lock().await;
-        let use_nested_configs = options.use_nested_configs();
+        let use_nested_configs = options.lint.use_nested_configs();
 
         // append the base watcher
         watchers.push(FileSystemWatcher {
             glob_pattern: GlobPattern::Relative(RelativePattern {
                 base_uri: OneOf::Right(self.root_uri.clone()),
                 pattern: options
+                    .lint
                     .config_path
                     .as_ref()
                     .unwrap_or(&"**/.oxlintrc.json".to_owned())
@@ -115,12 +117,12 @@ impl WorkspaceWorker {
 
     async fn refresh_server_linter(&self) {
         let options = self.options.lock().await;
-        let server_linter = ServerLinter::new(&self.root_uri, &options);
+        let server_linter = ServerLinter::new(&self.root_uri, &options.lint);
 
         *self.server_linter.write().await = Some(server_linter);
     }
 
-    fn needs_linter_restart(old_options: &Options, new_options: &Options) -> bool {
+    fn needs_linter_restart(old_options: &LintOptions, new_options: &LintOptions) -> bool {
         old_options.config_path != new_options.config_path
             || old_options.ts_config_path != new_options.ts_config_path
             || old_options.use_nested_configs() != new_options.use_nested_configs()
@@ -306,7 +308,7 @@ impl WorkspaceWorker {
             *options_guard = changed_options.clone();
         }
 
-        if Self::needs_linter_restart(&current_option, changed_options) {
+        if Self::needs_linter_restart(&current_option.lint, &changed_options.lint) {
             let files = {
                 let server_linter_guard = self.server_linter.read().await;
                 let server_linter = server_linter_guard.as_ref();
@@ -318,13 +320,14 @@ impl WorkspaceWorker {
             };
             self.refresh_server_linter().await;
 
-            if current_option.config_path != changed_options.config_path {
+            if current_option.lint.config_path != changed_options.lint.config_path {
                 return (
                     Some(self.revalidate_diagnostics(files).await),
                     Some(FileSystemWatcher {
                         glob_pattern: GlobPattern::Relative(RelativePattern {
                             base_uri: OneOf::Right(self.root_uri.clone()),
                             pattern: changed_options
+                                .lint
                                 .config_path
                                 .as_ref()
                                 .unwrap_or(&"**/.oxlintrc.json".to_string())
