challenge(formatter): fix uneeded parens on decoaretd class expr (#746)

crates/biome_js_formatter/src/js/expressions/class_expression.rs

@@ -5,14 +5,14 @@ use biome_formatter::{format_args, write};
 use crate::parentheses::{
     is_callee, is_first_in_statement, FirstInStatementMode, NeedsParentheses,
 };
-use biome_js_syntax::{JsClassExpression, JsSyntaxNode};
+use biome_js_syntax::{JsClassExpression, JsSyntaxKind, JsSyntaxNode};
 
 #[derive(Debug, Clone, Default)]
 pub(crate) struct FormatJsClassExpression;
 
 impl FormatNodeRule<JsClassExpression> for FormatJsClassExpression {
     fn fmt_fields(&self, node: &JsClassExpression, f: &mut JsFormatter) -> FormatResult<()> {
-        if node.decorators().is_empty() {
+        if node.decorators().is_empty() || !self.needs_parentheses(node) {
             FormatClass::from(&node.clone().into()).fmt(f)
         } else {
             write!(
@@ -29,7 +29,8 @@ impl FormatNodeRule<JsClassExpression> for FormatJsClassExpression {
     }
 
     fn needs_parentheses(&self, item: &JsClassExpression) -> bool {
-        !item.decorators().is_empty() || item.needs_parentheses()
+        /*!item.decorators().is_empty() || */
+        item.needs_parentheses()
     }
 
     fn fmt_dangling_comments(
@@ -44,7 +45,8 @@ impl FormatNodeRule<JsClassExpression> for FormatJsClassExpression {
 
 impl NeedsParentheses for JsClassExpression {
     fn needs_parentheses_with_parent(&self, parent: &JsSyntaxNode) -> bool {
-        is_callee(self.syntax(), parent)
+        (parent.kind() == JsSyntaxKind::JS_EXTENDS_CLAUSE && !self.decorators().is_empty())
+            || is_callee(self.syntax(), parent)
             || is_first_in_statement(
                 self.clone().into(),
                 FirstInStatementMode::ExpressionOrExportDefault,

crates/biome_js_formatter/src/syntax_rewriter.rs

@@ -144,7 +144,7 @@ impl JsFormatSyntaxRewriter {
                 // Keep parentheses around unknown expressions. Biome can't know the precedence.
                 if inner.kind().is_bogus()
                     // Don't remove parentheses if the expression is a decorator
-                    || inner.grand_parent().map_or(false, |node| node.kind() == JsSyntaxKind::JS_DECORATOR)
+                    || inner.grand_parent().map_or(false, |node| node.kind() == JsSyntaxKind::JS_DECORATOR && decorator_expression_needs_parens(&inner))
                     // Don't remove parentheses if they have skipped trivia. We don't know for certain what the intended syntax is.
                     // Nor if there's a leading type cast comment
                     || has_type_cast_comment_or_skipped(&l_paren.leading_trivia())
@@ -403,6 +403,23 @@ impl JsFormatSyntaxRewriter {
     }
 }
 
+// TODO: This should be handled with a `NeedsParentheses` impl.
+fn decorator_expression_needs_parens(inner: &JsSyntaxNode) -> bool {
+    match AnyJsExpression::cast_ref(inner) {
+        Some(AnyJsExpression::JsCallExpression(call)) => call
+            .callee()
+            .map(|callee| decorator_expression_needs_parens(callee.syntax()))
+            .unwrap_or(true),
+        Some(AnyJsExpression::JsStaticMemberExpression(static_expr)) => {
+            static_expr.is_optional()
+                || static_expr.object().map_or(true, |object| {
+                    object.syntax().kind() != JsSyntaxKind::JS_IDENTIFIER_EXPRESSION
+                })
+        }
+        _ => true,
+    }
+}
+
 impl SyntaxRewriter for JsFormatSyntaxRewriter {
     type Language = JsLanguage;
 

crates/biome_js_formatter/tests/specs/js/module/decorators/expression.js.snap

@@ -51,28 +51,20 @@ Arrow parentheses: Always
 
 ```js
 console.log(
-	(
-		@deco
-		class Foo {}
-	),
+	@deco
+	class Foo {},
 );
 console.log(
-	(
-		@deco
-		class {}
-	),
+	@deco
+	class {},
 );
 
 const a1 =
-	(
-		@deco
-		class Foo {}
-	);
+	@deco
+	class Foo {};
 const a2 =
-	(
-		@deco
-		class {}
-	);
+	@deco
+	class {};
 
 (
 	@deco
@@ -94,10 +86,8 @@ const b2 = [];
 	@deco
 	class {}
 )(
-	(
-		@deco
-		class Foo {}
-	),
+	@deco
+	class Foo {},
 ).name;
 (
 	@deco