feat(formatter): reimplement formatting for ImportExpression (#14712)

The formatting logic of `arguments` in `ImportExpression` and `CallExpression` is the same, but our AST differs between these two nodes. Previously, I tried to pick up some logic from `CallExpression` to `ImportExpression` to cover most cases. However, it turns out that it isn't covered very well. In this PR, I tried to convert `ImportExpression`'s `source` and `options` to `AstNode<Vec<Argument>` with a tricky unsafe transmute so that it matches the Prettier behavior.

Author: Dunqing

crates/oxc_formatter/src/ast_nodes/node.rs

@@ -1,8 +1,11 @@
 use core::fmt;
-use std::ops::Deref;
+use std::{
+    mem::{transmute, transmute_copy},
+    ops::Deref,
+};
 
-use oxc_allocator::Allocator;
-use oxc_ast::ast::{ExpressionStatement, Program};
+use oxc_allocator::{Allocator, Vec};
+use oxc_ast::ast::*;
 use oxc_span::{GetSpan, Span};
 
 use super::AstNodes;
@@ -124,3 +127,46 @@ impl<'a> AstNode<'a, ExpressionStatement<'a>> {
         matches!(self.parent.parent(), AstNodes::ArrowFunctionExpression(arrow) if arrow.expression)
     }
 }
+
+impl<'a> AstNode<'a, ImportExpression<'a>> {
+    /// Converts the arguments of the ImportExpression into an `AstNode` representing a `Vec` of `Argument`.
+    #[inline]
+    pub fn to_arguments(&self) -> &AstNode<'a, Vec<'a, Argument<'a>>> {
+        // Convert ImportExpression's source and options to Vec<'a, Argument<'a>>.
+        // This allows us to reuse CallExpression's argument formatting logic when printing
+        // import expressions, since import(source, options) has the same structure as
+        // a function call with arguments.
+        let mut arguments = Vec::new_in(self.allocator);
+
+        // SAFETY: Argument inherits all Expression variants through the inherit_variants! macro,
+        // so Expression and Argument have identical memory layout for shared variants.
+        // Both are discriminated unions where each Expression variant (e.g., Expression::Identifier)
+        // has a corresponding Argument variant (e.g., Argument::Identifier) with the same discriminant
+        // and the same inner type (Box<'a, T>). Transmuting Expression to Argument via transmute_copy
+        // is safe because we're just copying the bits (discriminant + pointer).
+        unsafe {
+            arguments.push(transmute_copy(&self.inner.source));
+            if let Some(ref options) = self.inner.options {
+                arguments.push(transmute_copy(options));
+            }
+        }
+
+        let arguments_ref = self.allocator.alloc(arguments);
+        let following_span = self.following_span;
+
+        self.allocator.alloc(AstNode {
+            inner: arguments_ref,
+            allocator: self.allocator,
+            parent: self.allocator.alloc(AstNodes::ImportExpression({
+                /// * SAFETY: `self` is already allocated in Arena, so transmute from `&` to `&'a` is safe.
+                unsafe {
+                    transmute::<
+                        &AstNode<'_, ImportExpression<'_>>,
+                        &'a AstNode<'a, ImportExpression<'a>>,
+                    >(self)
+                }
+            })),
+            following_span,
+        })
+    }
+}

crates/oxc_formatter/src/write/call_arguments.rs

@@ -193,6 +193,7 @@ pub fn is_function_composition_args(args: &[Argument<'_>]) -> bool {
 }
 
 fn format_all_elements_broken_out<'a, 'b>(
+    node: &'b AstNode<'a, ArenaVec<'a, Argument<'a>>>,
     elements: impl Iterator<Item = (FormatResult<Option<FormatElement<'a>>>, usize)>,
     expand: bool,
     mut buffer: impl Buffer<'a>,
@@ -215,7 +216,11 @@ fn format_all_elements_broken_out<'a, 'b>(
                     }
                 }
 
-                write!(f, FormatTrailingCommas::All)
+                write!(
+                    f,
+                    [(!matches!(node.parent, AstNodes::ImportExpression(_)))
+                        .then_some(FormatTrailingCommas::All)]
+                )
             })),
             ")",
         ))
@@ -245,7 +250,11 @@ fn format_all_args_broken_out<'a, 'b>(
                     write!(f, [argument, (index != last_index).then_some(",")])?;
                 }
 
-                write!(f, FormatTrailingCommas::All)
+                write!(
+                    f,
+                    [(!matches!(node.parent, AstNodes::ImportExpression(_)))
+                        .then_some(FormatTrailingCommas::All)]
+                )
             })),
             ")",
         ))
@@ -641,7 +650,7 @@ fn write_grouped_arguments<'a>(
     // If any of the not grouped elements break, then fall back to the variant where
     // all arguments are printed in expanded mode.
     if non_grouped_breaks {
-        return format_all_elements_broken_out(elements.into_iter(), true, f);
+        return format_all_elements_broken_out(node, elements.into_iter(), true, f);
     }
 
     // We now cache the delimiter tokens. This is needed because `[crate::best_fitting]` will try to
@@ -654,7 +663,7 @@ fn write_grouped_arguments<'a>(
         let mut buffer = VecBuffer::new(f.state_mut());
         buffer.write_element(FormatElement::Tag(Tag::StartEntry))?;
 
-        format_all_elements_broken_out(elements.iter().cloned(), true, &mut buffer);
+        format_all_elements_broken_out(node, elements.iter().cloned(), true, &mut buffer);
 
         buffer.write_element(FormatElement::Tag(Tag::EndEntry))?;
 

crates/oxc_formatter/src/write/import_expression.rs

@@ -1,3 +1,4 @@
+use oxc_allocator::Vec;
 use oxc_ast::ast::*;
 
 use crate::{
@@ -17,63 +18,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, ImportExpression<'a>> {
             write!(f, [".", phase.as_str()])?;
         }
 
-        // The formatting implementation of `source` and `options` picks from `call_arguments`.
-        if self.options.is_none()
-            && (!matches!(
-                self.source,
-                Expression::StringLiteral(_)
-                    | Expression::TemplateLiteral(_)
-                    // Theoretically dynamic import shouldn't have this.
-                    | Expression::TaggedTemplateExpression(_)
-            ) || f.comments().has_comment_before(self.span.end))
-        {
-            return write!(
-                f,
-                [
-                    "(",
-                    group(&soft_block_indent(&format_once(|f| {
-                        write!(f, [self.source()])?;
-                        if let Some(options) = self.options() {
-                            write!(
-                                f,
-                                [
-                                    ",",
-                                    soft_line_break_or_space(),
-                                    group(&options).should_expand(true)
-                                ]
-                            )?;
-                        }
-                        Ok(())
-                    }))),
-                    ")"
-                ]
-            );
-        }
-
-        let source = self.source().memoized();
-        let options = self.options().memoized();
-
-        best_fitting![
-            group(&format_once(|f| {
-                write!(f, ["(", source])?;
-                if self.options().is_some() {
-                    write!(f, [",", space(), group(&options).should_expand(true)])?;
-                }
-                write!(f, ")")
-            })),
-            group(&format_args!(
-                "(",
-                &soft_block_indent(&format_once(|f| {
-                    write!(f, [source])?;
-                    if self.options.is_some() {
-                        write!(f, [",", soft_line_break_or_space(), options])?;
-                    }
-                    Ok(())
-                })),
-                ")"
-            ))
-            .should_expand(true),
-        ]
-        .fmt(f)
+        // Use the same logic as CallExpression arguments formatting
+        write!(f, self.to_arguments())
     }
 }

crates/oxc_formatter/tests/fixtures/js/comments/import-expression.js

@@ -0,0 +1,13 @@
+import(
+  // comment1
+  `../alias/${base}.js`
+  // comment2
+);
+
+import(
+  // comment1
+  `../alias/${base}.js`,
+  // comment2
+  { with: { type: "json" }}
+  // comment2
+);

crates/oxc_formatter/tests/fixtures/js/comments/import-expression.js.snap

@@ -0,0 +1,34 @@
+---
+source: crates/oxc_formatter/tests/fixtures/mod.rs
+---
+==================== Input ====================
+import(
+  // comment1
+  `../alias/${base}.js`
+  // comment2
+);
+
+import(
+  // comment1
+  `../alias/${base}.js`,
+  // comment2
+  { with: { type: "json" }}
+  // comment2
+);
+
+==================== Output ====================
+import(
+  // comment1
+  `../alias/${base}.js`
+  // comment2
+);
+
+import(
+  // comment1
+  `../alias/${base}.js`,
+  // comment2
+  { with: { type: "json" } }
+  // comment2
+);
+
+===================== End =====================

crates/oxc_formatter/tests/fixtures/js/import-expressions/grouped.js

@@ -0,0 +1,6 @@
+const fixturePackageJson = (
+  await import(
+    pathToFileURL(path.join(fixtureDir, 'package.json')).href,
+    { with: { type: 'json' } }
+  )
+).default;

crates/oxc_formatter/tests/fixtures/js/import-expressions/grouped.js.snap

@@ -0,0 +1,19 @@
+---
+source: crates/oxc_formatter/tests/fixtures/mod.rs
+---
+==================== Input ====================
+const fixturePackageJson = (
+  await import(
+    pathToFileURL(path.join(fixtureDir, 'package.json')).href,
+    { with: { type: 'json' } }
+  )
+).default;
+
+==================== Output ====================
+const fixturePackageJson = (
+  await import(pathToFileURL(path.join(fixtureDir, "package.json")).href, {
+    with: { type: "json" },
+  })
+).default;
+
+===================== End =====================