refactor(linter): simplify finding ancestor of specific kind (oxc-project#11224)

ulrichstark · web-flow · commit a6954727fe63 · 2025-05-21T19:47:06.000+01:00
diff --git a/crates/oxc_linter/src/rules/oxc/only_used_in_recursion.rs b/crates/oxc_linter/src/rules/oxc/only_used_in_recursion.rs
@@ -236,18 +236,13 @@ fn create_diagnostic_jsx(
 
             // search for references to the function and remove the property
             for reference in ctx.semantic().symbol_references(property_symbol_id) {
-                let mut ancestor_ids = ctx.nodes().ancestor_ids(reference.node_id());
-
-                let Some(attr) =
-                    ancestor_ids.find_map(|node| match ctx.nodes().get_node(node).kind() {
-                        AstKind::JSXAttributeItem(attr) => Some(attr),
-                        _ => None,
-                    })
-                else {
-                    continue;
-                };
-
-                fix.push(Fix::delete(attr.span()));
+                if let Some(attr) = ctx
+                    .nodes()
+                    .ancestors(reference.node_id())
+                    .find_map(|node| node.kind().as_jsx_attribute_item())
+                {
+                    fix.push(Fix::delete(attr.span()));
+                }
             }
 
             fix.with_message("Remove unused property")
@@ -334,9 +329,11 @@ fn is_property_only_used_in_recursion_jsx(
             return false;
         };
 
-        let Some(attr) = ctx.nodes().ancestors(may_jsx_expr_container.id()).find_map(|node| {
-            if let AstKind::JSXAttributeItem(attr) = node.kind() { Some(attr) } else { None }
-        }) else {
+        let Some(attr) = ctx
+            .nodes()
+            .ancestors(may_jsx_expr_container.id())
+            .find_map(|node| node.kind().as_jsx_attribute_item())
+        else {
             return false;
         };
 
@@ -350,14 +347,10 @@ fn is_property_only_used_in_recursion_jsx(
             return false;
         }
 
-        let Some(opening_element) =
-            ctx.nodes().ancestor_ids(reference.node_id()).find_map(|node| {
-                if let AstKind::JSXOpeningElement(elem) = ctx.nodes().get_node(node).kind() {
-                    Some(elem)
-                } else {
-                    None
-                }
-            })
+        let Some(opening_element) = ctx
+            .nodes()
+            .ancestors(reference.node_id())
+            .find_map(|node| node.kind().as_jsx_opening_element())
         else {
             return false;
         };
diff --git a/crates/oxc_linter/src/rules/react/jsx_key.rs b/crates/oxc_linter/src/rules/react/jsx_key.rs
@@ -1,7 +1,10 @@
 use cow_utils::CowUtils;
 use oxc_ast::{
     AstKind,
-    ast::{Expression, JSXAttributeItem, JSXAttributeName, JSXElement, JSXFragment, Statement},
+    ast::{
+        CallExpression, Expression, JSXAttributeItem, JSXAttributeName, JSXElement, JSXFragment,
+        Statement,
+    },
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
@@ -84,18 +87,8 @@ impl Rule for JsxKey {
     }
 }
 
-pub fn is_to_array(node: &AstNode<'_>) -> bool {
-    const TOARRAY: &str = "toArray";
-
-    let AstKind::CallExpression(call) = node.kind() else { return false };
-
-    let Some(subject) = call.callee_name() else { return false };
-
-    if subject != TOARRAY {
-        return false;
-    }
-
-    true
+pub fn is_to_array(call: &CallExpression<'_>) -> bool {
+    call.callee_name().is_some_and(|subject| subject == "toArray")
 }
 
 pub fn import_matcher<'a>(
@@ -125,12 +118,10 @@ pub fn is_import<'a>(
     import_matcher(ctx, actual_local_name, expected_module_name)
 }
 
-pub fn is_children<'a, 'b>(node: &'b AstNode<'a>, ctx: &'b LintContext<'a>) -> bool {
+pub fn is_children<'a, 'b>(call: &'b CallExpression<'a>, ctx: &'b LintContext<'a>) -> bool {
     const REACT: &str = "React";
     const CHILDREN: &str = "Children";
 
-    let AstKind::CallExpression(call) = node.kind() else { return false };
-
     let Some(member) = call.callee.as_member_expression() else { return false };
 
     if let Expression::Identifier(ident) = member.object() {
@@ -150,8 +141,8 @@ pub fn is_children<'a, 'b>(node: &'b AstNode<'a>, ctx: &'b LintContext<'a>) -> b
 fn is_within_children_to_array<'a, 'b>(node: &'b AstNode<'a>, ctx: &'b LintContext<'a>) -> bool {
     let parents_iter = ctx.nodes().ancestors(node.id()).skip(2);
     parents_iter
-        .filter(|parent_node| matches!(parent_node.kind(), AstKind::CallExpression(_)))
-        .any(|parent_node| is_children(parent_node, ctx) && is_to_array(parent_node))
+        .filter_map(|parent_node| parent_node.kind().as_call_expression())
+        .any(|parent_call| is_children(parent_call, ctx) && is_to_array(parent_call))
 }
 
 enum InsideArrayOrIterator {
diff --git a/crates/oxc_linter/src/rules/typescript/no_namespace.rs b/crates/oxc_linter/src/rules/typescript/no_namespace.rs
@@ -182,12 +182,9 @@ impl Rule for NoNamespace {
 }
 
 fn is_declaration(node: &AstNode, ctx: &LintContext) -> bool {
-    ctx.nodes().ancestors(node.id()).any(|node| {
-        let AstKind::TSModuleDeclaration(declaration) = node.kind() else {
-            return false;
-        };
-        declaration.declare
-    })
+    ctx.nodes()
+        .ancestors(node.id())
+        .any(|node| node.kind().as_ts_module_declaration().is_some_and(|decl| decl.declare))
 }
 
 #[test]
diff --git a/crates/oxc_linter/src/rules/vitest/no_conditional_tests.rs b/crates/oxc_linter/src/rules/vitest/no_conditional_tests.rs
@@ -1,4 +1,3 @@
-use oxc_ast::AstKind;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
@@ -79,12 +78,9 @@ fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>)
             JestFnKind::General(JestGeneralFnKind::Test),
         ],
     ) {
-        let if_statement_node = ctx
-            .nodes()
-            .ancestors(node.id())
-            .find(|node| matches!(node.kind(), AstKind::IfStatement(_)))?;
+        let if_statement =
+            ctx.nodes().ancestors(node.id()).find_map(|node| node.kind().as_if_statement())?;
 
-        let if_statement = if_statement_node.kind().as_if_statement()?;
         ctx.diagnostic(no_conditional_tests(if_statement.span));
     }
 
diff --git a/crates/oxc_linter/src/rules/vitest/require_local_test_context_for_concurrent_snapshots.rs b/crates/oxc_linter/src/rules/vitest/require_local_test_context_for_concurrent_snapshots.rs
@@ -117,15 +117,10 @@ impl RequireLocalTestContextForConcurrentSnapshots {
 
             let test_or_describe_node_found =
                 ctx.nodes().ancestors(possible_jest_node.node.id()).any(|node| {
-                    if let AstKind::CallExpression(ancestor_call_expr) = node.kind() {
-                        if let Some(ancestor_member_expr) =
-                            ancestor_call_expr.callee.as_member_expression()
-                        {
-                            return is_test_or_describe_node(ancestor_member_expr);
-                        }
-                    }
-
-                    false
+                    node.kind()
+                        .as_call_expression()
+                        .and_then(|call_expr| call_expr.callee.as_member_expression())
+                        .is_some_and(|member_expr| is_test_or_describe_node(member_expr))
                 });
 
             if test_or_describe_node_found {

Original file line number	Diff line number	Diff line change
`@@ -182,12 +182,9 @@ impl Rule for NoNamespace {`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`fn is_declaration(node: &AstNode, ctx: &LintContext) -> bool {`
`185`		`- ctx.nodes().ancestors(node.id()).any(\|node\| {`
`186`		`- let AstKind::TSModuleDeclaration(declaration) = node.kind() else {`
`187`		`- return false;`
`188`		`- };`
`189`		`- declaration.declare`
`190`		`- })`
	`185`	`+ ctx.nodes()`
	`186`	`+ .ancestors(node.id())`
	`187`	`+ .any(\|node\| node.kind().as_ts_module_declaration().is_some_and(\|decl\| decl.declare))`
`191`	`188`	`}`
`192`	`189`
`193`	`190`	`#[test]`