[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(

crates/oxc_language_server/src/formatter/server_formatter.rs

@@ -114,19 +114,19 @@ impl LanguageServer for Backend {
         // we will init the linter after requesting for the workspace configuration.
         if !capabilities.workspace_configuration || options.is_some() {
             for worker in &workers {
-                worker
-                    .init_linter(
-                        &options
-                            .clone()
-                            .unwrap_or_default()
-                            .iter()
-                            .find(|workspace_option| {
-                                worker.is_responsible_for_uri(&workspace_option.workspace_uri)
-                            })
-                            .map(|workspace_options| workspace_options.options.clone())
-                            .unwrap_or_default(),
-                    )
-                    .await;
+                let option = &options
+                    .clone()
+                    .unwrap_or_default()
+                    .iter()
+                    .find(|workspace_option| {
+                        worker.is_responsible_for_uri(&workspace_option.workspace_uri)
+                    })
+                    .map(|workspace_options| workspace_options.options.clone())
+                    .unwrap_or_default();
+
+                worker.init_options(option).await;
+                worker.init_linter(&option.lint).await;
+                worker.init_formatter(&option.format).await;
             }
         }
 
@@ -164,11 +164,9 @@ impl LanguageServer for Backend {
             ConcurrentHashMap::with_capacity_and_hasher(workers.len(), FxBuildHasher);
         let needed_configurations = needed_configurations.pin_owned();
         for worker in workers {
-            if worker.needs_init_linter().await {
+            if worker.needs_init_linter().await || worker.needs_init_formatter().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,22 @@ 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_options(configuration).await;
+                worker.init_linter(&configuration.lint).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,11 +201,33 @@ impl LanguageServer for Backend {
                     })),
                 });
             }
+        }
 
-            if let Err(err) = self.client.register_capability(registrations).await {
-                warn!("sending registerCapability.didChangeWatchedFiles failed: {err}");
+        if capabilities.dynamic_formatting {
+            // check if one workspace has formatting enabled
+            let mut started_worker = false;
+            for worker in workers {
+                if !worker.needs_init_formatter().await {
+                    started_worker = true;
+                    break;
+                }
+            }
+
+            if started_worker {
+                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}");
+        }
     }
 
     async fn shutdown(&self) -> Result<()> {
@@ -279,14 +298,26 @@ impl LanguageServer for Backend {
             return;
         };
 
+        let mut global_formatting_added = false;
+        let mut global_formatting_removed = false;
+
         for option in resolved_options {
             let Some(worker) =
                 workers.iter().find(|worker| worker.is_responsible_for_uri(&option.workspace_uri))
             else {
                 continue;
             };
 
-            let (diagnostics, watcher) = worker.did_change_configuration(&option.options).await;
+            let (diagnostics, watcher, formatting) =
+                worker.did_change_configuration(&option.options).await;
+
+            if self.capabilities.get().is_some_and(|c| c.dynamic_formatting) {
+                if Some(true) == formatting {
+                    global_formatting_added = true;
+                } else if Some(false) == formatting {
+                    global_formatting_removed = true;
+                }
+            }
 
             if let Some(diagnostics) = diagnostics {
                 for (uri, reports) in &diagnostics.pin() {
@@ -297,7 +328,9 @@ impl LanguageServer for Backend {
                 }
             }
 
-            if let Some(watcher) = watcher {
+            if let Some(watcher) = watcher
+                && self.capabilities.get().is_some_and(|capabilities| capabilities.dynamic_watchers)
+            {
                 // remove the old watcher
                 removing_registrations.push(Unregistration {
                     id: format!("watcher-{}", worker.get_root_uri().as_str()),
@@ -324,16 +357,27 @@ impl LanguageServer for Backend {
             self.publish_all_diagnostics(x).await;
         }
 
-        if self.capabilities.get().is_some_and(|capabilities| capabilities.dynamic_watchers) {
-            if !removing_registrations.is_empty() {
-                if let Err(err) = self.client.unregister_capability(removing_registrations).await {
-                    warn!("sending unregisterCapability.didChangeWatchedFiles failed: {err}");
-                }
+        if global_formatting_added {
+            adding_registrations.push(Registration {
+                id: "dynamic-formatting".to_string(),
+                method: "textDocument/formatting".to_string(),
+                register_options: None,
+            });
+        } else if global_formatting_removed {
+            removing_registrations.push(Unregistration {
+                id: "dynamic-formatting".to_string(),
+                method: "textDocument/formatting".to_string(),
+            });
+        }
+
+        if !removing_registrations.is_empty() {
+            if let Err(err) = self.client.unregister_capability(removing_registrations).await {
+                warn!("sending unregisterCapability.didChangeWatchedFiles failed: {err}");
             }
-            if !adding_registrations.is_empty() {
-                if let Err(err) = self.client.register_capability(adding_registrations).await {
-                    warn!("sending registerCapability.didChangeWatchedFiles failed: {err}");
-                }
+        }
+        if !adding_registrations.is_empty() {
+            if let Err(err) = self.client.register_capability(adding_registrations).await {
+                warn!("sending registerCapability.didChangeWatchedFiles failed: {err}");
             }
         }
     }
@@ -401,6 +445,8 @@ 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)
         {
@@ -414,7 +460,12 @@ impl LanguageServer for Backend {
                 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_options(options).await;
+                worker.init_linter(&options.lint).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(),
@@ -429,7 +480,9 @@ impl LanguageServer for Backend {
             for folder in params.event.added {
                 let worker = WorkspaceWorker::new(folder.uri);
                 // use default options
-                worker.init_linter(&Options::default()).await;
+                worker.init_options(&default_options).await;
+                worker.init_linter(&default_options.lint).await;
+                worker.init_formatter(&default_options.format).await;
                 workers.push(worker);
             }
         }
@@ -603,7 +656,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)
     }
 }