wip: skip rules that do not have any relevant node types

Author: camchenry

Cargo.lock

@@ -4,6 +4,7 @@
 use std::{path::Path, rc::Rc, sync::Arc};
 
 use oxc_allocator::Allocator;
+use oxc_ast::ast_kind::AST_TYPE_MAX;
 use oxc_semantic::{AstNode, Semantic};
 
 #[cfg(all(feature = "oxlint2", not(feature = "disable_oxlint2")))]
@@ -25,6 +26,7 @@ mod module_graph_visitor;
 mod module_record;
 mod options;
 mod rule;
+mod rule_runner_impls;
 mod service;
 mod tsgolint;
 mod utils;
@@ -56,7 +58,7 @@ pub use crate::{
     module_record::ModuleRecord,
     options::LintOptions,
     options::{AllowWarnDeny, InvalidFilterKind, LintFilter, LintFilterKind},
-    rule::{RuleCategory, RuleFixMeta, RuleMeta},
+    rule::{RuleCategory, RuleFixMeta, RuleMeta, RuleRunner},
     service::{LintService, LintServiceOptions, RuntimeFileSystem},
     tsgolint::TsGoLintState,
     utils::{read_to_arena_str, read_to_string},
@@ -167,7 +169,23 @@ impl Linter {
             // Collect rules into a Vec so that we can iterate over the rules multiple times
             let rules = rules.collect::<Vec<_>>();
 
+            // TODO: How should we preallocate this?
+            let mut rules_by_ast_type = vec![Vec::new(); AST_TYPE_MAX as usize + 1];
+            // TODO: compute needed capacity
+            let mut rules_any_ast_type = Vec::with_capacity(1024);
+
             for (rule, ctx) in &rules {
+                if rule.should_run(&ctx_host) {
+                    let (ast_types, all_types) = rule.types_info();
+                    if all_types {
+                        rules_any_ast_type.push((rule, ctx));
+                    } else {
+                        for ty in ast_types {
+                            rules_by_ast_type[ty as usize].push((rule, ctx));
+                        }
+                    }
+                }
+
                 rule.run_once(ctx);
             }
 
@@ -177,8 +195,12 @@ impl Linter {
                 }
             }
 
+            // Run rules on nodes
             for node in semantic.nodes() {
-                for (rule, ctx) in &rules {
+                for (rule, ctx) in &rules_by_ast_type[node.kind().ty() as usize] {
+                    rule.run(node, ctx);
+                }
+                for (rule, ctx) in &rules_any_ast_type {
                     rule.run(node, ctx);
                 }
             }
@@ -198,8 +220,17 @@ impl Linter {
                     rule.run_on_symbol(symbol, ctx);
                 }
 
-                for node in semantic.nodes() {
-                    rule.run(node, ctx);
+                let (ast_types, all_types) = rule.types_info();
+                if all_types {
+                    for node in semantic.nodes() {
+                        rule.run(node, ctx)
+                    }
+                } else {
+                    for node in semantic.nodes() {
+                        if ast_types.has(node.kind().ty()) {
+                            rule.run(node, ctx);
+                        }
+                    }
                 }
 
                 if should_run_on_jest_node {

crates/oxc_linter/src/lib.rs

@@ -5,7 +5,7 @@ use std::{fmt, hash::Hash};
 use schemars::{JsonSchema, SchemaGenerator, schema::Schema};
 use serde::{Deserialize, Serialize};
 
-use oxc_semantic::SymbolId;
+use oxc_semantic::{AstTypesBitset, SymbolId};
 
 use crate::{
     AstNode, FixKind,
@@ -66,6 +66,16 @@ pub trait Rule: Sized + Default + fmt::Debug {
     }
 }
 
+pub trait RuleRunner: Rule {
+    /// `AstType`s that rule acts on
+    const NODE_TYPES: &AstTypesBitset;
+    /// `true` if codegen can't figure out what node types rule acts on
+    const ANY_NODE_TYPE: bool;
+
+    fn types_info(&self) -> (&'static AstTypesBitset, bool) {
+        (Self::NODE_TYPES, Self::ANY_NODE_TYPE)
+    }
+}
 pub trait RuleMeta {
     const NAME: &'static str;
 
@@ -279,6 +289,8 @@ impl From<RuleFixMeta> for FixKind {
 
 #[cfg(test)]
 mod test {
+    use crate::{RuleMeta, RuleRunner};
+
     use super::RuleCategory;
 
     #[test]
@@ -322,4 +334,83 @@ mod test {
             assert_eq!(de, RuleCategory::try_from(input).unwrap(), "{input}");
         }
     }
+
+    #[test]
+    fn test_rule_runner_impls() {
+        use crate::rules::*;
+        use oxc_ast::AstType::*;
+
+        // The RuleRunner code is automatically generated by the `oxc_linter_codegen` crate.
+        // This is set of manually verified test cases to ensure that the generated code
+        // is working as expected and is not skipping rules for nodes that actually should be linted.
+        assert_rule_runs_on_node_types(&eslint::no_debugger::NoDebugger, &[DebuggerStatement]);
+        assert_rule_runs_on_node_types(&eslint::no_with::NoWith, &[WithStatement]);
+        assert_rule_runs_on_node_types(
+            &eslint::curly::Curly::default(),
+            &[
+                IfStatement,
+                ForStatement,
+                ForInStatement,
+                ForOfStatement,
+                WhileStatement,
+                DoWhileStatement,
+            ],
+        );
+        assert_rule_runs_on_node_types(
+            &eslint::default_case::DefaultCase::default(),
+            &[SwitchStatement],
+        );
+        assert_rule_runs_on_node_types(
+            &import::no_mutable_exports::NoMutableExports,
+            &[ExportNamedDeclaration, ExportDefaultDeclaration],
+        );
+        assert_rule_runs_on_node_types(
+            &jest::prefer_jest_mocked::PreferJestMocked,
+            &[TSAsExpression, TSTypeAssertion],
+        );
+        assert_rule_runs_on_node_types(
+            &jsx_a11y::anchor_is_valid::AnchorIsValid::default(),
+            &[JSXElement],
+        );
+        assert_rule_runs_on_node_types(
+            &nextjs::no_head_element::NoHeadElement,
+            &[JSXOpeningElement],
+        );
+        assert_rule_runs_on_node_types(
+            &oxc::bad_bitwise_operator::BadBitwiseOperator,
+            &[BinaryExpression, AssignmentExpression],
+        );
+        assert_rule_runs_on_node_types(
+            &promise::prefer_await_to_callbacks::PreferAwaitToCallbacks,
+            &[CallExpression, Function, ArrowFunctionExpression],
+        );
+        assert_rule_runs_on_node_types(
+            &react::button_has_type::ButtonHasType::default(),
+            &[JSXOpeningElement, CallExpression],
+        );
+        assert_rule_runs_on_node_types(
+            &typescript::ban_types::BanTypes,
+            &[TSTypeReference, TSTypeLiteral],
+        );
+        assert_rule_runs_on_node_types(
+            &unicorn::explicit_length_check::ExplicitLengthCheck::default(),
+            &[StaticMemberExpression],
+        );
+    }
+
+    fn assert_rule_runs_on_node_types<R: RuleMeta + RuleRunner>(
+        rule: &R,
+        node_types: &[oxc_ast::AstType],
+    ) {
+        let (types, _) = rule.types_info();
+        assert!(!R::ANY_NODE_TYPE, "{} should not have ANY_NODE_TYPE set to true", R::NAME);
+        for node_type in node_types {
+            assert!(
+                types.has(*node_type),
+                "{}: missing {:?} in its NODE_TYPES (this means it will incorrectly skip nodes it needs to lint)",
+                R::NAME,
+                node_type
+            );
+        }
+    }
 }