refactor: consistently use cast, cast_ref and try_cast (#3520)

crates/biome_js_analyze/src/lint/a11y/no_noninteractive_tabindex.rs

@@ -195,7 +195,7 @@ fn attribute_has_negative_tabindex(
         AnyJsxAttributeValue::JsxExpressionAttributeValue(value) => {
             let expression = value.expression().ok()?;
             let expression_value =
-                AnyNumberLikeExpression::cast_ref(expression.syntax())?.value()?;
+                AnyNumberLikeExpression::cast(expression.into_syntax())?.value()?;
             Some(is_negative_tabindex(&expression_value))
         }
         _ => None,

crates/biome_js_analyze/src/lint/a11y/no_positive_tabindex.rs

@@ -138,12 +138,11 @@ impl Rule for NoPositiveTabindex {
             }
             TabindexProp::JsPropertyObjectMember(js_object_member) => {
                 let expression = js_object_member.value().ok()?;
-                let expression_syntax_node = expression.syntax();
+                let range = expression.range();
                 let expression_value =
-                    AnyNumberLikeExpression::cast_ref(expression_syntax_node)?.value()?;
-
+                    AnyNumberLikeExpression::cast(expression.into_syntax())?.value()?;
                 if !is_tabindex_valid(&expression_value) {
-                    return Some(expression_syntax_node.text_trimmed_range());
+                    return Some(range);
                 }
             }
         }
@@ -214,7 +213,7 @@ fn attribute_has_valid_tabindex(jsx_any_attribute_value: &AnyJsxAttributeValue)
         AnyJsxAttributeValue::JsxExpressionAttributeValue(value) => {
             let expression = value.expression().ok()?;
             let expression_value =
-                AnyNumberLikeExpression::cast_ref(expression.syntax())?.value()?;
+                AnyNumberLikeExpression::cast(expression.into_syntax())?.value()?;
 
             Some(is_tabindex_valid(&expression_value))
         }

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

@@ -81,7 +81,7 @@ impl Rule for NoForEach {
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
         let node = ctx.query();
         let member_expression =
-            AnyJsMemberExpression::cast_ref(node.callee().ok()?.omit_parentheses().syntax())?;
+            AnyJsMemberExpression::cast(node.callee().ok()?.omit_parentheses().into_syntax())?;
         if member_expression.member_name()?.text() != "forEach" {
             return None;
         }

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

@@ -135,12 +135,11 @@ impl Rule for NoUselessFragments {
                                 if JsxExpressionAttributeValue::can_cast(parent.kind()) {
                                     in_jsx_attr_expr = true;
                                 }
-                                if let Some(parenthesized_expression) =
-                                    JsParenthesizedExpression::cast_ref(&parent)
-                                {
-                                    parenthesized_expression.syntax().parent()
-                                } else {
-                                    Some(parent)
+                                match JsParenthesizedExpression::try_cast(parent) {
+                                    Ok(parenthesized_expression) => {
+                                        parenthesized_expression.syntax().parent()
+                                    }
+                                    Err(parent) => Some(parent),
                                 }
                             })
                             .map_or(false, |parent| {

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

@@ -70,15 +70,15 @@ impl Rule for UseFlatMap {
             }
         }
         let flat_member_expression =
-            AnyJsMemberExpression::cast_ref(flat_call.callee().ok()?.syntax())?;
+            AnyJsMemberExpression::cast(flat_call.callee().ok()?.into_syntax())?;
         if flat_member_expression.member_name()?.text() == "flat" {
             let Ok(AnyJsExpression::JsCallExpression(map_call)) = flat_member_expression.object()
             else {
                 return None;
             };
             let map_call_arguments = map_call.arguments().ok()?.args();
             let map_member_expression =
-                AnyJsMemberExpression::cast_ref(map_call.callee().ok()?.syntax())?;
+                AnyJsMemberExpression::cast(map_call.callee().ok()?.into_syntax())?;
             if map_member_expression.member_name()?.text() == "map" && map_call_arguments.len() == 1
             {
                 return Some(map_call);

crates/biome_js_analyze/src/lint/correctness/no_constant_condition.rs

@@ -106,7 +106,7 @@ impl Rule for NoConstantCondition {
         // If the statement contains a valid yield expression returned from a `while`, `for`, or `do...while` statement,
         // we don't need to examine the statement's `test`.
         if let Some(any_js_stmt) = conditional_stmt.body() {
-            if conditional_stmt.is_in_generator_function().unwrap_or(false)
+            if conditional_stmt.is_in_generator_function()
                 && has_valid_yield_expression(&any_js_stmt).unwrap_or(false)
             {
                 return None;
@@ -158,15 +158,15 @@ impl ConditionalStatement {
         }
     }
     // Checks if the self statement is in a generator function
-    fn is_in_generator_function(&self) -> Option<bool> {
-        self.syntax().ancestors().find_map(|node| {
-            if let Some(func_decl) = JsFunctionDeclaration::cast_ref(&node) {
-                return Some(func_decl.star_token().is_some());
-            };
-            if let Some(func_expr) = JsFunctionExpression::cast(node) {
-                return Some(func_expr.star_token().is_some());
-            };
-            None
+    fn is_in_generator_function(&self) -> bool {
+        self.syntax().ancestors().any(|node| {
+            match JsFunctionDeclaration::try_cast(node) {
+                Ok(func_decl) => func_decl.star_token(),
+                Err(node) => {
+                    JsFunctionExpression::cast(node).and_then(|func_expr| func_expr.star_token())
+                }
+            }
+            .is_some()
         })
     }
 }

crates/biome_js_analyze/src/lint/correctness/no_constant_math_min_max_clamp.rs

@@ -147,7 +147,7 @@ fn get_math_min_or_max_call(
     model: &SemanticModel,
 ) -> Option<MathMinOrMaxCall> {
     let callee = call_expression.callee().ok()?.omit_parentheses();
-    let member_expr = AnyJsMemberExpression::cast_ref(callee.syntax())?;
+    let member_expr = AnyJsMemberExpression::cast(callee.into_syntax())?;
 
     let member_name = member_expr.member_name()?;
     let member_name = member_name.text();

crates/biome_js_analyze/src/lint/correctness/no_flat_map_identity.rs

@@ -55,7 +55,7 @@ impl Rule for NoFlatMapIdentity {
         let flat_map_call = ctx.query();
 
         let flat_map_expression =
-            AnyJsMemberExpression::cast_ref(flat_map_call.callee().ok()?.syntax())?;
+            AnyJsMemberExpression::cast(flat_map_call.callee().ok()?.into_syntax())?;
 
         if flat_map_expression.object().is_err() {
             return None;

crates/biome_js_analyze/src/lint/correctness/no_string_case_mismatch.rs

@@ -184,7 +184,7 @@ impl StringCase {
             return None;
         }
         let callee = call.callee().ok()?;
-        let member_expr = AnyJsMemberExpression::cast_ref(callee.syntax())?;
+        let member_expr = AnyJsMemberExpression::cast(callee.into_syntax())?;
         let member_name = member_expr.member_name()?;
         let member_name = member_name.text();
         if member_name == "toLowerCase" {

crates/biome_js_analyze/src/lint/correctness/no_unused_private_class_members.rs

@@ -265,22 +265,22 @@ impl AnyMember {
                     AnyJsClassMember::JsGetterClassMember(member) => member
                         .modifiers()
                         .iter()
-                        .filter_map(|x| TsAccessibilityModifier::cast_ref(x.syntax()))
+                        .filter_map(|x| TsAccessibilityModifier::cast(x.into_syntax()))
                         .any(|accessibility| accessibility.is_private()),
                     AnyJsClassMember::JsMethodClassMember(member) => member
                         .modifiers()
                         .iter()
-                        .filter_map(|x| TsAccessibilityModifier::cast_ref(x.syntax()))
+                        .filter_map(|x| TsAccessibilityModifier::cast(x.into_syntax()))
                         .any(|accessibility| accessibility.is_private()),
                     AnyJsClassMember::JsPropertyClassMember(member) => member
                         .modifiers()
                         .iter()
-                        .filter_map(|x| TsAccessibilityModifier::cast_ref(x.syntax()))
+                        .filter_map(|x| TsAccessibilityModifier::cast(x.into_syntax()))
                         .any(|accessibility| accessibility.is_private()),
                     AnyJsClassMember::JsSetterClassMember(member) => member
                         .modifiers()
                         .iter()
-                        .filter_map(|x| TsAccessibilityModifier::cast_ref(x.syntax()))
+                        .filter_map(|x| TsAccessibilityModifier::cast(x.into_syntax()))
                         .any(|accessibility| accessibility.is_private()),
                     _ => false,
                 };
@@ -291,7 +291,7 @@ impl AnyMember {
                 param
                     .modifiers()
                     .iter()
-                    .filter_map(|x| TsAccessibilityModifier::cast_ref(x.syntax()))
+                    .filter_map(|x| TsAccessibilityModifier::cast(x.into_syntax()))
                     .any(|accessibility| accessibility.is_private()),
             ),
         }

crates/biome_js_analyze/src/lint/correctness/use_exhaustive_dependencies.rs

@@ -657,34 +657,35 @@ fn determine_unstable_dependency(
     }
 }
 
-fn into_member_vec(node: &JsSyntaxNode) -> Vec<String> {
+fn into_member_iter(node: &JsSyntaxNode) -> impl Iterator<Item = String> {
     let mut vec = vec![];
     let mut next = Some(node.clone());
 
-    while let Some(node) = &next {
-        match AnyJsMemberExpression::cast_ref(node) {
-            Some(member_expr) => {
+    while let Some(node) = next {
+        match AnyJsMemberExpression::try_cast(node) {
+            Ok(member_expr) => {
                 let member_name = member_expr
                     .member_name()
                     .and_then(|it| it.as_string_constant().map(|it| it.to_owned()));
                 if let Some(member_name) = member_name {
-                    vec.insert(0, member_name);
+                    vec.push(member_name);
                 }
                 next = member_expr.object().ok().map(AstNode::into_syntax);
             }
-            None => {
-                vec.insert(0, node.text_trimmed().to_string());
+            Err(node) => {
+                vec.push(node.text_trimmed().to_string());
                 break;
             }
         }
     }
 
-    vec
+    // elemnsts are inserted in reverse, thus we have to reverse the iteration.
+    vec.into_iter().rev()
 }
 
 fn compare_member_depth(a: &JsSyntaxNode, b: &JsSyntaxNode) -> (bool, bool) {
-    let mut a_member_iter = into_member_vec(a).into_iter();
-    let mut b_member_iter = into_member_vec(b).into_iter();
+    let mut a_member_iter = into_member_iter(a);
+    let mut b_member_iter = into_member_iter(b);
 
     loop {
         let a_member = a_member_iter.next();

crates/biome_js_analyze/src/lint/correctness/use_hook_at_top_level.rs

@@ -115,17 +115,19 @@ fn enclosing_function_if_call_is_at_top_level(
     let mut prev_node = None;
 
     for node in call.syntax().ancestors() {
-        if let Some(enclosing_function) = AnyJsFunctionOrMethod::cast_ref(&node) {
-            return Some(enclosing_function);
-        }
-
-        if let Some(prev_node) = prev_node {
-            if is_conditional_expression(&node, &prev_node) {
-                return None;
+        match AnyJsFunctionOrMethod::try_cast(node) {
+            Ok(enclosing_function) => {
+                return Some(enclosing_function);
+            }
+            Err(node) => {
+                if let Some(prev_node) = prev_node {
+                    if is_conditional_expression(&node, &prev_node) {
+                        return None;
+                    }
+                }
+                prev_node = Some(node);
             }
         }
-
-        prev_node = Some(node);
     }
 
     None

crates/biome_js_analyze/src/lint/correctness/use_is_nan.rs

@@ -296,7 +296,7 @@ fn has_nan(expr: AnyJsExpression, model: &SemanticModel) -> bool {
             }
             reference
         } else {
-            let member_expr = AnyJsMemberExpression::cast_ref(expr.syntax())?;
+            let member_expr = AnyJsMemberExpression::cast(expr.into_syntax())?;
             if member_expr.member_name()?.text() != "NaN" {
                 return None;
             }

crates/biome_js_analyze/src/lint/correctness/use_jsx_key_in_iterable.rs

@@ -257,15 +257,15 @@ fn handle_potential_react_component(
     }
 
     if is_inside_jsx {
-        if let Some(node) = ReactComponentExpression::cast_ref(node.syntax()) {
+        if let Some(node) = ReactComponentExpression::cast(node.into_syntax()) {
             let range = handle_react_component(node, model)?;
             Some(range)
         } else {
             None
         }
     } else {
         let range =
-            handle_react_component(ReactComponentExpression::cast_ref(node.syntax())?, model)?;
+            handle_react_component(ReactComponentExpression::cast(node.into_syntax())?, model)?;
         Some(range)
     }
 }
@@ -291,7 +291,7 @@ fn handle_react_component(
 /// ```
 fn handle_jsx_tag(node: &JsxTagExpression, model: &SemanticModel) -> Option<Vec<TextRange>> {
     let tag = node.tag().ok()?;
-    let tag = AnyJsxChild::cast_ref(tag.syntax())?;
+    let tag = AnyJsxChild::cast(tag.into_syntax())?;
     handle_jsx_child(&tag, model)
 }
 

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

@@ -40,7 +40,7 @@ impl Rule for NoConsole {
         let call_expression = ctx.query();
         let model = ctx.model();
         let callee = call_expression.callee().ok()?;
-        let member_expression = AnyJsMemberExpression::cast_ref(callee.syntax())?;
+        let member_expression = AnyJsMemberExpression::cast(callee.into_syntax())?;
         let object = member_expression.object().ok()?;
         let (reference, name) = global_identifier(&object)?;
         if name.text() != "console" {