perf(linter): allow analyzing node types in match blocks with guards (#14459)

camchenry · camchenry · commit aec0c089614b · 2025-10-13T12:02:26.000Z
Previously, we skipped guard conditions to be extra cautious. After thinking about it and using the runtime optimizations in practice, I think that we can allow patterns with guards, and we just assume that it may always be taken. So this should result in the largest set of AST kinds possible for a rule and will not narrow it down dynamically.
diff --git a/crates/oxc_linter/src/generated/rule_runner_impls.rs b/crates/oxc_linter/src/generated/rule_runner_impls.rs
@@ -55,7 +55,8 @@ impl RuleRunner for crate::rules::eslint::default_case_last::DefaultCaseLast {
 }
 
 impl RuleRunner for crate::rules::eslint::default_param_last::DefaultParamLast {
-    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;
 }
 
@@ -83,12 +84,18 @@ impl RuleRunner for crate::rules::eslint::func_style::FuncStyle {
 }
 
 impl RuleRunner for crate::rules::eslint::getter_return::GetterReturn {
-    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::eslint::grouped_accessor_pairs::GroupedAccessorPairs {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::ClassBody,
+        AstType::ObjectExpression,
+        AstType::TSInterfaceBody,
+        AstType::TSTypeLiteral,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -204,7 +211,14 @@ impl RuleRunner for crate::rules::eslint::no_compare_neg_zero::NoCompareNegZero
 }
 
 impl RuleRunner for crate::rules::eslint::no_cond_assign::NoCondAssign {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::AssignmentExpression,
+        AstType::ConditionalExpression,
+        AstType::DoWhileStatement,
+        AstType::ForStatement,
+        AstType::IfStatement,
+        AstType::WhileStatement,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -306,7 +320,8 @@ impl RuleRunner for crate::rules::eslint::no_else_return::NoElseReturn {
 }
 
 impl RuleRunner for crate::rules::eslint::no_empty::NoEmpty {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::BlockStatement, AstType::SwitchStatement]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -341,7 +356,11 @@ impl RuleRunner for crate::rules::eslint::no_eq_null::NoEqNull {
 }
 
 impl RuleRunner for crate::rules::eslint::no_eval::NoEval {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::CallExpression,
+        AstType::Program,
+        AstType::ThisExpression,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -363,7 +382,8 @@ impl RuleRunner for crate::rules::eslint::no_extra_bind::NoExtraBind {
 }
 
 impl RuleRunner for crate::rules::eslint::no_extra_boolean_cast::NoExtraBooleanCast {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::UnaryExpression]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -441,7 +461,8 @@ impl RuleRunner for crate::rules::eslint::no_lonely_if::NoLonelyIf {
 }
 
 impl RuleRunner for crate::rules::eslint::no_loss_of_precision::NoLossOfPrecision {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::NumericLiteral]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -552,7 +573,11 @@ impl RuleRunner for crate::rules::eslint::no_redeclare::NoRedeclare {
 }
 
 impl RuleRunner for crate::rules::eslint::no_regex_spaces::NoRegexSpaces {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::CallExpression,
+        AstType::NewExpression,
+        AstType::RegExpLiteral,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -575,7 +600,8 @@ impl RuleRunner for crate::rules::eslint::no_return_assign::NoReturnAssign {
 }
 
 impl RuleRunner for crate::rules::eslint::no_script_url::NoScriptUrl {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::StringLiteral, AstType::TemplateLiteral]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -683,7 +709,25 @@ impl RuleRunner for crate::rules::eslint::no_unsafe_negation::NoUnsafeNegation {
 }
 
 impl RuleRunner for crate::rules::eslint::no_unsafe_optional_chaining::NoUnsafeOptionalChaining {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::Argument,
+        AstType::ArrayExpression,
+        AstType::AssignmentExpression,
+        AstType::AssignmentPattern,
+        AstType::AssignmentTargetWithDefault,
+        AstType::BinaryExpression,
+        AstType::CallExpression,
+        AstType::Class,
+        AstType::ComputedMemberExpression,
+        AstType::ForOfStatement,
+        AstType::NewExpression,
+        AstType::PrivateFieldExpression,
+        AstType::StaticMemberExpression,
+        AstType::TaggedTemplateExpression,
+        AstType::UnaryExpression,
+        AstType::VariableDeclarator,
+        AstType::WithStatement,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -728,7 +772,12 @@ impl RuleRunner for crate::rules::eslint::no_useless_catch::NoUselessCatch {
 }
 
 impl RuleRunner for crate::rules::eslint::no_useless_computed_key::NoUselessComputedKey {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::BindingProperty,
+        AstType::MethodDefinition,
+        AstType::ObjectProperty,
+        AstType::PropertyDefinition,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -745,7 +794,11 @@ impl RuleRunner for crate::rules::eslint::no_useless_constructor::NoUselessConst
 }
 
 impl RuleRunner for crate::rules::eslint::no_useless_escape::NoUselessEscape {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::RegExpLiteral,
+        AstType::StringLiteral,
+        AstType::TemplateLiteral,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -784,7 +837,10 @@ impl RuleRunner for crate::rules::eslint::operator_assignment::OperatorAssignmen
 }
 
 impl RuleRunner for crate::rules::eslint::prefer_destructuring::PreferDestructuring {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::AssignmentExpression,
+        AstType::VariableDeclarator,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -966,7 +1022,8 @@ impl RuleRunner for crate::rules::import::namespace::Namespace {
 }
 
 impl RuleRunner for crate::rules::import::no_absolute_path::NoAbsolutePath {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::ImportDeclaration]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -2033,7 +2090,8 @@ impl RuleRunner for crate::rules::react::jsx_filename_extension::JsxFilenameExte
 }
 
 impl RuleRunner for crate::rules::react::jsx_fragments::JsxFragments {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::JSXElement, AstType::JSXFragment]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -2300,7 +2358,11 @@ impl RuleRunner
 impl RuleRunner
     for crate::rules::typescript::consistent_type_definitions::ConsistentTypeDefinitions
 {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::ExportDefaultDeclaration,
+        AstType::TSInterfaceDeclaration,
+        AstType::TSTypeAliasDeclaration,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -2341,7 +2403,10 @@ impl RuleRunner for crate::rules::typescript::no_base_to_string::NoBaseToString
 impl RuleRunner
     for crate::rules::typescript::no_confusing_non_null_assertion::NoConfusingNonNullAssertion
 {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::AssignmentExpression,
+        AstType::BinaryExpression,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -2378,7 +2443,10 @@ impl RuleRunner for crate::rules::typescript::no_empty_interface::NoEmptyInterfa
 }
 
 impl RuleRunner for crate::rules::typescript::no_empty_object_type::NoEmptyObjectType {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[
+        AstType::TSInterfaceDeclaration,
+        AstType::TSTypeLiteral,
+    ]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
@@ -3134,7 +3202,8 @@ impl RuleRunner for crate::rules::unicorn::no_useless_switch_case::NoUselessSwit
 }
 
 impl RuleRunner for crate::rules::unicorn::no_useless_undefined::NoUselessUndefined {
-    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const NODE_TYPES: Option<&AstTypesBitset> =
+        Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::IdentifierReference]));
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;
 }
 
diff --git a/tasks/linter_codegen/src/match_detector.rs b/tasks/linter_codegen/src/match_detector.rs
@@ -52,15 +52,12 @@ impl MatchDetector {
     }
 
     fn extract_variants_from_match_arm(&mut self, arm: &Arm) -> CollectionResult {
-        // If there are any guards, we can't be 100% sure which variants this runs on, as it may
-        // run on any node type depending on the guard condition.
-        if arm.guard.is_some() {
-            return CollectionResult::Incomplete;
-        }
         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 {

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,8 @@ impl RuleRunner for crate::rules::eslint::default_case_last::DefaultCaseLast {`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`impl RuleRunner for crate::rules::eslint::default_param_last::DefaultParamLast {`
`58`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`58`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`59`	`+ Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));`
`59`	`60`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`60`	`61`	`}`
`61`	`62`
`@@ -83,12 +84,18 @@ impl RuleRunner for crate::rules::eslint::func_style::FuncStyle {`
`83`	`84`	`}`
`84`	`85`
`85`	`86`	`impl RuleRunner for crate::rules::eslint::getter_return::GetterReturn {`
`86`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`87`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`88`	`+ Some(&AstTypesBitset::from_types(&[AstType::ArrowFunctionExpression, AstType::Function]));`
`87`	`89`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`88`	`90`	`}`
`89`	`91`
`90`	`92`	`impl RuleRunner for crate::rules::eslint::grouped_accessor_pairs::GroupedAccessorPairs {`
`91`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`93`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`94`	`+ AstType::ClassBody,`
	`95`	`+ AstType::ObjectExpression,`
	`96`	`+ AstType::TSInterfaceBody,`
	`97`	`+ AstType::TSTypeLiteral,`
	`98`	`+ ]));`
`92`	`99`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`93`	`100`	`}`
`94`	`101`
`@@ -204,7 +211,14 @@ impl RuleRunner for crate::rules::eslint::no_compare_neg_zero::NoCompareNegZero`
`204`	`211`	`}`
`205`	`212`
`206`	`213`	`impl RuleRunner for crate::rules::eslint::no_cond_assign::NoCondAssign {`
`207`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`214`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`215`	`+ AstType::AssignmentExpression,`
	`216`	`+ AstType::ConditionalExpression,`
	`217`	`+ AstType::DoWhileStatement,`
	`218`	`+ AstType::ForStatement,`
	`219`	`+ AstType::IfStatement,`
	`220`	`+ AstType::WhileStatement,`
	`221`	`+ ]));`
`208`	`222`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`209`	`223`	`}`
`210`	`224`
`@@ -306,7 +320,8 @@ impl RuleRunner for crate::rules::eslint::no_else_return::NoElseReturn {`
`306`	`320`	`}`
`307`	`321`
`308`	`322`	`impl RuleRunner for crate::rules::eslint::no_empty::NoEmpty {`
`309`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`323`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`324`	`+ Some(&AstTypesBitset::from_types(&[AstType::BlockStatement, AstType::SwitchStatement]));`
`310`	`325`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`311`	`326`	`}`
`312`	`327`
`@@ -341,7 +356,11 @@ impl RuleRunner for crate::rules::eslint::no_eq_null::NoEqNull {`
`341`	`356`	`}`
`342`	`357`
`343`	`358`	`impl RuleRunner for crate::rules::eslint::no_eval::NoEval {`
`344`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`359`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`360`	`+ AstType::CallExpression,`
	`361`	`+ AstType::Program,`
	`362`	`+ AstType::ThisExpression,`
	`363`	`+ ]));`
`345`	`364`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`346`	`365`	`}`
`347`	`366`
`@@ -363,7 +382,8 @@ impl RuleRunner for crate::rules::eslint::no_extra_bind::NoExtraBind {`
`363`	`382`	`}`
`364`	`383`
`365`	`384`	`impl RuleRunner for crate::rules::eslint::no_extra_boolean_cast::NoExtraBooleanCast {`
`366`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`385`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`386`	`+ Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::UnaryExpression]));`
`367`	`387`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`368`	`388`	`}`
`369`	`389`
`@@ -441,7 +461,8 @@ impl RuleRunner for crate::rules::eslint::no_lonely_if::NoLonelyIf {`
`441`	`461`	`}`
`442`	`462`
`443`	`463`	`impl RuleRunner for crate::rules::eslint::no_loss_of_precision::NoLossOfPrecision {`
`444`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`464`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`465`	`+ Some(&AstTypesBitset::from_types(&[AstType::NumericLiteral]));`
`445`	`466`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`446`	`467`	`}`
`447`	`468`
`@@ -552,7 +573,11 @@ impl RuleRunner for crate::rules::eslint::no_redeclare::NoRedeclare {`
`552`	`573`	`}`
`553`	`574`
`554`	`575`	`impl RuleRunner for crate::rules::eslint::no_regex_spaces::NoRegexSpaces {`
`555`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`576`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`577`	`+ AstType::CallExpression,`
	`578`	`+ AstType::NewExpression,`
	`579`	`+ AstType::RegExpLiteral,`
	`580`	`+ ]));`
`556`	`581`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`557`	`582`	`}`
`558`	`583`
`@@ -575,7 +600,8 @@ impl RuleRunner for crate::rules::eslint::no_return_assign::NoReturnAssign {`
`575`	`600`	`}`
`576`	`601`
`577`	`602`	`impl RuleRunner for crate::rules::eslint::no_script_url::NoScriptUrl {`
`578`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`603`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`604`	`+ Some(&AstTypesBitset::from_types(&[AstType::StringLiteral, AstType::TemplateLiteral]));`
`579`	`605`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`580`	`606`	`}`
`581`	`607`
`@@ -683,7 +709,25 @@ impl RuleRunner for crate::rules::eslint::no_unsafe_negation::NoUnsafeNegation {`
`683`	`709`	`}`
`684`	`710`
`685`	`711`	`impl RuleRunner for crate::rules::eslint::no_unsafe_optional_chaining::NoUnsafeOptionalChaining {`
`686`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`712`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`713`	`+ AstType::Argument,`
	`714`	`+ AstType::ArrayExpression,`
	`715`	`+ AstType::AssignmentExpression,`
	`716`	`+ AstType::AssignmentPattern,`
	`717`	`+ AstType::AssignmentTargetWithDefault,`
	`718`	`+ AstType::BinaryExpression,`
	`719`	`+ AstType::CallExpression,`
	`720`	`+ AstType::Class,`
	`721`	`+ AstType::ComputedMemberExpression,`
	`722`	`+ AstType::ForOfStatement,`
	`723`	`+ AstType::NewExpression,`
	`724`	`+ AstType::PrivateFieldExpression,`
	`725`	`+ AstType::StaticMemberExpression,`
	`726`	`+ AstType::TaggedTemplateExpression,`
	`727`	`+ AstType::UnaryExpression,`
	`728`	`+ AstType::VariableDeclarator,`
	`729`	`+ AstType::WithStatement,`
	`730`	`+ ]));`
`687`	`731`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`688`	`732`	`}`
`689`	`733`
`@@ -728,7 +772,12 @@ impl RuleRunner for crate::rules::eslint::no_useless_catch::NoUselessCatch {`
`728`	`772`	`}`
`729`	`773`
`730`	`774`	`impl RuleRunner for crate::rules::eslint::no_useless_computed_key::NoUselessComputedKey {`
`731`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`775`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`776`	`+ AstType::BindingProperty,`
	`777`	`+ AstType::MethodDefinition,`
	`778`	`+ AstType::ObjectProperty,`
	`779`	`+ AstType::PropertyDefinition,`
	`780`	`+ ]));`
`732`	`781`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`733`	`782`	`}`
`734`	`783`
`@@ -745,7 +794,11 @@ impl RuleRunner for crate::rules::eslint::no_useless_constructor::NoUselessConst`
`745`	`794`	`}`
`746`	`795`
`747`	`796`	`impl RuleRunner for crate::rules::eslint::no_useless_escape::NoUselessEscape {`
`748`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`797`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`798`	`+ AstType::RegExpLiteral,`
	`799`	`+ AstType::StringLiteral,`
	`800`	`+ AstType::TemplateLiteral,`
	`801`	`+ ]));`
`749`	`802`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`750`	`803`	`}`
`751`	`804`
`@@ -784,7 +837,10 @@ impl RuleRunner for crate::rules::eslint::operator_assignment::OperatorAssignmen`
`784`	`837`	`}`
`785`	`838`
`786`	`839`	`impl RuleRunner for crate::rules::eslint::prefer_destructuring::PreferDestructuring {`
`787`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`840`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`841`	`+ AstType::AssignmentExpression,`
	`842`	`+ AstType::VariableDeclarator,`
	`843`	`+ ]));`
`788`	`844`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`789`	`845`	`}`
`790`	`846`
`@@ -966,7 +1022,8 @@ impl RuleRunner for crate::rules::import::namespace::Namespace {`
`966`	`1022`	`}`
`967`	`1023`
`968`	`1024`	`impl RuleRunner for crate::rules::import::no_absolute_path::NoAbsolutePath {`
`969`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`1025`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`1026`	`+ Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::ImportDeclaration]));`
`970`	`1027`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`971`	`1028`	`}`
`972`	`1029`
`@@ -2033,7 +2090,8 @@ impl RuleRunner for crate::rules::react::jsx_filename_extension::JsxFilenameExte`
`2033`	`2090`	`}`
`2034`	`2091`
`2035`	`2092`	`impl RuleRunner for crate::rules::react::jsx_fragments::JsxFragments {`
`2036`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`2093`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`2094`	`+ Some(&AstTypesBitset::from_types(&[AstType::JSXElement, AstType::JSXFragment]));`
`2037`	`2095`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`2038`	`2096`	`}`
`2039`	`2097`
`@@ -2300,7 +2358,11 @@ impl RuleRunner`
`2300`	`2358`	`impl RuleRunner`
`2301`	`2359`	`for crate::rules::typescript::consistent_type_definitions::ConsistentTypeDefinitions`
`2302`	`2360`	`{`
`2303`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`2361`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`2362`	`+ AstType::ExportDefaultDeclaration,`
	`2363`	`+ AstType::TSInterfaceDeclaration,`
	`2364`	`+ AstType::TSTypeAliasDeclaration,`
	`2365`	`+ ]));`
`2304`	`2366`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`2305`	`2367`	`}`
`2306`	`2368`
`@@ -2341,7 +2403,10 @@ impl RuleRunner for crate::rules::typescript::no_base_to_string::NoBaseToString`
`2341`	`2403`	`impl RuleRunner`
`2342`	`2404`	`for crate::rules::typescript::no_confusing_non_null_assertion::NoConfusingNonNullAssertion`
`2343`	`2405`	`{`
`2344`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`2406`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`2407`	`+ AstType::AssignmentExpression,`
	`2408`	`+ AstType::BinaryExpression,`
	`2409`	`+ ]));`
`2345`	`2410`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`2346`	`2411`	`}`
`2347`	`2412`
`@@ -2378,7 +2443,10 @@ impl RuleRunner for crate::rules::typescript::no_empty_interface::NoEmptyInterfa`
`2378`	`2443`	`}`
`2379`	`2444`
`2380`	`2445`	`impl RuleRunner for crate::rules::typescript::no_empty_object_type::NoEmptyObjectType {`
`2381`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`2446`	`+ const NODE_TYPES: Option<&AstTypesBitset> = Some(&AstTypesBitset::from_types(&[`
	`2447`	`+ AstType::TSInterfaceDeclaration,`
	`2448`	`+ AstType::TSTypeLiteral,`
	`2449`	`+ ]));`
`2382`	`2450`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`2383`	`2451`	`}`
`2384`	`2452`
`@@ -3134,7 +3202,8 @@ impl RuleRunner for crate::rules::unicorn::no_useless_switch_case::NoUselessSwit`
`3134`	`3202`	`}`
`3135`	`3203`
`3136`	`3204`	`impl RuleRunner for crate::rules::unicorn::no_useless_undefined::NoUselessUndefined {`
`3137`		`- const NODE_TYPES: Option<&AstTypesBitset> = None;`
	`3205`	`+ const NODE_TYPES: Option<&AstTypesBitset> =`
	`3206`	`+ Some(&AstTypesBitset::from_types(&[AstType::CallExpression, AstType::IdentifierReference]));`
`3138`	`3207`	`const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Run;`
`3139`	`3208`	`}`
`3140`	`3209`