refactor(linter): use run_on_jest_node for existing lint rules (#6722)

- closes #6038

Migrates all simple iterations over Jest nodes to use the `run_on_jest_node` method. Rules which require more custom data (such as getting nodes in order or storing data about counts, duplicates, etc.) have not been migrated.

Some simple benchmarking shows that this is ~5% faster on `vscode` when the Jest/Vitest rules are NOT enabled (due to being able to skip them now). And it is up to 8% on `vscode` when the Jest/Vitest plugins are enabled.

```
hyperfine -i -N --warmup 3 --runs 30 './oxlint-jest-iter --deny=all --silent ./vscode' './oxlint-main --deny=all --silent ./vscode'
Benchmark 1: ./oxlint-jest-iter --deny=all --silent ./vscode
  Time (mean ± σ):      2.348 s ±  0.104 s    [User: 16.922 s, System: 0.641 s]
  Range (min … max):    2.141 s …  2.544 s    30 runs

Benchmark 2: ./oxlint-main --deny=all --silent ./vscode
  Time (mean ± σ):      2.476 s ±  0.042 s    [User: 17.768 s, System: 0.668 s]
  Range (min … max):    2.430 s …  2.598 s    30 runs

Summary
  ./oxlint-jest-iter --deny=all --silent ./vscode ran
    1.05 ± 0.05 times faster than ./oxlint-main --deny=all --silent ./vscode
```

```
hyperfine -i -N --warmup 3 --runs 30 './oxlint-jest-iter --deny=all --jest-plugin --vitest-plugin --silent ./vscode' './oxlint-main --deny=all --jest-plugin --vitest-plugin --silent ./vscode'
Benchmark 1: ./oxlint-jest-iter --deny=all --jest-plugin --vitest-plugin --silent ./vscode
  Time (mean ± σ):      2.728 s ±  0.118 s    [User: 19.782 s, System: 0.786 s]
  Range (min … max):    2.580 s …  3.078 s    30 runs

Benchmark 2: ./oxlint-main --deny=all --jest-plugin --vitest-plugin --silent ./vscode
  Time (mean ± σ):      2.939 s ±  0.051 s    [User: 21.259 s, System: 0.859 s]
  Range (min … max):    2.848 s …  3.064 s    30 runs

Summary
  ./oxlint-jest-iter --deny=all --jest-plugin --vitest-plugin --silent ./vscode ran
    1.08 ± 0.05 times faster than ./oxlint-main --deny=all --jest-plugin --vitest-plugin --silent ./vscode
```

Author: camchenry

apps/oxlint/fixtures/eslintrc_vitest_replace/foo.js renamed to apps/oxlint/fixtures/eslintrc_vitest_replace/foo.test.js

@@ -539,7 +539,7 @@ mod test {
         let args = &[
             "-c",
             "fixtures/eslintrc_vitest_replace/eslintrc.json",
-            "fixtures/eslintrc_vitest_replace/foo.js",
+            "fixtures/eslintrc_vitest_replace/foo.test.js",
         ];
         let result = test(args);
         assert_eq!(result.number_of_files, 1);
@@ -549,7 +549,7 @@ mod test {
             "--vitest-plugin",
             "-c",
             "fixtures/eslintrc_vitest_replace/eslintrc.json",
-            "fixtures/eslintrc_vitest_replace/foo.js",
+            "fixtures/eslintrc_vitest_replace/foo.test.js",
         ];
         let result = test(args);
         assert_eq!(result.number_of_files, 1);

apps/oxlint/src/lint/mod.rs

@@ -14,8 +14,7 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, get_node_name, is_type_of_jest_fn_call, JestFnKind,
-        JestGeneralFnKind, PossibleJestNode,
+        get_node_name, is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode,
     },
 };
 
@@ -107,10 +106,12 @@ impl Rule for ExpectExpect {
         }))
     }
 
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            run(self, possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(self, jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/expect_expect.rs

@@ -6,7 +6,7 @@ use oxc_span::Span;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
+    utils::{parse_expect_jest_fn_call, PossibleJestNode},
 };
 
 fn no_alias_methods_diagnostic(x1: &str, x2: &str, span3: Span) -> OxcDiagnostic {
@@ -59,10 +59,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for NoAliasMethods {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_alias_methods.rs

@@ -9,8 +9,8 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, is_type_of_jest_fn_call, parse_expect_jest_fn_call,
-        JestFnKind, JestGeneralFnKind, PossibleJestNode,
+        is_type_of_jest_fn_call, parse_expect_jest_fn_call, JestFnKind, JestGeneralFnKind,
+        PossibleJestNode,
     },
 };
 
@@ -70,10 +70,12 @@ declare_oxc_lint!(
 struct InConditional(bool);
 
 impl Rule for NoConditionalExpect {
-    fn run_once(&self, ctx: &LintContext) {
-        for node in &collect_possible_jest_call_node(ctx) {
-            run(node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_conditional_expect.rs

@@ -7,8 +7,8 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, parse_general_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        ParsedGeneralJestFnCall, PossibleJestNode,
+        parse_general_jest_fn_call, JestFnKind, JestGeneralFnKind, ParsedGeneralJestFnCall,
+        PossibleJestNode,
     },
 };
 
@@ -90,10 +90,12 @@ impl Message {
 }
 
 impl Rule for NoDisabledTests {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_disabled_tests.rs

@@ -10,8 +10,7 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, get_node_name, parse_general_jest_fn_call, JestFnKind,
-        JestGeneralFnKind, PossibleJestNode,
+        get_node_name, parse_general_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode,
     },
 };
 
@@ -77,10 +76,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for NoDoneCallback {
-    fn run_once(&self, ctx: &LintContext) {
-        for node in &collect_possible_jest_call_node(ctx) {
-            run(node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_done_callback.rs

@@ -7,8 +7,8 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, parse_general_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        MemberExpressionElement, ParsedGeneralJestFnCall, PossibleJestNode,
+        parse_general_jest_fn_call, JestFnKind, JestGeneralFnKind, MemberExpressionElement,
+        ParsedGeneralJestFnCall, PossibleJestNode,
     },
 };
 
@@ -66,10 +66,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for NoFocusedTests {
-    fn run_once(&self, ctx: &LintContext) {
-        for node in &collect_possible_jest_call_node(ctx) {
-            run(node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_focused_tests.rs

@@ -6,10 +6,7 @@ use oxc_span::{CompactStr, GetSpan, Span};
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        PossibleJestNode,
-    },
+    utils::{is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode},
 };
 
 fn unexpected_hook_diagonsitc(span: Span) -> OxcDiagnostic {
@@ -96,10 +93,12 @@ impl Rule for NoHooks {
         Self(Box::new(NoHooksConfig { allow }))
     }
 
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in collect_possible_jest_call_node(ctx) {
-            self.run(&possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        self.run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_hooks.rs

@@ -6,7 +6,7 @@ use oxc_span::Span;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
+    utils::{parse_expect_jest_fn_call, PossibleJestNode},
 };
 
 fn no_interpolation_in_snapshots_diagnostic(span: Span) -> OxcDiagnostic {
@@ -55,10 +55,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for NoInterpolationInSnapshots {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_interpolation_in_snapshots.rs

@@ -13,7 +13,7 @@ use rustc_hash::FxHashMap;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
+    utils::{iter_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
 };
 
 // TODO: re-word diagnostic messages
@@ -167,8 +167,8 @@ impl Rule for NoLargeSnapshots {
                 }
             }
         } else {
-            for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-                self.run(possible_jest_node, ctx);
+            for possible_jest_node in iter_possible_jest_call_node(ctx.semantic()) {
+                self.run(&possible_jest_node, ctx);
             }
         }
     }

crates/oxc_linter/src/rules/jest/no_large_snapshots.rs

@@ -7,10 +7,7 @@ use rustc_hash::FxHashMap;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        PossibleJestNode,
-    },
+    utils::{is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode},
 };
 
 fn restricted_jest_method(x0: &str, span1: Span) -> OxcDiagnostic {
@@ -76,10 +73,12 @@ impl Rule for NoRestrictedJestMethods {
         }))
     }
 
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            self.run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        self.run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_restricted_jest_methods.rs

@@ -11,8 +11,8 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, is_type_of_jest_fn_call, parse_expect_jest_fn_call,
-        JestFnKind, KnownMemberExpressionProperty, PossibleJestNode,
+        is_type_of_jest_fn_call, parse_expect_jest_fn_call, JestFnKind,
+        KnownMemberExpressionProperty, PossibleJestNode,
     },
 };
 
@@ -90,10 +90,12 @@ impl Rule for NoRestrictedMatchers {
         }))
     }
 
-    fn run_once(&self, ctx: &LintContext<'_>) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            self.run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        self.run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_restricted_matchers.rs

@@ -7,8 +7,8 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, parse_general_jest_fn_call, JestGeneralFnKind,
-        KnownMemberExpressionProperty, ParsedGeneralJestFnCall, PossibleJestNode,
+        parse_general_jest_fn_call, JestGeneralFnKind, KnownMemberExpressionProperty,
+        ParsedGeneralJestFnCall, PossibleJestNode,
     },
 };
 
@@ -58,10 +58,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for NoTestPrefixes {
-    fn run_once(&self, ctx: &LintContext) {
-        for node in &collect_possible_jest_call_node(ctx) {
-            run(node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/no_test_prefixes.rs

@@ -6,11 +6,7 @@ use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
-use crate::{
-    context::LintContext,
-    rule::Rule,
-    utils::{collect_possible_jest_call_node, PossibleJestNode},
-};
+use crate::{context::LintContext, rule::Rule, utils::PossibleJestNode};
 
 fn add_type_parameter_to_module_mock_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn(
@@ -92,10 +88,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for NoUntypedMockFactory {
-    fn run_once(&self, ctx: &LintContext<'_>) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 
     fn should_run(&self, ctx: &crate::context::ContextHost) -> bool {

crates/oxc_linter/src/rules/jest/no_untyped_mock_factory.rs

@@ -6,7 +6,7 @@ use oxc_span::Span;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
+    utils::{parse_expect_jest_fn_call, PossibleJestNode},
 };
 
 fn use_to_be_called_with(span: Span) -> OxcDiagnostic {
@@ -48,10 +48,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferCalledWith {
-    fn run_once(&self, ctx: &LintContext<'_>) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_called_with.rs

@@ -12,8 +12,8 @@ use crate::{
     fixer::RuleFixer,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, is_equality_matcher, parse_expect_jest_fn_call,
-        KnownMemberExpressionProperty, PossibleJestNode,
+        is_equality_matcher, parse_expect_jest_fn_call, KnownMemberExpressionProperty,
+        PossibleJestNode,
     },
 };
 
@@ -60,10 +60,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferComparisonMatcher {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_comparison_matcher.rs

@@ -10,7 +10,7 @@ use oxc_syntax::operator::BinaryOperator;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
+    utils::{parse_expect_jest_fn_call, PossibleJestNode},
 };
 
 fn use_equality_matcher_diagnostic(span: Span) -> OxcDiagnostic {
@@ -45,10 +45,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferEqualityMatcher {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_equality_matcher.rs

@@ -10,10 +10,7 @@ use crate::{
     context::LintContext,
     fixer::{RuleFix, RuleFixer},
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, parse_expect_jest_fn_call, ParsedExpectFnCall,
-        PossibleJestNode,
-    },
+    utils::{parse_expect_jest_fn_call, ParsedExpectFnCall, PossibleJestNode},
 };
 
 fn expect_resolves(span: Span) -> OxcDiagnostic {
@@ -76,10 +73,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferExpectResolves {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_expect_resolves.rs

@@ -7,8 +7,7 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, parse_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        ParsedJestFnCallNew, PossibleJestNode,
+        parse_jest_fn_call, JestFnKind, JestGeneralFnKind, ParsedJestFnCallNew, PossibleJestNode,
     },
 };
 
@@ -157,10 +156,12 @@ impl Rule for PreferLowercaseTitle {
         }))
     }
 
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            self.run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        self.run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_lowercase_title.rs

@@ -5,7 +5,7 @@ use oxc_span::Span;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
+    utils::{parse_expect_jest_fn_call, PossibleJestNode},
 };
 
 fn use_to_strict_equal(span: Span) -> OxcDiagnostic {
@@ -38,10 +38,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferStrictEqual {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_strict_equal.rs

@@ -10,8 +10,8 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, is_equality_matcher, parse_expect_jest_fn_call,
-        KnownMemberExpressionProperty, ParsedExpectFnCall, PossibleJestNode,
+        is_equality_matcher, parse_expect_jest_fn_call, KnownMemberExpressionProperty,
+        ParsedExpectFnCall, PossibleJestNode,
     },
 };
 
@@ -79,10 +79,12 @@ enum PreferToBeKind {
 }
 
 impl Rule for PreferToBe {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_to_be.rs

@@ -10,8 +10,8 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, is_equality_matcher, parse_expect_jest_fn_call,
-        KnownMemberExpressionParentKind, PossibleJestNode,
+        is_equality_matcher, parse_expect_jest_fn_call, KnownMemberExpressionParentKind,
+        PossibleJestNode,
     },
 };
 
@@ -53,10 +53,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferToContain {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_to_contain.rs

@@ -10,10 +10,7 @@ use crate::{
     context::LintContext,
     fixer::RuleFixer,
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, is_equality_matcher, parse_expect_jest_fn_call,
-        ParsedExpectFnCall, PossibleJestNode,
-    },
+    utils::{is_equality_matcher, parse_expect_jest_fn_call, ParsedExpectFnCall, PossibleJestNode},
 };
 
 fn use_to_have_length(span: Span) -> OxcDiagnostic {
@@ -55,10 +52,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferToHaveLength {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_to_have_length.rs

@@ -10,10 +10,7 @@ use crate::{
     context::LintContext,
     fixer::{RuleFix, RuleFixer},
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        PossibleJestNode,
-    },
+    utils::{is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode},
 };
 
 fn empty_test(span: Span) -> OxcDiagnostic {
@@ -51,10 +48,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferTodo {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/prefer_todo.rs

@@ -6,7 +6,7 @@ use oxc_span::Span;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{collect_possible_jest_call_node, parse_expect_jest_fn_call, PossibleJestNode},
+    utils::{parse_expect_jest_fn_call, PossibleJestNode},
 };
 
 fn require_to_throw_message_diagnostic(x0: &str, span1: Span) -> OxcDiagnostic {
@@ -46,10 +46,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for RequireToThrowMessage {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 
@@ -177,5 +179,5 @@ fn test() {
         ),
     ];
 
-    Tester::new(RequireToThrowMessage::NAME, pass, fail).test_and_snapshot();
+    Tester::new(RequireToThrowMessage::NAME, pass, fail).with_jest_plugin(true).test_and_snapshot();
 }

crates/oxc_linter/src/rules/jest/require_to_throw_message.rs

@@ -9,10 +9,7 @@ use oxc_span::{GetSpan, Span};
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, parse_general_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        PossibleJestNode,
-    },
+    utils::{parse_general_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode},
 };
 
 fn valid_describe_callback_diagnostic(
@@ -76,10 +73,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for ValidDescribeCallback {
-    fn run_once(&self, ctx: &LintContext) {
-        for node in &collect_possible_jest_call_node(ctx) {
-            run(node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/valid_describe_callback.rs

@@ -11,9 +11,7 @@ use oxc_span::{GetSpan, Span};
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, parse_expect_jest_fn_call, ExpectError, PossibleJestNode,
-    },
+    utils::{parse_expect_jest_fn_call, ExpectError, PossibleJestNode},
     AstNode,
 };
 
@@ -115,10 +113,12 @@ impl Rule for ValidExpect {
         Self(Box::new(ValidExpectConfig { async_matchers, min_args, max_args, always_await }))
     }
 
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            self.run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'b>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'b>,
+        ctx: &'b LintContext<'a>,
+    ) {
+        self.run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/valid_expect.rs

@@ -14,10 +14,7 @@ use rustc_hash::FxHashMap;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, parse_general_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        PossibleJestNode,
-    },
+    utils::{parse_general_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode},
 };
 
 fn valid_title_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
@@ -105,10 +102,12 @@ impl Rule for ValidTitle {
         }))
     }
 
-    fn run_once(&self, ctx: &LintContext) {
-        for node in &collect_possible_jest_call_node(ctx) {
-            self.run(node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        self.run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/jest/valid_title.rs

@@ -6,10 +6,7 @@ use oxc_span::Span;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        PossibleJestNode,
-    },
+    utils::{is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode},
 };
 
 fn no_conditional_tests(span: Span) -> OxcDiagnostic {
@@ -59,10 +56,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for NoConditionalTests {
-    fn run_once(&self, ctx: &LintContext) {
-        for node in &collect_possible_jest_call_node(ctx) {
-            run(node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        run(jest_node, ctx);
     }
 }
 
@@ -142,5 +141,5 @@ fn test() {
 			   });"#,
     ];
 
-    Tester::new(NoConditionalTests::NAME, pass, fail).test_and_snapshot();
+    Tester::new(NoConditionalTests::NAME, pass, fail).with_vitest_plugin(true).test_and_snapshot();
 }

crates/oxc_linter/src/rules/vitest/no_conditional_tests.rs

@@ -1,6 +1,6 @@
 use oxc_macros::declare_oxc_lint;
 
-use crate::{context::LintContext, rule::Rule, utils::collect_possible_jest_call_node};
+use crate::{context::LintContext, rule::Rule};
 
 use super::prefer_to_be_truthy::prefer_to_be_simply_bool;
 
@@ -38,10 +38,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferToBeFalsy {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_vitest_node in &collect_possible_jest_call_node(ctx) {
-            prefer_to_be_simply_bool(possible_vitest_node, ctx, false);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &crate::utils::PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        prefer_to_be_simply_bool(jest_node, ctx, false);
     }
 }
 
@@ -100,5 +102,8 @@ fn test() {
             None,
         ),
     ];
-    Tester::new(PreferToBeFalsy::NAME, pass, fail).expect_fix(fix).test_and_snapshot();
+    Tester::new(PreferToBeFalsy::NAME, pass, fail)
+        .expect_fix(fix)
+        .with_vitest_plugin(true)
+        .test_and_snapshot();
 }

crates/oxc_linter/src/rules/vitest/prefer_to_be_falsy.rs

@@ -10,8 +10,8 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        collect_possible_jest_call_node, parse_jest_fn_call, KnownMemberExpressionProperty,
-        ParsedExpectFnCall, ParsedJestFnCallNew, PossibleJestNode,
+        parse_jest_fn_call, KnownMemberExpressionProperty, ParsedExpectFnCall, ParsedJestFnCallNew,
+        PossibleJestNode,
     },
 };
 
@@ -66,10 +66,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferToBeObject {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_vitest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_vitest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 

crates/oxc_linter/src/rules/vitest/prefer_to_be_object.rs

@@ -7,10 +7,7 @@ use oxc_macros::declare_oxc_lint;
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, is_equality_matcher,
-        parse_expect_and_typeof_vitest_fn_call, PossibleJestNode,
-    },
+    utils::{is_equality_matcher, parse_expect_and_typeof_vitest_fn_call, PossibleJestNode},
 };
 
 use oxc_diagnostics::OxcDiagnostic;
@@ -104,10 +101,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for PreferToBeTruthy {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_vitest_node in &collect_possible_jest_call_node(ctx) {
-            prefer_to_be_simply_bool(possible_vitest_node, ctx, true);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        prefer_to_be_simply_bool(jest_node, ctx, true);
     }
 }
 
@@ -168,5 +167,8 @@ fn test() {
             None,
         ),
     ];
-    Tester::new(PreferToBeTruthy::NAME, pass, fail).expect_fix(fix).test_and_snapshot();
+    Tester::new(PreferToBeTruthy::NAME, pass, fail)
+        .expect_fix(fix)
+        .with_vitest_plugin(true)
+        .test_and_snapshot();
 }

crates/oxc_linter/src/rules/vitest/prefer_to_be_truthy.rs

@@ -6,10 +6,7 @@ use oxc_span::{GetSpan, Span};
 use crate::{
     context::LintContext,
     rule::Rule,
-    utils::{
-        collect_possible_jest_call_node, is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind,
-        PossibleJestNode,
-    },
+    utils::{is_type_of_jest_fn_call, JestFnKind, JestGeneralFnKind, PossibleJestNode},
 };
 
 #[inline]
@@ -93,10 +90,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for RequireLocalTestContextForConcurrentSnapshots {
-    fn run_once(&self, ctx: &LintContext) {
-        for possible_jest_node in &collect_possible_jest_call_node(ctx) {
-            Self::run(possible_jest_node, ctx);
-        }
+    fn run_on_jest_node<'a, 'c>(
+        &self,
+        jest_node: &PossibleJestNode<'a, 'c>,
+        ctx: &'c LintContext<'a>,
+    ) {
+        Self::run(jest_node, ctx);
     }
 }
 
@@ -178,5 +177,6 @@ fn test() {
     ];
 
     Tester::new(RequireLocalTestContextForConcurrentSnapshots::NAME, pass, fail)
+        .with_vitest_plugin(true)
         .test_and_snapshot();
 }

crates/oxc_linter/src/rules/vitest/require_local_test_context_for_concurrent_snapshots.rs

@@ -417,7 +417,7 @@ impl Tester {
             self.current_working_directory.join(&self.rule_path)
         } else if let Some(path) = path {
             self.current_working_directory.join(path)
-        } else if self.plugins.has_jest() {
+        } else if self.plugins.has_test() {
             self.rule_path.with_extension("test.tsx")
         } else {
             self.rule_path.clone()