fix(biome_js_analyze): ignore as const and similar wrappers in noMagicNumbers rule (#6944)

Co-authored-by: Arend van Beelen jr. <[email protected]>

Author: sterliakov

.changeset/crazy-moments-sniff.md

@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [#6910](https://github.com/biomejs/biome/issues/6910): Biome now ignores type casts and assertions when evaluating numbers for `noMagicNumbers` rule.

crates/biome_js_analyze/src/lint/nursery/no_magic_numbers.rs

@@ -8,9 +8,10 @@ use biome_js_syntax::{
     JsComputedMemberAssignment, JsComputedMemberExpression, JsFormalParameter, JsInitializerClause,
     JsNumberLiteralExpression, JsObjectBindingPatternShorthandProperty, JsParenthesizedExpression,
     JsPropertyClassMember, JsPropertyObjectMember, JsSyntaxNode, JsUnaryExpression,
-    JsUnaryOperator, JsxExpressionAttributeValue, JsxExpressionChild, TsEnumMemberList,
-    TsIndexedAccessType, TsNumberLiteralType, TsReturnTypeAnnotation, TsTypeAnnotation,
-    TsUnionTypeVariantList,
+    JsUnaryOperator, JsxExpressionAttributeValue, JsxExpressionChild, TsAsExpression,
+    TsEnumMemberList, TsIndexedAccessType, TsNonNullAssertionExpression, TsNumberLiteralType,
+    TsPredicateReturnType, TsReturnTypeAnnotation, TsSatisfiesExpression, TsTypeAnnotation,
+    TsTypeAssertionExpression, TsUnionTypeVariantList,
 };
 use biome_rowan::{AstNode, declare_node_union};
 use biome_rule_options::no_magic_numbers::NoMagicNumbersOptions;
@@ -45,6 +46,11 @@ declare_lint_rule! {
     /// const TAX_RATE = 1.23;
     /// let total = price * TAX_RATE;
     /// ```
+    ///
+    /// ```ts
+    /// const TAX_RATE = 1.23 as const;
+    /// let total = price * TAX_RATE;
+    /// ```
     pub NoMagicNumbers {
         version: "2.1.0",
         name: "noMagicNumbers",
@@ -372,43 +378,28 @@ fn is_ts_numeric_literal_return_type(numeric_literal: &TsNumberLiteralType) -> b
         .is_some_and(|parent| TsReturnTypeAnnotation::can_cast(parent.kind()))
 }
 
-/// Omits unary plus or minus expressions by returning the parent node if
-/// the current node is a unary expression with a plus or minus operator.
-/// Example: `-5` or `+3` will return the parent node, effectively skipping the unary operator parent node.
-fn omit_unary_plus_minus_parent(node: JsSyntaxNode) -> Option<JsSyntaxNode> {
-    let unary_expression_plus_or_minus =
-        JsUnaryExpression::cast(node.clone()).and_then(|unary_node| {
-            if unary_node.operator().is_ok_and(|operator| {
-                operator == JsUnaryOperator::Plus || operator == JsUnaryOperator::Minus
-            }) {
-                Some(unary_node)
-            } else {
-                None
-            }
-        });
-
-    if unary_expression_plus_or_minus.is_some() {
-        node.parent()
-    } else {
-        Some(node)
-    }
-}
-
-/// Omits the parenthesized expression if the node is wrapped in parentheses.
-/// Example: `(5)` will return the parent node, effectively skipping the parenthesized expression.
-fn omit_parenthesized_parent(node: JsSyntaxNode) -> Option<JsSyntaxNode> {
-    if JsParenthesizedExpression::can_cast(node.kind()) {
-        node.parent()
-    } else {
-        Some(node)
-    }
-}
-
-/// Returns the parent node of the given node, skipping over any unary plus/minus or parenthesized expression wrappers.
+/// Returns the parent node of the given node, skipping over any unary plus/minus or parenthesized expression wrappers,
+/// as well as all type-level wrappers (casts and `satisfies`).
 /// It helps determine the true syntactic context of the node by ignoring these common, but semantically insignificant, wrappers.
 fn get_sanitized_parent_node(node: &JsSyntaxNode) -> Option<JsSyntaxNode> {
-    node.parent()
-        .and_then(|parent| omit_unary_plus_minus_parent(parent).and_then(omit_parenthesized_parent))
+    node.ancestors().skip(1).find(|parent| {
+        if TsAsExpression::can_cast(parent.kind())
+            || TsNonNullAssertionExpression::can_cast(parent.kind())
+            || TsSatisfiesExpression::can_cast(parent.kind())
+            || TsTypeAssertionExpression::can_cast(parent.kind())
+            || TsPredicateReturnType::can_cast(parent.kind())
+            || JsParenthesizedExpression::can_cast(parent.kind())
+        {
+            false
+        } else if let Some(parent) = JsUnaryExpression::cast_ref(parent) {
+            match parent.operator() {
+                Err(_) => true,
+                Ok(op) => !matches!(op, JsUnaryOperator::Plus | JsUnaryOperator::Minus),
+            }
+        } else {
+            true
+        }
+    })
 }
 
 const ALWAYS_IGNORED_IN_ARITHMETIC_OPERATIONS: &[&str] = &[

crates/biome_js_analyze/tests/specs/nursery/noMagicNumbers/valid.tsx

@@ -8,6 +8,12 @@ const MY_NUMBER = +42;
 const foo = 42;
 let foo = 42;
 let foo = -42;
+const foo = 42 as const;
+const foo = 42 as number;
+const foo = 42 satisfies number;
+const foo = (42 satisfies number) as const;
+const foo = ((42 satisfies number) as const);
+const foo = (42 satisfies number)!;
 
 // jsx
 let jsx = (<div>{5}</div>);
@@ -95,9 +101,9 @@ function f(x: string): 100 {
 }
 
 // bitwise operations
-let bitwiseOr = 1 | 2;
-let bitwiseAnd = 1 & 2;
-let bitwiseXor = 1 ^ 2;
+let bitwiseOr = 1 | 42;
+let bitwiseAnd = 1 & 42;
+let bitwiseXor = 1 ^ 42;
 
 let a = ~5;
 let a = -5;
@@ -141,3 +147,8 @@ f(1n)
 f(-1n)
 f(1)
 f((-1))
+
+// type predicate
+function isFourtyTwo(num): num is 42 {
+	return true;
+}

crates/biome_js_analyze/tests/specs/nursery/noMagicNumbers/valid.tsx.snap

@@ -1,6 +1,5 @@
 ---
 source: crates/biome_js_analyze/tests/spec_tests.rs
-assertion_line: 134
 expression: valid.tsx
 ---
 # Input
@@ -15,6 +14,12 @@ const MY_NUMBER = +42;
 const foo = 42;
 let foo = 42;
 let foo = -42;
+const foo = 42 as const;
+const foo = 42 as number;
+const foo = 42 satisfies number;
+const foo = (42 satisfies number) as const;
+const foo = ((42 satisfies number) as const);
+const foo = (42 satisfies number)!;
 
 // jsx
 let jsx = (<div>{5}</div>);
@@ -102,9 +107,9 @@ function f(x: string): 100 {
 }
 
 // bitwise operations
-let bitwiseOr = 1 | 2;
-let bitwiseAnd = 1 & 2;
-let bitwiseXor = 1 ^ 2;
+let bitwiseOr = 1 | 42;
+let bitwiseAnd = 1 & 42;
+let bitwiseXor = 1 ^ 42;
 
 let a = ~5;
 let a = -5;
@@ -149,4 +154,9 @@ f(-1n)
 f(1)
 f((-1))
 
+// type predicate
+function isFourtyTwo(num): num is 42 {
+	return true;
+}
+
 ```