fix(formatter): don't print CallExpression as MemberChain style when its only has one argument and it is a TemplateLiteral on its own line

Author: Dunqing

crates/oxc_formatter/src/write/arrow_function_expression.rs

@@ -170,21 +170,9 @@ impl<'a> Format<'a> for FormatJsArrowFunctionExpression<'a, '_> {
                             true
                         }
                         Expression::JSXElement(_) | Expression::JSXFragment(_) => true,
-                        Expression::TemplateLiteral(template) => {
-                            is_multiline_template_starting_on_same_line(
-                                template.span.start,
-                                template,
-                                f.source_text(),
-                            )
+                        _ => {
+                            is_multiline_template_starting_on_same_line(expression, f.source_text())
                         }
-                        Expression::TaggedTemplateExpression(template) => {
-                            is_multiline_template_starting_on_same_line(
-                                template.span.start,
-                                &template.quasi,
-                                f.source_text(),
-                            )
-                        }
-                        _ => false,
                     }
                 });
 
@@ -392,10 +380,15 @@ impl<'a, 'b> ArrowFunctionLayout<'a, 'b> {
 ///
 /// Returns `false` because the template isn't on the same line as the '+' token.
 pub fn is_multiline_template_starting_on_same_line(
-    start: u32,
-    template: &TemplateLiteral,
+    expression: &Expression,
     source_text: SourceText,
 ) -> bool {
+    let (start, template) = match expression {
+        Expression::TemplateLiteral(template) => (template.span.start, template.as_ref()),
+        Expression::TaggedTemplateExpression(tagged) => (tagged.span.start, &tagged.quasi),
+        _ => return false,
+    };
+
     template.quasis.iter().any(|quasi| source_text.contains_newline(quasi.span))
         && !source_text.has_newline_before(start)
 }

crates/oxc_formatter/src/write/call_arguments.rs

@@ -959,19 +959,11 @@ fn is_multiline_template_only_args(arguments: &[Argument], source_text: SourceTe
         return false;
     }
 
-    match arguments.first().unwrap() {
-        Argument::TemplateLiteral(template) => {
-            is_multiline_template_starting_on_same_line(template.span.start, template, source_text)
-        }
-        Argument::TaggedTemplateExpression(template) => {
-            is_multiline_template_starting_on_same_line(
-                template.span.start,
-                &template.quasi,
-                source_text,
-            )
-        }
-        _ => false,
-    }
+    arguments
+        .first()
+        .unwrap()
+        .as_expression()
+        .is_some_and(|expr| is_multiline_template_starting_on_same_line(expr, source_text))
 }
 
 /// This function is used to check if the code is a hook-like code:

crates/oxc_formatter/src/write/mod.rs

@@ -78,6 +78,7 @@ use crate::{
 
 use self::{
     array_expression::FormatArrayExpression,
+    arrow_function_expression::is_multiline_template_starting_on_same_line,
     class::format_grouped_parameters_with_return_type,
     function::should_group_function_parameters,
     object_like::ObjectLike,
@@ -215,13 +216,20 @@ impl<'a> FormatWrite<'a> for AstNode<'a, CallExpression<'a>> {
         let arguments = self.arguments();
         let optional = self.optional();
 
-        if callee.as_member_expression().is_some_and(|e| {
-            matches!(
-                e,
-                MemberExpression::StaticMemberExpression(_)
-                    | MemberExpression::ComputedMemberExpression(_)
-            )
-        }) && !callee.needs_parentheses(f)
+        let is_template_literal_single_arg = arguments.len() == 1
+            && arguments.first().unwrap().as_expression().is_some_and(|expr| {
+                is_multiline_template_starting_on_same_line(expr, f.source_text())
+            });
+
+        if !is_template_literal_single_arg
+            && callee.as_member_expression().is_some_and(|e| {
+                matches!(
+                    e,
+                    MemberExpression::StaticMemberExpression(_)
+                        | MemberExpression::ComputedMemberExpression(_)
+                )
+            })
+            && !callee.needs_parentheses(f)
         {
             MemberChain::from_call_expression(self, f).fmt(f)
         } else {