refactor(language_server): pass serde_json::Value to WorkspaceWorker configuration changes

Author: Sysix

crates/oxc_language_server/src/backend.rs

@@ -24,7 +24,7 @@ use crate::{
     commands::{FIX_ALL_COMMAND_ID, FixAllCommandArgs},
     file_system::LSPFileSystem,
     linter::options::Run,
-    options::{Options, WorkspaceOption},
+    options::WorkspaceOption,
     worker::WorkspaceWorker,
 };
 
@@ -73,23 +73,22 @@ impl LanguageServer for Backend {
     async fn initialize(&self, params: InitializeParams) -> Result<InitializeResult> {
         let server_version = env!("CARGO_PKG_VERSION");
         // initialization_options can be anything, so we are requesting `workspace/configuration` when no initialize options are provided
-        let options = params.initialization_options.and_then(|mut value| {
+        let options = params.initialization_options.and_then(|value| {
             // the client supports the new settings object
             if let Ok(new_settings) = serde_json::from_value::<Vec<WorkspaceOption>>(value.clone())
             {
                 // ToDo: validate they have the same length as params.workspace_folders
                 return Some(new_settings);
             }
 
-            let deprecated_settings =
-                serde_json::from_value::<Options>(value.get_mut("settings")?.take()).ok();
+            let deprecated_settings = value.get("settings");
 
             // the client has deprecated settings and has a deprecated root uri.
             // handle all things like the old way
             if deprecated_settings.is_some() && params.root_uri.is_some() {
                 return Some(vec![WorkspaceOption {
                     workspace_uri: params.root_uri.clone().unwrap(),
-                    options: deprecated_settings.unwrap(),
+                    options: deprecated_settings.unwrap().clone(),
                 }]);
             }
 
@@ -186,13 +185,11 @@ impl LanguageServer for Backend {
                 self.request_workspace_configuration(needed_configurations.keys().collect()).await
             } else {
                 // every worker should be initialized already in `initialize` request
-                vec![Some(Options::default()); needed_configurations.len()]
+                vec![serde_json::Value::Null; needed_configurations.len()]
             };
-            let default_options = Options::default();
 
             for (index, worker) in needed_configurations.values().enumerate() {
-                let configuration =
-                    configurations.get(index).unwrap_or(&None).as_ref().unwrap_or(&default_options);
+                let configuration = configurations.get(index).unwrap_or(&serde_json::Value::Null);
 
                 worker.start_worker(configuration).await;
             }
@@ -262,14 +259,12 @@ impl LanguageServer for Backend {
             .ok()
             .or_else(|| {
                 // fallback to old configuration
-                let options = serde_json::from_value::<Options>(params.settings).ok()?;
-
                 // for all workers (default only one)
                 let options = workers
                     .iter()
                     .map(|worker| WorkspaceOption {
                         workspace_uri: worker.get_root_uri().clone(),
-                        options: options.clone(),
+                        options: params.settings.clone(),
                     })
                     .collect();
 
@@ -295,12 +290,9 @@ impl LanguageServer for Backend {
             configs
                 .iter()
                 .enumerate()
-                // filter out results where the client did not return a configuration
-                .filter_map(|(index, config)| {
-                    config.as_ref().map(|options| WorkspaceOption {
-                        workspace_uri: workers[index].get_root_uri().clone(),
-                        options: options.clone(),
-                    })
+                .map(|(index, config)| WorkspaceOption {
+                    workspace_uri: workers[index].get_root_uri().clone(),
+                    options: config.clone(),
                 })
                 .collect::<Vec<_>>()
         } else {
@@ -423,8 +415,6 @@ impl LanguageServer for Backend {
 
         self.publish_all_diagnostics(&cleared_diagnostics).await;
 
-        let default_options = Options::default();
-
         // client support `workspace/configuration` request
         if self.capabilities.get().is_some_and(|capabilities| capabilities.workspace_configuration)
         {
@@ -437,9 +427,7 @@ impl LanguageServer for Backend {
             for (index, folder) in params.event.added.iter().enumerate() {
                 let worker = WorkspaceWorker::new(folder.uri.clone());
                 // get the configuration from the response and init the linter
-                let options = configurations.get(index).unwrap_or(&None);
-                let options = options.as_ref().unwrap_or(&default_options);
-
+                let options = configurations.get(index).unwrap_or(&serde_json::Value::Null);
                 worker.start_worker(options).await;
 
                 added_registrations.extend(worker.init_watchers().await);
@@ -450,7 +438,7 @@ impl LanguageServer for Backend {
             for folder in params.event.added {
                 let worker = WorkspaceWorker::new(folder.uri);
                 // use default options
-                worker.start_worker(&default_options).await;
+                worker.start_worker(&serde_json::Value::Null).await;
                 workers.push(worker);
             }
         }
@@ -675,7 +663,7 @@ impl Backend {
     /// Request the workspace configuration from the client
     /// and return the options for each workspace folder.
     /// The check if the client support workspace configuration, should be done before.
-    async fn request_workspace_configuration(&self, uris: Vec<&Uri>) -> Vec<Option<Options>> {
+    async fn request_workspace_configuration(&self, uris: Vec<&Uri>) -> Vec<serde_json::Value> {
         let length = uris.len();
         let config_items = uris
             .into_iter()
@@ -688,20 +676,15 @@ impl Backend {
         let Ok(configs) = self.client.configuration(config_items).await else {
             debug!("failed to get configuration");
             // return none for each workspace folder
-            return vec![None; length];
+            return vec![serde_json::Value::Null; length];
         };
 
-        let mut options = vec![];
-        for config in configs {
-            options.push(serde_json::from_value::<Options>(config).ok());
-        }
-
         debug_assert!(
-            options.len() == length,
+            configs.len() == length,
             "the number of configuration items should be the same as the number of workspace folders"
         );
 
-        options
+        configs
     }
 
     /// Clears all diagnostics for workspace folders

crates/oxc_language_server/src/formatter/server_formatter.rs

@@ -181,8 +181,10 @@ fn compute_minimal_text_edit<'a>(
 
 #[cfg(test)]
 mod tests {
+    use serde_json::json;
+
     use super::compute_minimal_text_edit;
-    use crate::formatter::{options::FormatOptions, tester::Tester};
+    use crate::formatter::tester::Tester;
 
     #[test]
     #[should_panic(expected = "assertion failed")]
@@ -269,7 +271,9 @@ mod tests {
     fn test_formatter() {
         Tester::new(
             "fixtures/formatter/basic",
-            Some(FormatOptions { experimental: true, ..Default::default() }),
+            json!({
+                "fmt.experimental": true
+            }),
         )
         .format_and_snapshot_single_file("basic.ts");
     }
@@ -278,7 +282,9 @@ mod tests {
     fn test_root_config_detection() {
         Tester::new(
             "fixtures/formatter/root_config",
-            Some(FormatOptions { experimental: true, ..Default::default() }),
+            json!({
+                "fmt.experimental": true
+            }),
         )
         .format_and_snapshot_single_file("semicolons-as-needed.ts");
     }
@@ -287,9 +293,9 @@ mod tests {
     fn test_custom_config_path() {
         Tester::new(
             "fixtures/formatter/custom_config_path",
-            Some(FormatOptions {
-                experimental: true,
-                config_path: Some("./format.json".to_string()),
+            json!({
+                "fmt.experimental": true,
+                "fmt.configPath": "./format.json",
             }),
         )
         .format_and_snapshot_single_file("semicolons-as-needed.ts");

crates/oxc_language_server/src/formatter/tester.rs

@@ -5,7 +5,7 @@ use tower_lsp_server::{
     lsp_types::{TextEdit, Uri},
 };
 
-use crate::{formatter::options::FormatOptions, options::Options, worker::WorkspaceWorker};
+use crate::worker::WorkspaceWorker;
 
 /// Given a file path relative to the crate root directory, return the absolute path of the file.
 pub fn get_file_path(relative_file_path: &str) -> PathBuf {
@@ -45,11 +45,11 @@ fn get_snapshot_from_text_edits(edits: &[TextEdit]) -> String {
 /// Testing struct for the [formatter server][crate::formatter::server_formatter::ServerFormatter].
 pub struct Tester<'t> {
     relative_root_dir: &'t str,
-    options: Option<FormatOptions>,
+    options: serde_json::Value,
 }
 
 impl Tester<'_> {
-    pub fn new(relative_root_dir: &'static str, options: Option<FormatOptions>) -> Self {
+    pub fn new(relative_root_dir: &'static str, options: serde_json::Value) -> Self {
         Self { relative_root_dir, options }
     }
 
@@ -59,9 +59,7 @@ 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);
-        let option =
-            &Options { format: self.options.clone().unwrap_or_default(), ..Default::default() };
-        worker.start_worker(option).await;
+        worker.start_worker(&self.options).await;
 
         worker
     }

crates/oxc_language_server/src/linter/options.rs

@@ -25,7 +25,9 @@ pub enum Run {
 #[serde(rename_all = "camelCase")]
 pub struct LintOptions {
     pub run: Run, // TODO: the client wants maybe only the formatter, make it optional
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub config_path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub ts_config_path: Option<String>,
     pub unused_disable_directives: UnusedDisableDirectives,
     pub type_aware: bool,