fix codegen, prettier, transformer

Author: overlookmotel

crates/oxc_codegen/src/gen.rs

@@ -2086,7 +2086,7 @@ impl GenExpr for ImportExpression<'_> {
             && (has_comment_before_right_paren
                 || p.has_comment(self.source.span().start)
                 || self
-                    .arguments
+                    .options
                     .first()
                     .is_some_and(|argument| p.has_comment(argument.span().start)));
 
@@ -2108,15 +2108,15 @@ impl GenExpr for ImportExpression<'_> {
                 p.print_indent();
             }
             self.source.print_expr(p, Precedence::Comma, Context::empty());
-            if !self.arguments.is_empty() {
+            if !self.options.is_empty() {
                 p.print_comma();
                 if has_comment {
                     p.print_soft_newline();
                     p.print_indent();
                 } else {
                     p.print_soft_space();
                 }
-                p.print_expressions(&self.arguments, Precedence::Comma, Context::empty());
+                p.print_expressions(&self.options, Precedence::Comma, Context::empty());
             }
             if has_comment {
                 // Handle `/* comment */);`

crates/oxc_prettier/src/format/print/call_arguments.rs

@@ -237,8 +237,8 @@ pub fn print_import_source_and_arguments<'a>(
     let mut indent_parts = Vec::new_in(p.allocator);
     indent_parts.push(softline!());
     indent_parts.push(expr.source.format(p));
-    if !expr.arguments.is_empty() {
-        for arg in &expr.arguments {
+    if !expr.options.is_empty() {
+        for arg in &expr.options {
             indent_parts.push(text!(","));
             indent_parts.push(line!());
             indent_parts.push(arg.format(p));
@@ -301,7 +301,7 @@ fn is_hopefully_short_call_argument(mut node: &Expression) -> bool {
         return !match node {
             Expression::CallExpression(call) => call.arguments.len() > 1,
             Expression::NewExpression(call) => call.arguments.len() > 1,
-            Expression::ImportExpression(call) => call.arguments.len() > 0,
+            Expression::ImportExpression(call) => call.options.len() > 0,
             _ => false,
         };
     }
@@ -350,7 +350,7 @@ fn is_simple_call_argument(node: &Expression, depth: usize) -> bool {
 
     if node.is_call_expression() {
         if let Expression::ImportExpression(expr) = node {
-            return expr.arguments.len() <= depth && expr.arguments.iter().all(is_child_simple);
+            return expr.options.len() <= depth && expr.options.iter().all(is_child_simple);
         } else if let Expression::CallExpression(expr) = node {
             if is_simple_call_argument(&expr.callee, depth) {
                 return expr.arguments.len() <= depth

crates/oxc_transformer/src/plugins/module_runner_transform.rs

@@ -255,15 +255,15 @@ impl<'a> ModuleRunnerTransform<'a> {
             unreachable!();
         };
 
-        let ImportExpression { span, source, arguments, .. } = import_expr.unbox();
+        let ImportExpression { span, source, options, .. } = import_expr.unbox();
 
         if let Expression::StringLiteral(source) = &source {
             self.dynamic_deps.push(source.value.to_string());
         }
 
         let flags = ReferenceFlags::Read;
         let callee = ctx.create_unbound_ident_expr(SPAN, SSR_DYNAMIC_IMPORT_KEY, flags);
-        let arguments = arguments.into_iter().map(Argument::from);
+        let arguments = options.into_iter().map(Argument::from);
         let arguments = ctx.ast.vec_from_iter(iter::once(Argument::from(source)).chain(arguments));
         *expr = ctx.ast.expression_call(span, callee, NONE, arguments, false);
     }