refactor(oxfmt, formatter): clean up embedded formatter integration (#15937)

Aims to remove `embedded_formatter: Option<EmbeddedFormatter>` from the `Formatter` struct, which violates the `clippy::struct_field_names` rule.

Store the `embedded_formatter` in the `Formatter` is unnecessary because it is immediately passed into the FormatContext.

Author: Dunqing

apps/oxfmt/src/service.rs

@@ -4,7 +4,7 @@ use cow_utils::CowUtils;
 use rayon::prelude::*;
 
 use oxc_allocator::AllocatorPool;
-use oxc_diagnostics::{DiagnosticSender, DiagnosticService};
+use oxc_diagnostics::{DiagnosticSender, DiagnosticService, OxcDiagnostic};
 use oxc_formatter::{FormatOptions, Formatter, enable_jsx_source_type, get_parse_options};
 use oxc_parser::Parser;
 
@@ -93,24 +93,37 @@ impl FormatService {
         }
 
         let base_formatter = Formatter::new(&allocator, self.format_options.clone());
-        let formatter = if self.format_options.embedded_language_formatting.is_off() {
-            base_formatter
+        let formatted = if cfg!(not(feature = "napi"))
+            || self.format_options.embedded_language_formatting.is_off()
+            || self.external_formatter.is_none()
+        {
+            base_formatter.format(&ret.program)
         } else {
             #[cfg(feature = "napi")]
             {
-                let external_formatter = self
-                    .external_formatter
-                    .as_ref()
-                    .map(crate::prettier_plugins::ExternalFormatter::to_embedded_formatter);
-                base_formatter.with_embedded_formatter(external_formatter)
-            }
-            #[cfg(not(feature = "napi"))]
-            {
-                base_formatter
+                let Some(external_formatter) = &self.external_formatter else {
+                    unreachable!("Already checked above that external_formatter is Some");
+                };
+                let embedded_formatter = external_formatter.to_embedded_formatter();
+                base_formatter.format_with_embedded(&ret.program, embedded_formatter)
             }
         };
 
-        let code = formatter.build(&ret.program);
+        let code = match formatted.print() {
+            Ok(printed) => printed.into_code(),
+            Err(err) => {
+                let oxc_diagnostic =
+                    OxcDiagnostic::error(format!("Failed to print formatted code: {err}"));
+                let diagnostics = DiagnosticService::wrap_diagnostics(
+                    self.cwd.clone(),
+                    path,
+                    &source_text,
+                    vec![oxc_diagnostic],
+                );
+                tx_error.send(diagnostics).unwrap();
+                return;
+            }
+        };
 
         #[cfg(feature = "detect_code_removal")]
         {

crates/oxc_formatter/src/formatter/context.rs

@@ -52,6 +52,7 @@ impl<'ast> FormatContext<'ast> {
         comments: &'ast [Comment],
         allocator: &'ast Allocator,
         options: FormatOptions,
+        embedded_formatter: Option<EmbeddedFormatter>,
     ) -> Self {
         let source_text = SourceText::new(source_text);
         Self {
@@ -61,7 +62,7 @@ impl<'ast> FormatContext<'ast> {
             comments: Comments::new(source_text, comments),
             allocator,
             cached_elements: FxHashMap::default(),
-            embedded_formatter: None,
+            embedded_formatter,
         }
     }
 
@@ -77,11 +78,6 @@ impl<'ast> FormatContext<'ast> {
         }
     }
 
-    /// Set the embedded formatter for handling embedded languages
-    pub fn set_embedded_formatter(&mut self, embedded_formatter: Option<EmbeddedFormatter>) {
-        self.embedded_formatter = embedded_formatter;
-    }
-
     /// Get the embedded formatter if one is set
     pub fn embedded_formatter(&self) -> Option<&EmbeddedFormatter> {
         self.embedded_formatter.as_ref()

crates/oxc_formatter/src/lib.rs

@@ -50,22 +50,11 @@ pub struct Formatter<'a> {
     allocator: &'a Allocator,
     source_text: &'a str,
     options: FormatOptions,
-    embedded_formatter: Option<EmbeddedFormatter>,
 }
 
 impl<'a> Formatter<'a> {
     pub fn new(allocator: &'a Allocator, options: FormatOptions) -> Self {
-        Self { allocator, source_text: "", options, embedded_formatter: None }
-    }
-
-    /// Set the embedded formatter for handling embedded languages in templates
-    #[must_use]
-    pub fn with_embedded_formatter(
-        mut self,
-        embedded_formatter: Option<EmbeddedFormatter>,
-    ) -> Self {
-        self.embedded_formatter = embedded_formatter;
-        self
+        Self { allocator, source_text: "", options }
     }
 
     /// Formats the given AST `Program` and returns the formatted string.
@@ -74,7 +63,25 @@ impl<'a> Formatter<'a> {
         formatted.print().unwrap().into_code()
     }
 
-    pub fn format(mut self, program: &'a Program<'a>) -> Formatted<'a> {
+    #[inline]
+    pub fn format(self, program: &'a Program<'a>) -> Formatted<'a> {
+        self.format_impl(program, None)
+    }
+
+    #[inline]
+    pub fn format_with_embedded(
+        self,
+        program: &'a Program<'a>,
+        embedded_formatter: EmbeddedFormatter,
+    ) -> Formatted<'a> {
+        self.format_impl(program, Some(embedded_formatter))
+    }
+
+    pub fn format_impl(
+        mut self,
+        program: &'a Program<'a>,
+        embedded_formatter: Option<EmbeddedFormatter>,
+    ) -> Formatted<'a> {
         let parent = self.allocator.alloc(AstNodes::Dummy());
         let program_node = AstNode::new(program, parent, self.allocator);
 
@@ -89,8 +96,8 @@ impl<'a> Formatter<'a> {
             &program.comments,
             self.allocator,
             self.options,
+            embedded_formatter,
         );
-        context.set_embedded_formatter(self.embedded_formatter);
 
         let mut formatted = formatter::format(
             context,