code-gauge 10.4.0 → 10.4.1

package/native/src/complexity.rs

@@ -1,34 +1,38 @@
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashMap;
+use std::sync::OnceLock;
 use tree_sitter::Node;
 
-use crate::tree_index::NodeExt;
+use crate::languages::LANGUAGES;
+use crate::tree_index::{KindSet, NodeExt};
 use crate::types::CognitiveBlock;
 use crate::util::{all_children, node_text, Source};
 
-/// Node-type lookup sets built once per measurement from the language definition.
+/// Node-type lookup sets of a language.
 pub struct LanguageSets {
-    pub function_nodes: FxHashSet<&'static str>,
-    pub decision_nodes: FxHashSet<&'static str>,
-    pub nesting_nodes: FxHashSet<&'static str>,
-    pub ncss_nodes: FxHashSet<&'static str>,
-    pub ncss_containers: FxHashSet<&'static str>,
-    pub ncss_bare_body_parents: FxHashSet<&'static str>,
+    pub function_nodes: KindSet,
+    pub decision_nodes: KindSet,
+    pub nesting_nodes: KindSet,
+    pub ncss_nodes: KindSet,
+    pub ncss_containers: KindSet,
+    pub ncss_bare_body_parents: KindSet,
 }
 
 impl LanguageSets {
-    pub fn new(language: &crate::languages::LanguageDefinition) -> Self {
-        LanguageSets {
-            function_nodes: language.function_node_types.iter().copied().collect(),
-            decision_nodes: language.decision_node_types.iter().copied().collect(),
-            nesting_nodes: language.nesting_node_types.iter().copied().collect(),
-            ncss_nodes: language.ncss_node_types.iter().copied().collect(),
-            ncss_containers: language.ncss_container_node_types.iter().copied().collect(),
-            ncss_bare_body_parents: language
-                .ncss_bare_body_parent_node_types
-                .iter()
-                .copied()
-                .collect(),
-        }
+    pub fn of(language: &crate::languages::LanguageDefinition) -> &'static LanguageSets {
+        static SETS: [OnceLock<LanguageSets>; LANGUAGES.len()] =
+            [const { OnceLock::new() }; LANGUAGES.len()];
+        let index = LANGUAGES
+            .iter()
+            .position(|candidate| candidate.name == language.name)
+            .expect("every language is listed in LANGUAGES");
+        SETS[index].get_or_init(|| LanguageSets {
+            function_nodes: KindSet::new(language.function_node_types),
+            decision_nodes: KindSet::new(language.decision_node_types),
+            nesting_nodes: KindSet::new(language.nesting_node_types),
+            ncss_nodes: KindSet::new(language.ncss_node_types),
+            ncss_containers: KindSet::new(language.ncss_container_node_types),
+            ncss_bare_body_parents: KindSet::new(language.ncss_bare_body_parent_node_types),
+        })
     }
 }
 
@@ -54,15 +58,15 @@ pub fn is_lambda_body_block(node: Node<'_>) -> bool {
 /// A function node with a body of its own: bodyless declarations (abstract methods, auto-property
 /// accessors, accessor-list properties) open no nesting frame, so members inside them are not
 /// charged as nested functions.
-pub fn is_function_boundary(node: Node<'_>, function_nodes: &FxHashSet<&'static str>) -> bool {
-    function_nodes.contains(node.kind_name())
+pub fn is_function_boundary(node: Node<'_>, function_nodes: &KindSet) -> bool {
+    function_nodes.contains(node)
         && !is_lambda_body_block(node)
         && crate::functions::is_implemented_function(node)
 }
 
 // Sonar cognitive complexity charges a switch/match once as a whole, not per case label. Only
 // named nodes are consulted, so anonymous keyword tokens never match.
-const SWITCH_LIKE_NODE_TYPES: &[&str] = &[
+static SWITCH_LIKE_KINDS: KindSet = KindSet::new(&[
     "switch_statement",
     "switch_expression",
     "expression_switch_statement",
@@ -73,10 +77,10 @@ const SWITCH_LIKE_NODE_TYPES: &[&str] = &[
     "when_expression",
     "case",
     "case_match",
-];
+]);
 
 // Per-case decision nodes: cyclomatic-only, because the switch itself carries the cognitive cost.
-const CASE_CLAUSE_NODE_TYPES: &[&str] = &[
+static CASE_CLAUSE_KINDS: KindSet = KindSet::new(&[
     "case_clause",
     "switch_case",
     "switch_block_statement_group",
@@ -91,7 +95,7 @@ const CASE_CLAUSE_NODE_TYPES: &[&str] = &[
     "when_entry",
     "when",
     "in_clause",
-];
+]);
 
 const IF_LIKE_NODE_TYPES: &[&str] = &["if_statement", "if_expression", "if", "unless"];
 
@@ -303,13 +307,12 @@ impl FunctionBodyPass<'_, '_, '_> {
         let counts_for_own_body = !inside_nested_region && !opens_frame;
 
         let is_decision = self.is_decision(current);
-        let is_case_clause =
-            current.is_named() && CASE_CLAUSE_NODE_TYPES.contains(&current.kind_name());
+        let is_case_clause = current.is_named() && CASE_CLAUSE_KINDS.contains(current);
         // Ruby's `case ... else` arm is an `else` node; like every other language's default branch
         // it nests its contents inside the switch (it cannot go in the Ruby nesting set because
         // `if`/`begin` else branches would then double-nest under their already-nesting parent).
         let is_nesting = current.is_named()
-            && (self.sets.nesting_nodes.contains(current.kind_name())
+            && (self.sets.nesting_nodes.contains(current)
                 || (current.kind_name() == "else" && is_case_else_parent(parent)));
         // `elsif`/`elif`/`else if` continue a flat chain: they add a decision without a nesting
         // surcharge (Sonar cognitive-complexity semantics).
@@ -317,8 +320,7 @@ impl FunctionBodyPass<'_, '_, '_> {
         let is_boolean_operator = is_boolean_operator(current, parent, self.code);
         let is_pattern_guard = is_pattern_guard(current, parent);
 
-        let is_switch_like =
-            current.is_named() && SWITCH_LIKE_NODE_TYPES.contains(&current.kind_name());
+        let is_switch_like = current.is_named() && SWITCH_LIKE_KINDS.contains(current);
         // Opened before the node's own increments so that the block includes them. The sentinel
         // frame's blocks would be those of top-level code, which no function reports.
         if self.frames.len() > 1
@@ -513,8 +515,7 @@ impl FunctionBodyPass<'_, '_, '_> {
         // Anonymous keyword tokens can share a type with named nodes (Ruby's `if` node contains an
         // `if` keyword token), so only named nodes count as decisions.
         node.is_named()
-            && (self.sets.decision_nodes.contains(node.kind_name())
-                || crate::util::is_else_if_clause(node))
+            && (self.sets.decision_nodes.contains(node) || crate::util::is_else_if_clause(node))
             && !is_pathless_switch_branch(node)
     }
 

package/native/src/container.rs

@@ -1,4 +1,3 @@
-use rustc_hash::FxHashSet;
 use tree_sitter::Node;
 
 use crate::functions::{
@@ -6,7 +5,7 @@ use crate::functions::{
     find_string_literal_content, find_value_binding, is_value_group, next_declarator,
     unwrap_transparent_value_wrappers,
 };
-use crate::tree_index::NodeExt;
+use crate::tree_index::{KindSet, NodeExt};
 use crate::util::{named_children, node_text, Source};
 
 const CONTAINER_NODE_TYPES: &[&str] = &[
@@ -58,7 +57,7 @@ const CPP_SCOPE_NODE_TYPES: &[&str] = &[
 /// enclosing it.
 fn enclosing_cpp_scopes<'s>(
     node: Node<'_>,
-    function_nodes: &FxHashSet<&'static str>,
+    function_nodes: &KindSet,
     code: &Source<'s>,
     namespaces_only: bool,
 ) -> Vec<&'s str> {
@@ -98,7 +97,7 @@ fn explicit_ruby_owner(object: Option<Node<'_>>, code: &Source<'_>) -> Option<St
 /// method); or the path a JavaScript object literal holding it is bound to.
 pub fn find_container_name(
     node: Node<'_>,
-    function_nodes: &FxHashSet<&'static str>,
+    function_nodes: &KindSet,
     code: &Source<'_>,
     inline_namespaces: &InlineNamespaces<'_>,
 ) -> Option<String> {
@@ -201,7 +200,7 @@ fn assigns_attribute(assignment: Node<'_>, target: Node<'_>) -> bool {
 /// to nothing the syntax names.
 fn object_owner(
     object: Node<'_>,
-    function_nodes: &FxHashSet<&'static str>,
+    function_nodes: &KindSet,
     code: &Source<'_>,
     inline_namespaces: &InlineNamespaces<'_>,
 ) -> Option<String> {
@@ -293,7 +292,7 @@ fn find_qualified_declarator(node: Node<'_>) -> Option<Node<'_>> {
 fn cpp_spelled_owner(
     node: Node<'_>,
     qualified: Node<'_>,
-    function_nodes: &FxHashSet<&'static str>,
+    function_nodes: &KindSet,
     code: &Source<'_>,
     inline_namespaces: &InlineNamespaces<'_>,
 ) -> Option<String> {
@@ -431,7 +430,7 @@ fn holds_namespaces_without_scope(node: Node<'_>) -> bool {
 /// the function no member of it.
 fn enclosing_owner(
     node: Node<'_>,
-    function_nodes: &FxHashSet<&'static str>,
+    function_nodes: &KindSet,
     code: &Source<'_>,
     inline_namespaces: &InlineNamespaces<'_>,
 ) -> Option<String> {
@@ -463,7 +462,7 @@ fn enclosing_owner(
 fn spell_owner(
     container: Node<'_>,
     is_friend: bool,
-    function_nodes: &FxHashSet<&'static str>,
+    function_nodes: &KindSet,
     code: &Source<'_>,
     inline_namespaces: &InlineNamespaces<'_>,
 ) -> Option<String> {

package/native/src/dep_degree.rs

@@ -2,7 +2,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use tree_sitter::Node;
 
 use crate::complexity::is_function_boundary;
-use crate::tree_index::NodeExt;
+use crate::tree_index::{KindSet, NodeExt};
 use crate::util::{node_text, Source};
 
 /// Leaf node types treated as variable references by the def-use approximation.
@@ -89,65 +89,153 @@ const DEFINITION_LIST_HOLDER_TYPES: &[&str] = &[
 /// Parameter-position fields that annotate or initialize rather than bind (`x: T`, `x = default`).
 const NON_BINDING_PARAMETER_FIELDS: &[&str] = &["type", "value"];
 
-/// One leaf of the def-use walk: its field in the parent and its function-scope chain.
+/// One leaf of the def-use walk: its field in the parent and its function scope.
 struct DepDegreeLeaf<'t> {
     node: Node<'t>,
     field_name: Option<&'t str>,
-    /// Chain of nested-function scope ids below the measured function: "" for its own body,
-    /// then "/0", "/0/1", ...
-    scope: String,
+    /// Preorder number of the innermost function scope holding the leaf (see LeafWalk).
+    scope: usize,
 }
 
-/// Approximate def-use pairs of the function's subtree.
-pub fn measure_dep_degree(
-    function_node: Node<'_>,
+/// The non-comment leaves of a subtree in walk order, with the function scopes they lie in.
+struct LeafWalk<'t> {
+    leaves: Vec<DepDegreeLeaf<'t>>,
+    /// The last scope nested in each scope, by preorder number; scope 0 is the walked subtree's
+    /// own, and scope `outer` encloses scope `inner` exactly when
+    /// `outer <= inner && inner <= last_nested_scopes[outer]`.
+    last_nested_scopes: Vec<usize>,
+    /// The leaf range and body scope of each function, by node id, whose subtree the walk entered.
+    function_spans: FxHashMap<usize, (std::ops::Range<usize>, usize)>,
+}
+
+/// What a variable leaf does in the def-use walk, which depends only on the leaf and the leaf
+/// after it.
+#[derive(Clone, Copy)]
+struct VariableUse<'a> {
+    name: &'a str,
+    next_operator: Option<AssignmentOperator>,
+    /// Whether the leaf is a definition even when no assignment operator follows it.
+    is_binding: bool,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+enum AssignmentOperator {
+    Pure,
+    Compound,
+}
+
+/// Approximate def-use pairs of the subtree of each function in `functions`, by node id: one walk
+/// of the file gathers every function's leaves, since a function's leaves and the scopes they lie
+/// in are the same wherever the walk starts.
+pub fn measure_dep_degrees(
+    root: Node<'_>,
+    functions: &[Node<'_>],
     code: &Source<'_>,
-    function_nodes: &FxHashSet<&'static str>,
-) -> u64 {
-    let mut leaves = Vec::new();
-    let mut next_scope_id = 0usize;
-    collect_dep_degree_leaves(
-        function_node,
-        None,
-        "",
-        &mut next_scope_id,
+    function_nodes: &KindSet,
+) -> FxHashMap<usize, u64> {
+    let walk = LeafWalk::new(
+        root,
         function_nodes,
-        &mut leaves,
-        true,
+        &functions.iter().map(Node::id).collect(),
     );
-    let mut definition_scopes_by_name: FxHashMap<&str, Vec<String>> = FxHashMap::default();
+    let mut variable_uses = vec![None; walk.leaves.len()];
+    functions
+        .iter()
+        .map(|&function_node| {
+            let (leaf_range, body_scope) = walk
+                .function_spans
+                .get(&function_node.id())
+                .expect("the walk enters every function boundary");
+            let pairs = count_pairs(
+                &walk,
+                leaf_range.clone(),
+                *body_scope,
+                function_node,
+                code,
+                &mut variable_uses,
+            );
+            (function_node.id(), pairs)
+        })
+        .collect()
+}
+
+/// The def-use pairs among the leaves in `leaf_range` of the function whose own body is
+/// `body_scope`; `variable_uses` caches what each leaf of the walk does, as `Some(None)` for a
+/// leaf that is no variable.
+fn count_pairs<'a>(
+    walk: &LeafWalk<'_>,
+    leaf_range: std::ops::Range<usize>,
+    body_scope: usize,
+    function_node: Node<'_>,
+    code: &Source<'a>,
+    variable_uses: &mut [Option<Option<VariableUse<'a>>>],
+) -> u64 {
+    let is_visible = |definition_scopes: Option<&Vec<usize>>, scope: usize| {
+        definition_scopes.is_some_and(|scopes| {
+            scopes
+                .iter()
+                .any(|&outer| outer <= scope && scope <= walk.last_nested_scopes[outer])
+        })
+    };
+    let mut definition_scopes_by_name: FxHashMap<&str, Vec<usize>> = FxHashMap::default();
     for name in implicit_accessor_definitions(function_node, code) {
-        add_definition(&mut definition_scopes_by_name, name, "");
+        add_definition(&mut definition_scopes_by_name, name, body_scope);
     }
+    let leaf_end = leaf_range.end;
     let mut pairs = 0u64;
-    for index in 0..leaves.len() {
-        let leaf = &leaves[index];
-        if !is_variable_leaf(leaf) {
+    for index in leaf_range {
+        let leaf = &walk.leaves[index];
+        let Some(variable_use) =
+            *variable_uses[index].get_or_insert_with(|| variable_use(&walk.leaves, index, code))
+        else {
             continue;
-        }
-        let name = node_text(leaf.node, code);
-        let next_text = leaves.get(index + 1).map(|next| node_text(next.node, code));
-        if next_text.is_some_and(|next| COMPOUND_ASSIGNMENT_OPERATORS.contains(&next)) {
-            if is_definition_visible(definition_scopes_by_name.get(name), &leaf.scope) {
+        };
+        let name = variable_use.name;
+        // The function's last leaf has no next leaf within the function.
+        let next_operator = variable_use.next_operator.filter(|_| index + 1 != leaf_end);
+        if next_operator == Some(AssignmentOperator::Compound) {
+            if is_visible(definition_scopes_by_name.get(name), leaf.scope) {
                 pairs += 1;
             }
-            add_definition(&mut definition_scopes_by_name, name, &leaf.scope);
+            add_definition(&mut definition_scopes_by_name, name, leaf.scope);
             continue;
         }
-        if next_text.is_some_and(|next| PURE_ASSIGNMENT_OPERATORS.contains(&next))
-            || is_structural_definition(leaf)
-            || is_parameter_definition(leaf)
-        {
-            add_definition(&mut definition_scopes_by_name, name, &leaf.scope);
+        if next_operator == Some(AssignmentOperator::Pure) || variable_use.is_binding {
+            add_definition(&mut definition_scopes_by_name, name, leaf.scope);
             continue;
         }
-        if is_definition_visible(definition_scopes_by_name.get(name), &leaf.scope) {
+        if is_visible(definition_scopes_by_name.get(name), leaf.scope) {
             pairs += 1;
         }
     }
     pairs
 }
 
+fn variable_use<'a>(
+    leaves: &[DepDegreeLeaf<'_>],
+    index: usize,
+    code: &Source<'a>,
+) -> Option<VariableUse<'a>> {
+    let leaf = &leaves[index];
+    if !is_variable_leaf(leaf) {
+        return None;
+    }
+    let next_text = leaves.get(index + 1).map(|next| node_text(next.node, code));
+    Some(VariableUse {
+        name: node_text(leaf.node, code),
+        next_operator: next_text.and_then(|next| {
+            if COMPOUND_ASSIGNMENT_OPERATORS.contains(&next) {
+                Some(AssignmentOperator::Compound)
+            } else if PURE_ASSIGNMENT_OPERATORS.contains(&next) {
+                Some(AssignmentOperator::Pure)
+            } else {
+                None
+            }
+        }),
+        is_binding: is_structural_definition(leaf) || is_parameter_definition(leaf),
+    })
+}
+
 /// Kotlin spells type names as identifiers: in a `user_type`, or as a type parameter's fieldless
 /// name (C# puts its type parameter in a `name` field).
 fn is_variable_leaf(leaf: &DepDegreeLeaf<'_>) -> bool {
@@ -215,81 +303,86 @@ fn implicit_accessor_definitions<'a>(function_node: Node<'_>, code: &Source<'a>)
     names
 }
 
-/// Collects non-comment leaves with their parent field (one cursor pass, so children of
-/// high-arity nodes cost O(1)) and function-scope chain; mirrors collectDepDegreeLeaves.
-#[allow(clippy::too_many_arguments)]
-fn collect_dep_degree_leaves<'t>(
-    node: Node<'t>,
-    field_name: Option<&'t str>,
-    scope: &str,
-    next_scope_id: &mut usize,
-    function_nodes: &FxHashSet<&'static str>,
-    leaves: &mut Vec<DepDegreeLeaf<'t>>,
-    is_measured_root: bool,
-) {
-    if matches!(
-        node.kind_name(),
-        "comment" | "line_comment" | "block_comment"
-    ) {
-        return;
-    }
-    if crate::util::is_token(node) {
-        leaves.push(DepDegreeLeaf {
-            node,
-            field_name,
-            scope: scope.to_string(),
-        });
-        return;
+impl<'t> LeafWalk<'t> {
+    /// Walks the subtree of `root`, recording the span of each function in `function_ids` it
+    /// enters.
+    fn new(
+        root: Node<'t>,
+        function_nodes: &KindSet,
+        function_ids: &FxHashSet<usize>,
+    ) -> LeafWalk<'t> {
+        let mut walk = LeafWalk {
+            leaves: Vec::new(),
+            last_nested_scopes: vec![0],
+            function_spans: FxHashMap::default(),
+        };
+        walk.visit(root, None, 0, function_nodes, function_ids);
+        // The walked subtree's own scope encloses every scope opened inside it.
+        walk.last_nested_scopes[0] = walk.last_nested_scopes.len() - 1;
+        walk
     }
-    let child_scope = if !is_measured_root && is_function_boundary(node, function_nodes) {
-        let scope = format!("{scope}/{next_scope_id}");
-        *next_scope_id += 1;
-        scope
-    } else {
-        scope.to_string()
-    };
-    let mut cursor = node.walk();
-    if cursor.goto_first_child() {
-        loop {
-            collect_dep_degree_leaves(
-                cursor.node(),
-                cursor.field_name(),
-                &child_scope,
-                next_scope_id,
+
+    fn visit(
+        &mut self,
+        node: Node<'t>,
+        field_name: Option<&'t str>,
+        scope: usize,
+        function_nodes: &KindSet,
+        function_ids: &FxHashSet<usize>,
+    ) {
+        if matches!(
+            node.kind_name(),
+            "comment" | "line_comment" | "block_comment"
+        ) {
+            return;
+        }
+        if crate::util::is_token(node) {
+            self.leaves.push(DepDegreeLeaf {
+                node,
+                field_name,
+                scope,
+            });
+            return;
+        }
+        let opens_scope = is_function_boundary(node, function_nodes);
+        let child_scope = if opens_scope {
+            self.last_nested_scopes.push(0);
+            self.last_nested_scopes.len() - 1
+        } else {
+            scope
+        };
+        let first_leaf = self.leaves.len();
+        for (child, child_field_name) in crate::util::children_with_field_names(node) {
+            self.visit(
+                child,
+                child_field_name,
+                child_scope,
                 function_nodes,
-                leaves,
-                false,
+                function_ids,
             );
-            if !cursor.goto_next_sibling() {
-                break;
-            }
+        }
+        if opens_scope {
+            self.last_nested_scopes[child_scope] = self.last_nested_scopes.len() - 1;
+        }
+        // Every measured function is a function boundary.
+        if opens_scope && function_ids.contains(&node.id()) {
+            self.function_spans
+                .insert(node.id(), (first_leaf..self.leaves.len(), child_scope));
         }
     }
 }
 
 fn add_definition<'a>(
-    definition_scopes_by_name: &mut FxHashMap<&'a str, Vec<String>>,
+    definition_scopes_by_name: &mut FxHashMap<&'a str, Vec<usize>>,
     name: &'a str,
-    scope: &str,
+    scope: usize,
 ) {
     let scopes = definition_scopes_by_name.entry(name).or_default();
-    if !scopes.iter().any(|existing| existing == scope) {
-        scopes.push(scope.to_string());
+    if !scopes.contains(&scope) {
+        scopes.push(scope);
     }
 }
 
-/// A definition reaches a read only from the read's own or an enclosing function scope.
-fn is_definition_visible(definition_scopes: Option<&Vec<String>>, scope: &str) -> bool {
-    definition_scopes.is_some_and(|scopes| {
-        scopes.iter().any(|definition_scope| {
-            scope == definition_scope
-                || (scope.len() > definition_scope.len()
-                    && scope.starts_with(definition_scope.as_str())
-                    && scope.as_bytes()[definition_scope.len()] == b'/')
-        })
-    })
-}
-
 fn is_structural_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
     let Some(parent) = leaf.node.parent_node() else {
         return false;

package/native/src/functions.rs

@@ -4,6 +4,8 @@ use tree_sitter::Node;
 use crate::tree_index::NodeExt;
 use crate::util::{all_children, find_children_by_field_name, named_children, node_text, Source};
 
+// code-gauge-allow-file fileNcss 648 -- holds the function-recognition and naming rules of every language
+
 /// Declarations without a body have no control flow, so they are signatures, not functions: C++
 /// pure-virtual/`= default`/`= delete` members, abstract/interface/extern methods (Java, C#,
 /// Kotlin), Go assembly-backed function declarations, and Rust trait method signatures, matching
@@ -194,11 +196,11 @@ fn find_parameters_node(node: Node<'_>) -> Option<Node<'_>> {
     })
 }
 
-pub fn collect_nodes<'t>(root: Node<'t>, matches: impl Fn(&str) -> bool) -> Vec<Node<'t>> {
+pub fn collect_nodes<'t>(root: Node<'t>, matches: impl Fn(Node<'t>) -> bool) -> Vec<Node<'t>> {
     let mut nodes = Vec::new();
 
-    fn visit<'t>(node: Node<'t>, matches: &impl Fn(&str) -> bool, nodes: &mut Vec<Node<'t>>) {
-        if matches(node.kind_name()) {
+    fn visit<'t>(node: Node<'t>, matches: &impl Fn(Node<'t>) -> bool, nodes: &mut Vec<Node<'t>>) {
+        if matches(node) {
             nodes.push(node);
         }
 

package/native/src/languages.rs

@@ -36,7 +36,7 @@ enum GrammarId {
     Tsx,
 }
 
-const GRAMMAR_COUNT: usize = GrammarId::Tsx as usize + 1;
+pub const GRAMMAR_COUNT: usize = GrammarId::Tsx as usize + 1;
 
 impl LanguageDefinition {
     pub fn grammar(&self) -> Language {
@@ -56,6 +56,11 @@ impl LanguageDefinition {
         }
     }
 
+    /// Distinct for each grammar, below GRAMMAR_COUNT.
+    pub fn grammar_index(&self) -> usize {
+        self.grammar_id as usize
+    }
+
     /// The grammar's node kind names, indexed by kind id.
     pub fn kind_names(&self) -> &'static [String] {
         static KIND_NAMES: [OnceLock<Vec<String>>; GRAMMAR_COUNT] =