[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

@@ -40,20 +40,19 @@ impl From<ClientCapabilities> for Capabilities {
                 watched_files.dynamic_registration.is_some_and(|dynamic| dynamic)
             })
         });
-        // TODO: enable it when we support formatting
-        // let formatting = value.text_document.as_ref().is_some_and(|text_document| {
-        //     text_document.formatting.is_some_and(|formatting| {
-        //         formatting.dynamic_registration.is_some_and(|dynamic| dynamic)
-        //     })
-        // });
+        let dynamic_formatting = value.text_document.as_ref().is_some_and(|text_document| {
+            text_document.formatting.is_some_and(|formatting| {
+                formatting.dynamic_registration.is_some_and(|dynamic| dynamic)
+            })
+        });
 
         Self {
             code_action_provider,
             workspace_apply_edit,
             workspace_execute_command,
             workspace_configuration,
             dynamic_watchers,
-            dynamic_formatting: false,
+            dynamic_formatting,
         }
     }
 }
@@ -100,9 +99,8 @@ impl From<Capabilities> for ServerCapabilities {
             } else {
                 None
             },
-            // ToDo: should by dynamic registered with workspace configuration
-            // THIS MUST NOT BE COMMITTED TO MAIN!!!
-            document_formatting_provider: Some(OneOf::Left(true)),
+            // the server supports formatting, but it will tell the client if he enabled the setting
+            document_formatting_provider: None,
             ..ServerCapabilities::default()
         }
     }

crates/oxc_language_server/src/capabilities.rs

@@ -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)
@@ -37,11 +41,7 @@ impl ServerFormatter {
             return None;
         }
 
-        let options = FormatOptions {
-            // semicolons: "always".parse().unwrap(),
-            semicolons: "as-needed".parse().unwrap(),
-            ..FormatOptions::default()
-        };
+        let options = FormatOptions::default();
         let code = Formatter::new(&allocator, options).build(&ret.program);
 
         Some(vec![TextEdit::new(