fix(noExtraBooleanCast): preserve parentheses to maintain operator precedence

.changeset/fix-boolean-cast-parentheses.md

@@ -0,0 +1,12 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [#7225](https://github.com/biomejs/biome/issues/7225): The noExtraBooleanCast rule now preserves parentheses when removing Boolean calls inside negations.
+
+```js
+// Before
+!Boolean(b0 && b1)
+// After  
+!(b0 && b1)  // instead of !b0 && b1
+```

crates/biome_js_analyze/src/lint/complexity/no_extra_boolean_cast.rs

@@ -3,9 +3,12 @@ use biome_analyze::{
 };
 use biome_console::markup;
 use biome_diagnostics::Severity;
+use biome_js_factory::make;
 use biome_js_syntax::{
-    AnyJsExpression, JsCallArgumentList, JsCallArguments, JsCallExpression, JsNewExpression,
-    JsSyntaxNode, JsUnaryOperator, is_in_boolean_context, is_negation,
+    AnyJsExpression, JsAssignmentExpression, JsBinaryExpression, JsCallArgumentList,
+    JsCallArguments, JsCallExpression, JsConditionalExpression, JsLogicalExpression, JsNewExpression,
+    JsParenthesizedExpression, JsSequenceExpression, JsSyntaxNode, JsUnaryExpression, JsUnaryOperator, T,
+    is_in_boolean_context, is_negation,
 };
 use biome_rowan::{AstNode, AstSeparatedList, BatchMutationExt};
 use biome_rule_options::no_extra_boolean_cast::NoExtraBooleanCastOptions;
@@ -188,7 +191,36 @@ impl Rule for NoExtraBooleanCast {
             ExtraBooleanCastType::DoubleNegation => "Remove redundant double-negation",
             ExtraBooleanCastType::BooleanCall => "Remove redundant `Boolean` call",
         };
-        mutation.replace_node(node.clone(), node_to_replace.clone());
+
+        // Check if the Boolean call is inside a unary negation and the argument needs parentheses
+        let replacement = if matches!(extra_boolean_cast_type, ExtraBooleanCastType::BooleanCall) {
+            // Check if this Boolean call is inside a unary negation
+            if let Some(unary_expr) = node.syntax().parent().and_then(JsUnaryExpression::cast) {
+                if matches!(unary_expr.operator(), Ok(JsUnaryOperator::LogicalNot)) {
+                    // Check if the argument is a complex expression that needs parentheses
+                    if needs_parentheses_when_negated(node_to_replace) {
+                        // Wrap in parentheses to preserve operator precedence
+                        AnyJsExpression::JsParenthesizedExpression(
+                            make::js_parenthesized_expression(
+                                make::token(T!['(']),
+                                node_to_replace.clone(),
+                                make::token(T![')']),
+                            ),
+                        )
+                    } else {
+                        node_to_replace.clone()
+                    }
+                } else {
+                    node_to_replace.clone()
+                }
+            } else {
+                node_to_replace.clone()
+            }
+        } else {
+            node_to_replace.clone()
+        };
+
+        mutation.replace_node(node.clone(), replacement);
 
         Some(JsRuleAction::new(
             ctx.metadata().action_category(ctx.category(), ctx.group()),
@@ -199,6 +231,27 @@ impl Rule for NoExtraBooleanCast {
     }
 }
 
+/// Determines if an expression needs parentheses when it becomes the operand of a unary negation.
+/// This is needed to preserve operator precedence for expressions like binary expressions.
+fn needs_parentheses_when_negated(expr: &AnyJsExpression) -> bool {
+    match expr {
+        // Binary expressions like `a + b` need parentheses in `!(a + b)` to maintain precedence
+        AnyJsExpression::JsBinaryExpression(_) => true,
+        // Logical expressions like `a && b` need parentheses in `!(a && b)` to maintain precedence
+        AnyJsExpression::JsLogicalExpression(_) => true,
+        // Conditional expressions like `a ? b : c` need parentheses
+        AnyJsExpression::JsConditionalExpression(_) => true,
+        // Assignment expressions need parentheses
+        AnyJsExpression::JsAssignmentExpression(_) => true,
+        // Sequence expressions (comma operator) need parentheses
+        AnyJsExpression::JsSequenceExpression(_) => true,
+        // Logical expressions that are already parenthesized don't need additional ones
+        AnyJsExpression::JsParenthesizedExpression(_) => false,
+        // Simple expressions like identifiers, literals, calls don't need parentheses
+        _ => false,
+    }
+}
+
 /// Check if the SyntaxNode is a Double Negation. Including the edge case
 /// ```js
 /// !(!x)

crates/biome_js_analyze/tests/specs/complexity/noExtraBooleanCast/invalid.js

@@ -20,4 +20,9 @@ new Boolean(!!x);
 
 !!!x;
 
-!Boolean(x);
+!Boolean(x);
+
+// Test case for issue #7225 - should preserve parentheses
+const b0 = false;
+const b1 = false;
+const boolean = !Boolean(b0 && b1);