perf(linter): detect diverging match blocks for node type skipping (#14631)

camchenry · camchenry · commit 12a99340ee96 · 2025-10-15T20:56:46.000Z
Adds a new kind of code analysis to the linter codegen. This new detector looks for diverging statements in lint rules, like:

```rust
let something = match node.kind() {
  AstKind::CallExpression(_) =&gt; { ... }
  _ =&gt; return,
}
```

The important part is that the expression _must_ diverge (i.e., it must have something like a `return` in its wildcard block). That way, we know only the matched node types in the match arms are used in the rule.
diff --git a/crates/oxc_linter/src/generated/rule_runner_impls.rs b/crates/oxc_linter/src/generated/rule_runner_impls.rs
@@ -9,7 +9,8 @@ use oxc_semantic::AstTypesBitset;
 use crate::rule::{RuleRunFunctionsImplemented, RuleRunner};
 
 impl RuleRunner for crate::rules::eslint::array_callback_return::ArrayCallbackReturn {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -164,7 +165,8 @@ impl RuleRunner for crate::rules::eslint::no_alert::NoAlert {
 }
 
 impl RuleRunner for crate::rules::eslint::no_array_constructor::NoArrayConstructor {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::NewExpression]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -175,7 +177,8 @@ impl RuleRunner for crate::rules::eslint::no_async_promise_executor::NoAsyncProm
 }
 
 impl RuleRunner for crate::rules::eslint::no_await_in_loop::NoAwaitInLoop {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::AwaitExpression, AstType::ForOfStatement]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -225,7 +228,10 @@ impl RuleRunner for crate::rules::eslint::no_cond_assign::NoCondAssign {
 }
 
 impl RuleRunner for crate::rules::eslint::no_console::NoConsole {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::ComputedMemberExpression,
+        AstType::StaticMemberExpression,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -429,7 +435,8 @@ impl RuleRunner for crate::rules::eslint::no_inner_declarations::NoInnerDeclarat
 }
 
 impl RuleRunner for crate::rules::eslint::no_invalid_regexp::NoInvalidRegexp {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::NewExpression]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -547,7 +554,8 @@ impl RuleRunner for crate::rules::eslint::no_obj_calls::NoObjCalls {
 }
 
 impl RuleRunner for crate::rules::eslint::no_object_constructor::NoObjectConstructor {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::NewExpression]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -964,7 +972,8 @@ impl RuleRunner for crate::rules::eslint::use_isnan::UseIsnan {
 }
 
 impl RuleRunner for crate::rules::eslint::valid_typeof::ValidTypeof {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::UnaryExpression]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -1434,12 +1443,14 @@ impl RuleRunner for crate::rules::jsdoc::no_defaults::NoDefaults {
 }
 
 impl RuleRunner for crate::rules::jsdoc::require_param::RequireParam {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
 impl RuleRunner for crate::rules::jsdoc::require_param_description::RequireParamDescription {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -1449,7 +1460,8 @@ impl RuleRunner for crate::rules::jsdoc::require_param_name::RequireParamName {
 }
 
 impl RuleRunner for crate::rules::jsdoc::require_param_type::RequireParamType {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -1953,7 +1965,8 @@ impl RuleRunner for crate::rules::oxc::number_arg_out_of_range::NumberArgOutOfRa
 }
 
 impl RuleRunner for crate::rules::oxc::only_used_in_recursion::OnlyUsedInRecursion {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -2269,7 +2282,8 @@ impl RuleRunner for crate::rules::react::prefer_es6_class::PreferEs6Class {
 }
 
 impl RuleRunner for crate::rules::react::react_in_jsx_scope::ReactInJsxScope {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::JSXFragment, AstType::JSXOpeningElement]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -2707,7 +2721,11 @@ impl RuleRunner for crate::rules::typescript::no_var_requires::NoVarRequires {
 }
 
 impl RuleRunner for crate::rules::typescript::no_wrapper_object_types::NoWrapperObjectTypes {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::TSClassImplements,
+        AstType::TSInterfaceHeritage,
+        AstType::TSTypeReference,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -2885,12 +2903,19 @@ impl RuleRunner
 }
 
 impl RuleRunner for crate::rules::unicorn::consistent_function_scoping::ConsistentFunctionScoping {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
 impl RuleRunner for crate::rules::unicorn::empty_brace_spaces::EmptyBraceSpaces {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::BlockStatement,
+        AstType::Class,
+        AstType::FunctionBody,
+        AstType::ObjectExpression,
+        AstType::StaticBlock,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -2937,7 +2962,10 @@ impl RuleRunner for crate::rules::unicorn::no_accessor_recursion::NoAccessorRecu
 }
 
 impl RuleRunner for crate::rules::unicorn::no_anonymous_default_export::NoAnonymousDefaultExport {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::AssignmentExpression,
+        AstType::ExportDefaultDeclaration,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -3240,7 +3268,8 @@ impl RuleRunner for crate::rules::unicorn::no_zero_fractions::NoZeroFractions {
 }
 
 impl RuleRunner for crate::rules::unicorn::number_literal_case::NumberLiteralCase {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::BigIntLiteral, AstType::NumericLiteral]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -3384,7 +3413,11 @@ impl RuleRunner for crate::rules::unicorn::prefer_math_min_max::PreferMathMinMax
 }
 
 impl RuleRunner for crate::rules::unicorn::prefer_math_trunc::PreferMathTrunc {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::AssignmentExpression,
+        AstType::BinaryExpression,
+        AstType::UnaryExpression,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -3566,7 +3599,8 @@ impl RuleRunner for crate::rules::unicorn::switch_case_braces::SwitchCaseBraces
 impl RuleRunner
     for crate::rules::unicorn::text_encoding_identifier_case::TextEncodingIdentifierCase
 {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::JSXText, AstType::StringLiteral]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
diff --git a/tasks/linter_codegen/src/early_diverge_detector.rs b/tasks/linter_codegen/src/early_diverge_detector.rs
@@ -0,0 +1,78 @@
+use syn::{Arm, Expr, Pat, Stmt};
+
+use crate::{
+    CollectionResult, NodeTypeSet,
+    utils::{astkind_variant_from_path, is_node_kind_call},
+};
+
+/// Detects various kinds of diverging statements that narrow by more than one AST node type.
+pub struct EarlyDivergeDetector {
+    node_types: NodeTypeSet,
+}
+
+impl EarlyDivergeDetector {
+    pub fn from_run_func(run_func: &syn::ImplItemFn) -> Option<NodeTypeSet> {
+        // Only look at cases where the body has more than one top-level statement.
+        let block = &run_func.block;
+        if block.stmts.len() <= 1 {
+            return None;
+        }
+
+        // Look at the first statement in the function body.
+        let stmt = block.stmts.first()?;
+
+        // Check if it's `let something = match node.kind() { ... }` that diverges
+        if let Stmt::Local(local) = stmt
+            && let Some(init) = &local.init
+            && let Expr::Match(match_expr) = &*init.expr
+            && is_node_kind_call(&match_expr.expr)
+        {
+            let mut detector = Self { node_types: NodeTypeSet::new() };
+            let result = detector.extract_variants_from_diverging_match_expr(match_expr);
+            if result == CollectionResult::Incomplete || detector.node_types.is_empty() {
+                return None;
+            }
+            return Some(detector.node_types);
+        }
+
+        None
+    }
+
+    fn extract_variants_from_diverging_match_expr(
+        &mut self,
+        match_expr: &syn::ExprMatch,
+    ) -> CollectionResult {
+        let mut overall_result = CollectionResult::Complete;
+        for arm in &match_expr.arms {
+            let result = self.extract_variants_from_diverging_match_arm(arm);
+            if result == CollectionResult::Incomplete {
+                overall_result = CollectionResult::Incomplete;
+            }
+        }
+        overall_result
+    }
+
+    fn extract_variants_from_diverging_match_arm(&mut self, arm: &Arm) -> CollectionResult {
+        let pat = &arm.pat;
+        match pat {
+            Pat::TupleStruct(ts) => {
+                if let Some(variant) = astkind_variant_from_path(&ts.path) {
+                    // NOTE: If there is a guard, we assume that it may or may not be taken and collect all AST kinds
+                    // regardless of the guard condition.
+                    self.node_types.insert(variant);
+                    CollectionResult::Complete
+                } else {
+                    CollectionResult::Incomplete
+                }
+            }
+            Pat::Wild(_) => {
+                // Body must be diverging (i.e., returning from function)
+                if let Expr::Return(_) = *arm.body {
+                    return CollectionResult::Complete;
+                }
+                CollectionResult::Incomplete
+            }
+            _ => CollectionResult::Incomplete,
+        }
+    }
+}
diff --git a/tasks/linter_codegen/src/main.rs b/tasks/linter_codegen/src/main.rs
@@ -1,6 +1,7 @@
 #![allow(clippy::print_stdout)]
 
 use crate::{
+    early_diverge_detector::EarlyDivergeDetector,
     if_else_detector::IfElseKindDetector,
     let_else_detector::LetElseDetector,
     match_detector::MatchDetector,
@@ -17,6 +18,7 @@ use std::{
 };
 use syn::File;
 
+mod early_diverge_detector;
 mod if_else_detector;
 mod let_else_detector;
 mod match_detector;
@@ -131,6 +133,13 @@ fn detect_top_level_node_types(file: &File, rule: &RuleEntry) -> Option<NodeType
         return Some(node_types);
     }
 
+    let node_types = EarlyDivergeDetector::from_run_func(run_func);
+    if let Some(node_types) = node_types
+        && !node_types.is_empty()
+    {
+        return Some(node_types);
+    }
+
     None
 }
 

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,8 @@ use oxc_semantic::AstTypesBitset;`
`9`	`9`	`use crate::rule::{RuleRunFunctionsImplemented, RuleRunner};`
`10`	`10`
`11`	`11`	`impl RuleRunner for crate::rules::eslint::array_callback_return::ArrayCallbackReturn {`
`12`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`12`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`13`	`+ Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));`
`13`	`14`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`14`	`15`	`}`
`15`	`16`
`@@ -164,7 +165,8 @@ impl RuleRunner for crate::rules::eslint::no_alert::NoAlert {`
`164`	`165`	`}`
`165`	`166`
`166`	`167`	`impl RuleRunner for crate::rules::eslint::no_array_constructor::NoArrayConstructor {`
`167`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`168`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`169`	`+ Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::NewExpression]));`
`168`	`170`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`169`	`171`	`}`
`170`	`172`
`@@ -175,7 +177,8 @@ impl RuleRunner for crate::rules::eslint::no_async_promise_executor::NoAsyncProm`
`175`	`177`	`}`
`176`	`178`
`177`	`179`	`impl RuleRunner for crate::rules::eslint::no_await_in_loop::NoAwaitInLoop {`
`178`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`180`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`181`	`+ Some(&AstTypesBitset::from_types(&[AstType::AwaitExpression, AstType::ForOfStatement]));`
`179`	`182`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`180`	`183`	`}`
`181`	`184`
`@@ -225,7 +228,10 @@ impl RuleRunner for crate::rules::eslint::no_cond_assign::NoCondAssign {`
`225`	`228`	`}`
`226`	`229`
`227`	`230`	`impl RuleRunner for crate::rules::eslint::no_console::NoConsole {`
`228`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`231`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`232`	`+ AstType::ComputedMemberExpression,`
	`233`	`+ AstType::StaticMemberExpression,`
	`234`	`+ ]));`
`229`	`235`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`230`	`236`	`}`
`231`	`237`
`@@ -429,7 +435,8 @@ impl RuleRunner for crate::rules::eslint::no_inner_declarations::NoInnerDeclarat`
`429`	`435`	`}`
`430`	`436`
`431`	`437`	`impl RuleRunner for crate::rules::eslint::no_invalid_regexp::NoInvalidRegexp {`
`432`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`438`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`439`	`+ Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::NewExpression]));`
`433`	`440`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`434`	`441`	`}`
`435`	`442`
`@@ -547,7 +554,8 @@ impl RuleRunner for crate::rules::eslint::no_obj_calls::NoObjCalls {`
`547`	`554`	`}`
`548`	`555`
`549`	`556`	`impl RuleRunner for crate::rules::eslint::no_object_constructor::NoObjectConstructor {`
`550`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`557`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`558`	`+ Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::NewExpression]));`
`551`	`559`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`552`	`560`	`}`
`553`	`561`
`@@ -964,7 +972,8 @@ impl RuleRunner for crate::rules::eslint::use_isnan::UseIsnan {`
`964`	`972`	`}`
`965`	`973`
`966`	`974`	`impl RuleRunner for crate::rules::eslint::valid_typeof::ValidTypeof {`
`967`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`975`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`976`	`+ Some(&AstTypesBitset::from_types(&[AstType::UnaryExpression]));`
`968`	`977`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`969`	`978`	`}`
`970`	`979`
`@@ -1434,12 +1443,14 @@ impl RuleRunner for crate::rules::jsdoc::no_defaults::NoDefaults {`
`1434`	`1443`	`}`
`1435`	`1444`
`1436`	`1445`	`impl RuleRunner for crate::rules::jsdoc::require_param::RequireParam {`
`1437`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`1446`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`1447`	`+ Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));`
`1438`	`1448`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`1439`	`1449`	`}`
`1440`	`1450`
`1441`	`1451`	`impl RuleRunner for crate::rules::jsdoc::require_param_description::RequireParamDescription {`
`1442`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`1452`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`1453`	`+ Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));`
`1443`	`1454`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`1444`	`1455`	`}`
`1445`	`1456`
`@@ -1449,7 +1460,8 @@ impl RuleRunner for crate::rules::jsdoc::require_param_name::RequireParamName {`
`1449`	`1460`	`}`
`1450`	`1461`
`1451`	`1462`	`impl RuleRunner for crate::rules::jsdoc::require_param_type::RequireParamType {`
`1452`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`1463`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`1464`	`+ Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));`
`1453`	`1465`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`1454`	`1466`	`}`
`1455`	`1467`
`@@ -1953,7 +1965,8 @@ impl RuleRunner for crate::rules::oxc::number_arg_out_of_range::NumberArgOutOfRa`
`1953`	`1965`	`}`
`1954`	`1966`
`1955`	`1967`	`impl RuleRunner for crate::rules::oxc::only_used_in_recursion::OnlyUsedInRecursion {`
`1956`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`1968`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`1969`	`+ Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));`
`1957`	`1970`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`1958`	`1971`	`}`
`1959`	`1972`
`@@ -2269,7 +2282,8 @@ impl RuleRunner for crate::rules::react::prefer_es6_class::PreferEs6Class {`
`2269`	`2282`	`}`
`2270`	`2283`
`2271`	`2284`	`impl RuleRunner for crate::rules::react::react_in_jsx_scope::ReactInJsxScope {`
`2272`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`2285`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`2286`	`+ Some(&AstTypesBitset::from_types(&[AstType::JSXFragment, AstType::JSXOpeningElement]));`
`2273`	`2287`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`2274`	`2288`	`}`
`2275`	`2289`
`@@ -2707,7 +2721,11 @@ impl RuleRunner for crate::rules::typescript::no_var_requires::NoVarRequires {`
`2707`	`2721`	`}`
`2708`	`2722`
`2709`	`2723`	`impl RuleRunner for crate::rules::typescript::no_wrapper_object_types::NoWrapperObjectTypes {`
`2710`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`2724`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`2725`	`+ AstType::TSClassImplements,`
	`2726`	`+ AstType::TSInterfaceHeritage,`
	`2727`	`+ AstType::TSTypeReference,`
	`2728`	`+ ]));`
`2711`	`2729`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`2712`	`2730`	`}`
`2713`	`2731`
`@@ -2885,12 +2903,19 @@ impl RuleRunner`
`2885`	`2903`	`}`
`2886`	`2904`
`2887`	`2905`	`impl RuleRunner for crate::rules::unicorn::consistent_function_scoping::ConsistentFunctionScoping {`
`2888`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`2906`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`2907`	`+ Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));`
`2889`	`2908`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`2890`	`2909`	`}`
`2891`	`2910`
`2892`	`2911`	`impl RuleRunner for crate::rules::unicorn::empty_brace_spaces::EmptyBraceSpaces {`
`2893`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`2912`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`2913`	`+ AstType::BlockStatement,`
	`2914`	`+ AstType::Class,`
	`2915`	`+ AstType::FunctionBody,`
	`2916`	`+ AstType::ObjectExpression,`
	`2917`	`+ AstType::StaticBlock,`
	`2918`	`+ ]));`
`2894`	`2919`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`2895`	`2920`	`}`
`2896`	`2921`
`@@ -2937,7 +2962,10 @@ impl RuleRunner for crate::rules::unicorn::no_accessor_recursion::NoAccessorRecu`
`2937`	`2962`	`}`
`2938`	`2963`
`2939`	`2964`	`impl RuleRunner for crate::rules::unicorn::no_anonymous_default_export::NoAnonymousDefaultExport {`
`2940`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`2965`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`2966`	`+ AstType::AssignmentExpression,`
	`2967`	`+ AstType::ExportDefaultDeclaration,`
	`2968`	`+ ]));`
`2941`	`2969`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`2942`	`2970`	`}`
`2943`	`2971`
`@@ -3240,7 +3268,8 @@ impl RuleRunner for crate::rules::unicorn::no_zero_fractions::NoZeroFractions {`
`3240`	`3268`	`}`
`3241`	`3269`
`3242`	`3270`	`impl RuleRunner for crate::rules::unicorn::number_literal_case::NumberLiteralCase {`
`3243`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`3271`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`3272`	`+ Some(&AstTypesBitset::from_types(&[AstType::BigIntLiteral, AstType::NumericLiteral]));`
`3244`	`3273`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`3245`	`3274`	`}`
`3246`	`3275`
`@@ -3384,7 +3413,11 @@ impl RuleRunner for crate::rules::unicorn::prefer_math_min_max::PreferMathMinMax`
`3384`	`3413`	`}`
`3385`	`3414`
`3386`	`3415`	`impl RuleRunner for crate::rules::unicorn::prefer_math_trunc::PreferMathTrunc {`
`3387`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`3416`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`3417`	`+ AstType::AssignmentExpression,`
	`3418`	`+ AstType::BinaryExpression,`
	`3419`	`+ AstType::UnaryExpression,`
	`3420`	`+ ]));`
`3388`	`3421`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`3389`	`3422`	`}`
`3390`	`3423`
`@@ -3566,7 +3599,8 @@ impl RuleRunner for crate::rules::unicorn::switch_case_braces::SwitchCaseBraces`
`3566`	`3599`	`impl RuleRunner`
`3567`	`3600`	`for crate::rules::unicorn::text_encoding_identifier_case::TextEncodingIdentifierCase`
`3568`	`3601`	`{`
`3569`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`3602`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`3603`	`+ Some(&AstTypesBitset::from_types(&[AstType::JSXText, AstType::StringLiteral]));`
`3570`	`3604`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`3571`	`3605`	`}`
`3572`	`3606`