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,13 @@ use biome_analyze::{
 };
 use biome_console::markup;
 use biome_diagnostics::Severity;
+use biome_js_factory::make;
+#[expect(unused_imports)]
 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 +192,30 @@ 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 mut replacement = node_to_replace.clone();
+
+        // Only wrap in parentheses if this is a Boolean call inside a logical NOT with complex expression
+        if matches!(extra_boolean_cast_type, ExtraBooleanCastType::BooleanCall) {
+            let is_negated_boolean_call = node
+                .syntax()
+                .parent()
+                .and_then(JsUnaryExpression::cast)
+                .and_then(|expr| expr.operator().ok())
+                .is_some_and(|op| op == JsUnaryOperator::LogicalNot);
+
+            if is_negated_boolean_call && needs_parentheses_when_negated(node_to_replace) {
+                replacement =
+                    AnyJsExpression::JsParenthesizedExpression(make::js_parenthesized_expression(
+                        make::token(T!['(']),
+                        replacement,
+                        make::token(T![')']),
+                    ));
+            }
+        }
+
+        mutation.replace_node(node.clone(), replacement);
 
         Some(JsRuleAction::new(
             ctx.metadata().action_category(ctx.category(), ctx.group()),
@@ -199,6 +226,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);

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

@@ -27,6 +27,11 @@ new Boolean(!!x);
 !!!x;
 
 !Boolean(x);
+
+// Test case for issue #7225 - should preserve parentheses
+const b0 = false;
+const b1 = false;
+const boolean = !Boolean(b0 && b1);
 ```
 
 # Diagnostics
@@ -226,6 +231,8 @@ invalid.js:23:2 lint/complexity/noExtraBooleanCast  FIXABLE  ━━━━━━
     22 │ 
   > 23 │ !Boolean(x);
        │  ^^^^^^^^^^
+    24 │ 
+    25 │ // Test case for issue #7225 - should preserve parentheses
 
   i It is not necessary to use `Boolean` call when a value will already be coerced to a boolean.
 
@@ -235,3 +242,22 @@ invalid.js:23:2 lint/complexity/noExtraBooleanCast  FIXABLE  ━━━━━━
        │  -------- - 
 
 ```
+
+```
+invalid.js:28:18 lint/complexity/noExtraBooleanCast  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i Avoid redundant `Boolean` call
+
+    26 │ const b0 = false;
+    27 │ const b1 = false;
+  > 28 │ const boolean = !Boolean(b0 && b1);
+       │                  ^^^^^^^^^^^^^^^^^
+
+  i It is not necessary to use `Boolean` call when a value will already be coerced to a boolean.
+
+  i Safe fix: Remove redundant `Boolean` call
+
+    28 │ const·boolean·=·!Boolean(b0·&&·b1);
+       │                  -------           
+
+```