[autofix.ci] apply automated fixes

Author: autofix-ci[bot]

Cargo.lock

@@ -27,7 +27,6 @@ oxc_diagnostics = { workspace = true }
 oxc_formatter = { workspace = true }
 oxc_linter = { workspace = true, features = ["language_server"] }
 oxc_parser = { workspace = true }
-oxc_span = { workspace = true }
 
 #
 env_logger = { workspace = true, features = ["humantime"] }

crates/oxc_language_server/Cargo.toml

@@ -21,7 +21,6 @@ impl LSPFileSystem {
         self.files.pin().insert(uri.clone(), content);
     }
 
-    #[expect(dead_code)] // used for the oxc_formatter in the future
     pub fn get(&self, uri: &Uri) -> Option<String> {
         self.files.pin().get(uri).cloned()
     }

crates/oxc_language_server/src/file_system.rs

@@ -1,5 +1,69 @@
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, de::Error};
+use serde_json::Value;
 
-#[derive(Debug, Default, Serialize, Deserialize, Clone)]
+#[derive(Debug, Default, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
-pub struct FormatOptions;
+pub struct FormatOptions {
+    pub experimental: bool,
+}
+
+impl<'de> Deserialize<'de> for FormatOptions {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = Value::deserialize(deserializer)?;
+        FormatOptions::try_from(value).map_err(Error::custom)
+    }
+}
+
+impl TryFrom<Value> for FormatOptions {
+    type Error = String;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        let Some(object) = value.as_object() else {
+            return Err("no object passed".to_string());
+        };
+
+        Ok(Self {
+            experimental: object
+                .get("fmt.experimental")
+                .is_some_and(|run| serde_json::from_value::<bool>(run.clone()).unwrap_or_default()),
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use serde_json::json;
+
+    use super::FormatOptions;
+
+    #[test]
+    fn test_valid_options_json() {
+        let json = json!({
+            "fmt.experimental": true,
+        });
+
+        let options = FormatOptions::try_from(json).unwrap();
+        assert!(options.experimental);
+    }
+
+    #[test]
+    fn test_empty_options_json() {
+        let json = json!({});
+
+        let options = FormatOptions::try_from(json).unwrap();
+        assert!(!options.experimental);
+    }
+
+    #[test]
+    fn test_invalid_options_json() {
+        let json = json!({
+            "fmt.experimental": "what", // should be bool
+        });
+
+        let options = FormatOptions::try_from(json).unwrap();
+        assert!(!options.experimental);
+    }
+}

crates/oxc_language_server/src/formatter/options.rs

@@ -16,10 +16,14 @@ impl ServerFormatter {
     }
 
     #[expect(clippy::unused_self)]
-    pub fn run_single(&self, uri: &Uri) -> Option<Vec<TextEdit>> {
+    pub fn run_single(&self, uri: &Uri, content: Option<String>) -> Option<Vec<TextEdit>> {
         let path = uri.to_file_path()?;
         let source_type = get_supported_source_type(&path)?;
-        let source_text = std::fs::read_to_string(path).expect("Failed to read file");
+        let source_text = if let Some(content) = content {
+            content
+        } else {
+            std::fs::read_to_string(&path).ok()?
+        };
 
         let allocator = Allocator::new();
         let ret = Parser::new(&allocator, &source_text, source_type)

crates/oxc_language_server/src/formatter/server_formatter.rs

@@ -167,8 +167,6 @@ impl LanguageServer for Backend {
             if worker.needs_init_linter().await {
                 needed_configurations.insert(worker.get_root_uri().clone(), worker);
             }
-            // ToDo: check for configuration
-            worker.init_formatter().await;
         }
 
         if !needed_configurations.is_empty() {
@@ -178,23 +176,21 @@ impl LanguageServer for Backend {
                 // every worker should be initialized already in `initialize` request
                 vec![Some(Options::default()); needed_configurations.len()]
             };
+            let default_options = Options::default();
 
             for (index, worker) in needed_configurations.values().enumerate() {
-                worker
-                    .init_linter(
-                        configurations
-                            .get(index)
-                            .unwrap_or(&None)
-                            .as_ref()
-                            .unwrap_or(&Options::default()),
-                    )
-                    .await;
+                let configuration =
+                    configurations.get(index).unwrap_or(&None).as_ref().unwrap_or(&default_options);
+
+                worker.init_linter(configuration).await;
+                worker.init_formatter(&configuration.format).await;
             }
         }
 
+        let mut registrations = vec![];
+
         // init all file watchers
         if capabilities.dynamic_watchers {
-            let mut registrations = vec![];
             for worker in workers {
                 registrations.push(Registration {
                     id: format!("watcher-{}", worker.get_root_uri().as_str()),
@@ -204,10 +200,21 @@ impl LanguageServer for Backend {
                     })),
                 });
             }
+        }
 
-            if let Err(err) = self.client.register_capability(registrations).await {
-                warn!("sending registerCapability.didChangeWatchedFiles failed: {err}");
-            }
+        if capabilities.dynamic_formatting {
+            registrations.push(Registration {
+                id: "dynamic-formatting".to_string(),
+                method: "textDocument/formatting".to_string(),
+                register_options: None,
+            });
+        }
+
+        if registrations.is_empty() {
+            return;
+        }
+        if let Err(err) = self.client.register_capability(registrations).await {
+            warn!("sending registerCapability.didChangeWatchedFiles failed: {err}");
         }
     }
 
@@ -410,11 +417,16 @@ impl LanguageServer for Backend {
                 )
                 .await;
 
+            let default_options = Options::default();
             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);
-                worker.init_linter(options.as_ref().unwrap_or(&Options::default())).await;
+                let options = options.as_ref().unwrap_or(&default_options);
+
+                worker.init_linter(options).await;
+                worker.init_formatter(&options.format).await;
+
                 added_registrations.push(Registration {
                     id: format!("watcher-{}", worker.get_root_uri().as_str()),
                     method: "workspace/didChangeWatchedFiles".to_string(),
@@ -603,7 +615,7 @@ impl LanguageServer for Backend {
         let Some(worker) = workers.iter().find(|worker| worker.is_responsible_for_uri(uri)) else {
             return Ok(None);
         };
-        Ok(worker.format_file(uri).await)
+        Ok(worker.format_file(uri, self.file_system.read().await.get(uri)).await)
     }
 }
 

crates/oxc_language_server/src/main.rs

@@ -34,6 +34,7 @@ mod test {
             "options": {
                 "run": true,
                 "configPath": "./custom.json",
+                "fmt.experimental": true
             }
         }]);
 
@@ -46,5 +47,6 @@ mod test {
         assert_eq!(options.lint.run, Run::OnType); // fallback
         assert_eq!(options.lint.config_path, Some("./custom.json".into()));
         assert!(options.lint.flags.is_empty());
+        assert!(options.format.experimental);
     }
 }

crates/oxc_language_server/src/options.rs

@@ -16,7 +16,7 @@ use crate::{
         apply_all_fix_code_action, apply_fix_code_actions, ignore_this_line_code_action,
         ignore_this_rule_code_action,
     },
-    formatter::server_formatter::ServerFormatter,
+    formatter::{options::FormatOptions, server_formatter::ServerFormatter},
     linter::{
         error_with_position::{DiagnosticReport, PossibleFixContent},
         options::LintOptions,
@@ -57,8 +57,11 @@ impl WorkspaceWorker {
         *self.server_linter.write().await = Some(ServerLinter::new(&self.root_uri, &options.lint));
     }
 
-    pub async fn init_formatter(&self) {
-        *self.server_formatter.write().await = Some(ServerFormatter::new());
+    pub async fn init_formatter(&self, options: &FormatOptions) {
+        if options.experimental {
+            debug!("experimental formatter enabled");
+            *self.server_formatter.write().await = Some(ServerFormatter::new());
+        }
     }
 
     // WARNING: start all programs (linter, formatter) before calling this function
@@ -156,12 +159,12 @@ impl WorkspaceWorker {
         server_linter.run_single(uri, content, run_type).await
     }
 
-    pub async fn format_file(&self, uri: &Uri) -> Option<Vec<TextEdit>> {
+    pub async fn format_file(&self, uri: &Uri, content: Option<String>) -> Option<Vec<TextEdit>> {
         let Some(server_formatter) = &*self.server_formatter.read().await else {
             return None;
         };
 
-        server_formatter.run_single(uri)
+        server_formatter.run_single(uri, content)
     }
 
     async fn revalidate_diagnostics(
@@ -327,6 +330,16 @@ impl WorkspaceWorker {
             *options_guard = changed_options.clone();
         }
 
+        if current_option.format.experimental != changed_options.format.experimental {
+            if changed_options.format.experimental {
+                debug!("experimental formatter enabled");
+                *self.server_formatter.write().await = Some(ServerFormatter::new());
+            } else {
+                debug!("experimental formatter disabled");
+                *self.server_formatter.write().await = None;
+            }
+        }
+
         if Self::needs_linter_restart(&current_option.lint, &changed_options.lint) {
             let files = {
                 let server_linter_guard = self.server_linter.read().await;