feat(formatter): complete printing JSX-related nodes

Author: Dunqing

crates/oxc_formatter/examples/formatter.rs

@@ -13,7 +13,7 @@
 use std::{fs, path::Path};
 
 use oxc_allocator::Allocator;
-use oxc_formatter::{FormatOptions, Formatter};
+use oxc_formatter::{BracketSameLine, FormatOptions, Formatter};
 use oxc_parser::{ParseOptions, Parser};
 use oxc_span::SourceType;
 use pico_args::Arguments;
@@ -46,7 +46,8 @@ fn main() -> Result<(), String> {
     }
 
     // Format the parsed code
-    let options = FormatOptions::default();
+    let options =
+        FormatOptions { bracket_same_line: BracketSameLine::from(true), ..Default::default() };
     let code = Formatter::new(&allocator, options).build(&ret.program);
 
     println!("{code}");

crates/oxc_formatter/src/generated/format.rs

@@ -1259,9 +1259,14 @@ impl<'a> Format<'a> for AstNode<'a, RegExpLiteral<'a>> {
 
 impl<'a> Format<'a> for AstNode<'a, JSXElement<'a>> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
-        self.format_leading_comments(f)?;
+        let needs_parentheses = self.needs_parentheses(f);
+        if needs_parentheses {
+            "(".fmt(f)?;
+        }
         let result = self.write(f);
-        self.format_trailing_comments(f)?;
+        if needs_parentheses {
+            ")".fmt(f)?;
+        }
         result
     }
 }
@@ -1286,9 +1291,14 @@ impl<'a> Format<'a> for AstNode<'a, JSXClosingElement<'a>> {
 
 impl<'a> Format<'a> for AstNode<'a, JSXFragment<'a>> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
-        self.format_leading_comments(f)?;
+        let needs_parentheses = self.needs_parentheses(f);
+        if needs_parentheses {
+            "(".fmt(f)?;
+        }
         let result = self.write(f);
-        self.format_trailing_comments(f)?;
+        if needs_parentheses {
+            ")".fmt(f)?;
+        }
         result
     }
 }

crates/oxc_formatter/src/parentheses/expression.rs

@@ -51,8 +51,8 @@ impl<'a> NeedsParentheses<'a> for AstNode<'a, Expression<'a>> {
             AstNodes::UpdateExpression(it) => it.needs_parentheses(f),
             AstNodes::YieldExpression(it) => it.needs_parentheses(f),
             AstNodes::PrivateInExpression(it) => it.needs_parentheses(f),
-            // AstNodes::JSXElement(it) => it.needs_parentheses(f),
-            // AstNodes::JSXFragment(it) => it.needs_parentheses(f),
+            AstNodes::JSXElement(it) => it.needs_parentheses(f),
+            AstNodes::JSXFragment(it) => it.needs_parentheses(f),
             AstNodes::TSAsExpression(it) => it.needs_parentheses(f),
             AstNodes::TSSatisfiesExpression(it) => it.needs_parentheses(f),
             AstNodes::TSTypeAssertion(it) => it.needs_parentheses(f),
@@ -313,6 +313,7 @@ impl<'a> NeedsParentheses<'a> for AstNode<'a, ConditionalExpression<'a>> {
                 | AstNodes::TSAsExpression(_)
                 | AstNodes::TSSatisfiesExpression(_)
                 | AstNodes::SpreadElement(_)
+                | AstNodes::JSXSpreadAttribute(_)
                 | AstNodes::LogicalExpression(_)
                 | AstNodes::BinaryExpression(_)
         ) {
@@ -549,10 +550,12 @@ fn binary_like_needs_parens(binary_like: BinaryLikeExpression<'_, '_>) -> bool {
         | AstNodes::AwaitExpression(_)
         | AstNodes::TSNonNullExpression(_)
         | AstNodes::SpreadElement(_)
+        | AstNodes::JSXSpreadAttribute(_)
         | AstNodes::CallExpression(_)
         | AstNodes::NewExpression(_)
         | AstNodes::StaticMemberExpression(_)
         | AstNodes::TaggedTemplateExpression(_) => return true,
+
         AstNodes::Class(class) => {
             return class.super_class.as_ref().is_some_and(|super_class| {
                 super_class.span().contains_inclusive(binary_like.span())
@@ -793,3 +796,43 @@ fn is_class_extends(span: Span, parent: &AstNodes<'_>) -> bool {
     }
     false
 }
+
+fn jsx_element_or_fragment_needs_paren(span: Span, parent: &AstNodes<'_>) -> bool {
+    if is_class_extends(span, parent) {
+        return true;
+    }
+
+    match parent {
+        AstNodes::BinaryExpression(binary) => {
+            let is_left = binary.left.span() == span;
+            binary.operator == BinaryOperator::LessThan && is_left
+        }
+        AstNodes::TSAsExpression(_)
+        | AstNodes::TSSatisfiesExpression(_)
+        | AstNodes::AwaitExpression(_)
+        | AstNodes::StaticMemberExpression(_)
+        | AstNodes::ComputedMemberExpression(_)
+        | AstNodes::SequenceExpression(_)
+        | AstNodes::UnaryExpression(_)
+        | AstNodes::TSNonNullExpression(_)
+        | AstNodes::SpreadElement(_)
+        | AstNodes::CallExpression(_)
+        | AstNodes::NewExpression(_)
+        | AstNodes::TaggedTemplateExpression(_)
+        | AstNodes::JSXSpreadAttribute(_)
+        | AstNodes::JSXSpreadChild(_) => true,
+        _ => false,
+    }
+}
+
+impl NeedsParentheses<'_> for AstNode<'_, JSXElement<'_>> {
+    fn needs_parentheses(&self, f: &Formatter<'_, '_>) -> bool {
+        jsx_element_or_fragment_needs_paren(self.span, self.parent)
+    }
+}
+
+impl NeedsParentheses<'_> for AstNode<'_, JSXFragment<'_>> {
+    fn needs_parentheses(&self, f: &Formatter<'_, '_>) -> bool {
+        jsx_element_or_fragment_needs_paren(self.span, self.parent)
+    }
+}

crates/oxc_formatter/src/utils/assignment_like.rs

@@ -741,24 +741,28 @@ fn is_poorly_breakable_member_or_call_chain<'a>(
     // Keeping track of all call expressions in the chain to check them later
     let mut call_expressions = vec![];
 
-    let mut expression = expression;
+    let mut expression = expression.as_ast_nodes();
 
     loop {
-        expression = match expression.as_ast_nodes() {
-            AstNodes::TSNonNullExpression(assertion) => assertion.expression(),
+        expression = match expression {
+            AstNodes::TSNonNullExpression(assertion) => assertion.expression().as_ast_nodes(),
             AstNodes::CallExpression(call_expression) => {
                 is_chain = true;
                 let callee = &call_expression.callee();
                 call_expressions.push(call_expression);
-                callee
+                callee.as_ast_nodes()
             }
             AstNodes::StaticMemberExpression(node) => {
                 is_chain = true;
-                node.object()
+                node.object().as_ast_nodes()
             }
             AstNodes::ComputedMemberExpression(node) => {
                 is_chain = true;
-                node.object()
+                node.object().as_ast_nodes()
+            }
+            AstNodes::ChainExpression(chain) => {
+                is_chain = true;
+                chain.expression().as_ast_nodes()
             }
             AstNodes::IdentifierReference(_) | AstNodes::ThisExpression(_) => {
                 is_chain_head_simple = true;