code-gauge 4.7.0 → 4.8.0

package/native/src/ncss.rs

@@ -1,23 +1,17 @@
-use std::collections::HashSet;
+use rustc_hash::FxHashSet;
 use tree_sitter::Node;
 
-use crate::util::{all_children, find_children_by_field_name};
+use crate::tree_index::NodeExt;
+use crate::util::find_children_by_field_name;
 
-pub const COMMENT_NODE_TYPES: &[&str] = &[
-    "comment",
-    "line_comment",
-    "block_comment",
-    "multiline_comment",
-];
+pub const COMMENT_NODE_TYPES: &[&str] = &["comment", "line_comment", "block_comment"];
 
 /// Nodes never counted positionally inside NCSS containers: metadata, empty statements, Ruby
 /// heredoc bodies (tree-sitter emits them as siblings of the statement that opened the heredoc),
-/// Ruby statement parentheses (transparent wrappers whose children count instead), Kotlin
-/// annotations (siblings of the statement they decorate), and Kotlin enum entries (Java enum
-/// constants are not counted either). Two Kotlin kinds are excluded contextually below because
-/// Rust shares their names: `try_expression` (Rust's `?` operator must keep counting as a tail
-/// expression) and `label` (a Rust block label `'outer:` stands for the labeled statement the
-/// other languages count, while a Kotlin `outer@` is a childless token beside its statement).
+/// Ruby statement parentheses (transparent wrappers whose children count instead), Kotlin enum
+/// entries (Java enum constants are not counted either), and Kotlin lambda parameters (siblings of
+/// the lambda's statements). Kotlin's `try_expression` is excluded contextually below because Rust
+/// shares its name: Rust's `?` operator must keep counting as a tail expression.
 const POSITIONAL_EXCLUSION_TYPES: &[&str] = &[
     "attribute_item",
     "inner_attribute_item",
@@ -26,8 +20,9 @@ const POSITIONAL_EXCLUSION_TYPES: &[&str] = &[
     "parenthesized_statements",
     "annotation",
     "file_annotation",
-    "shebang_line",
+    "shebang",
     "enum_entry",
+    "lambda_parameters",
 ];
 
 /// TypeScript interface members count like Java interface members, but the same node types appear
@@ -56,80 +51,67 @@ const BODYLESS_NCSS_SPECIFIER_TYPES: &[&str] = &[
     "class_specifier",
 ];
 
-/// Counts non-commenting source statements (NCSS) in the subtree, PMD-style: one per declaration,
+/// A node's own non-commenting source statement (NCSS) count, PMD-style: one per declaration,
 /// statement, and clause (`else`, `case`/`default` label, `catch`, `finally`, try-with-resources
-/// resource); `try` itself, braces, blank lines, and comments count 0.
-pub fn count_ncss(
-    node: Node<'_>,
-    countable: &HashSet<&'static str>,
-    containers: &HashSet<&'static str>,
-) -> u64 {
-    fn visit(
-        current: Node<'_>,
-        countable: &HashSet<&'static str>,
-        containers: &HashSet<&'static str>,
-        count: &mut u64,
-    ) {
-        *count += ncss_contribution(current, countable, containers);
-        for child in all_children(current) {
-            visit(child, countable, containers, count);
-        }
-    }
-
-    let mut count = 0;
-    visit(node, countable, containers, &mut count);
-    count
-}
-
+/// resource); `try` itself, braces, blank lines, and comments count 0. `parent` is the node's
+/// `parent_node()`, looked up once by the caller and shared by every check.
 pub fn ncss_contribution(
     node: Node<'_>,
-    countable: &HashSet<&'static str>,
-    containers: &HashSet<&'static str>,
+    parent: Option<Node<'_>>,
+    countable: &FxHashSet<&'static str>,
+    containers: &FxHashSet<&'static str>,
+    bare_body_parents: &FxHashSet<&'static str>,
 ) -> u64 {
-    if !node.is_named() || COMMENT_NODE_TYPES.contains(&node.kind()) || is_for_header_node(node) {
+    if !node.is_named()
+        || COMMENT_NODE_TYPES.contains(&node.kind_name())
+        || is_for_header_node(node, parent)
+    {
         return 0;
     }
     // A Kotlin accessor without a body (`private set`) only changes visibility and declares
-    // nothing of its own; it parses as a sibling of its property and must not count positionally.
-    if (node.kind() == "getter" || node.kind() == "setter")
+    // nothing of its own, so it must not count through its node type.
+    if (node.kind_name() == "getter" || node.kind_name() == "setter")
         && !crate::functions::is_implemented_function(node)
     {
         return 0;
     }
 
     let mut contribution = 0;
-    let positional = is_in_container_position(node, containers)
-        && !containers.contains(node.kind())
-        && !POSITIONAL_EXCLUSION_TYPES.contains(&node.kind())
-        && !crate::util::is_kotlin_try_expression(node)
-        && !(node.kind() == "label" && node.child_count() == 0);
-    if (counts_through_node_type(node, countable) || positional || counts_contextually(node))
+    // A Kotlin lambda holds its statements directly, so it is a container, yet it still counts where
+    // it stands like any other expression.
+    let positional = (is_in_container_position(parent, containers)
+        || is_bare_body(node, parent, bare_body_parents))
+        && (!containers.contains(node.kind_name()) || node.kind_name() == "lambda_literal")
+        && !POSITIONAL_EXCLUSION_TYPES.contains(&node.kind_name())
+        && !crate::util::is_kotlin_try_expression(node);
+    if (counts_through_node_type(node, countable)
+        || positional
+        || counts_contextually(node, parent))
         && !is_declaration_wrapper(node, countable)
     {
         contribution += 1;
     }
 
-    // A bare else branch (Java/Go `alternative:` without an else-clause wrapper, or Kotlin's bare
-    // `else` keyword) counts 1 like the `else` keyword does in PMD; an `else if` chain charges the
-    // nested if separately on top.
-    if IF_NODE_TYPES.contains(&node.kind()) {
-        contribution += count_bare_alternatives(node)
-            + u64::from(crate::util::kotlin_else_body(node).is_some());
+    // A bare else branch (Java/Go/Kotlin `alternative:` without an else-clause wrapper) counts 1
+    // like the `else` keyword does in PMD; an `else if` chain charges the nested if separately on
+    // top.
+    if IF_NODE_TYPES.contains(&node.kind_name()) {
+        contribution += count_bare_alternatives(node);
     }
 
     contribution
 }
 
-fn counts_through_node_type(node: Node<'_>, countable: &HashSet<&'static str>) -> bool {
-    if !countable.contains(node.kind()) {
+fn counts_through_node_type(node: Node<'_>, countable: &FxHashSet<&'static str>) -> bool {
+    if !countable.contains(node.kind_name()) {
         return false;
     }
-    if BODYLESS_NCSS_SPECIFIER_TYPES.contains(&node.kind()) {
+    if BODYLESS_NCSS_SPECIFIER_TYPES.contains(&node.kind_name()) {
         return node.child_by_field_name("body").is_some();
     }
     // A try-with-resources `resource` counts only when it declares a variable; `try (r)` reuses an
     // existing one and adds no statement (matching PMD).
-    if node.kind() == "resource" {
+    if node.kind_name() == "resource" {
         return node.child_by_field_name("name").is_some();
     }
     true
@@ -137,28 +119,44 @@ fn counts_through_node_type(node: Node<'_>, countable: &HashSet<&'static str>) -
 
 /// Direct container children count positionally; Ruby's `(foo; bar)` statement parentheses are
 /// transparent, so their children count when the parentheses themselves sit in a container.
-fn is_in_container_position(node: Node<'_>, containers: &HashSet<&'static str>) -> bool {
-    let mut ancestor = node.parent();
+fn is_in_container_position(
+    parent: Option<Node<'_>>,
+    containers: &FxHashSet<&'static str>,
+) -> bool {
+    let mut ancestor = parent;
     while let Some(current) = ancestor {
-        if current.kind() != "parenthesized_statements" {
-            return containers.contains(current.kind());
+        if current.kind_name() != "parenthesized_statements" {
+            return containers.contains(current.kind_name());
         }
-        ancestor = current.parent();
+        ancestor = current.parent_node();
     }
     false
 }
 
+/// A braceless branch or loop body (`if (x) foo()`) stands for the single statement a braced body
+/// would hold.
+fn is_bare_body(
+    node: Node<'_>,
+    parent: Option<Node<'_>>,
+    bare_body_parents: &FxHashSet<&'static str>,
+) -> bool {
+    parent.is_some_and(|parent| bare_body_parents.contains(parent.kind_name()))
+        && ["consequence", "alternative", "body"]
+            .iter()
+            .any(|field_name| is_field_of_parent(node, parent, field_name))
+}
+
 /// `export const x = 1` nests a countable declaration inside `export_statement`; only the inner
 /// declaration counts, mirroring how PMD counts one statement per declared entity.
-fn is_declaration_wrapper(node: Node<'_>, countable: &HashSet<&'static str>) -> bool {
-    if node.kind() != "export_statement" {
+fn is_declaration_wrapper(node: Node<'_>, countable: &FxHashSet<&'static str>) -> bool {
+    if node.kind_name() != "export_statement" {
         return false;
     }
     node.child_by_field_name("declaration")
         .is_some_and(|declaration| {
-            countable.contains(declaration.kind())
-                || declaration.kind() == "internal_module"
-                || declaration.kind() == "ambient_declaration"
+            countable.contains(declaration.kind_name())
+                || declaration.kind_name() == "internal_module"
+                || declaration.kind_name() == "ambient_declaration"
         })
 }
 
@@ -169,21 +167,21 @@ const FOR_HEADER_FIELD_NAMES: &[&str] =
 /// statement, which already counts; PMD does not count them separately. JavaScript parses the
 /// condition as an `expression_statement` and Go parses the update as an `inc_statement`, so all
 /// header fields must be excluded, not just the initializer.
-fn is_for_header_node(node: Node<'_>) -> bool {
-    let Some(parent) = node.parent() else {
+fn is_for_header_node(node: Node<'_>, parent: Option<Node<'_>>) -> bool {
+    let Some(parent) = parent else {
         return false;
     };
     // C++20 range-for initializers nest one level deeper: for_range_loop > init_statement > node.
-    if parent.kind() == "init_statement"
+    if parent.kind_name() == "init_statement"
         && parent
-            .parent()
-            .is_some_and(|grandparent| grandparent.kind() == "for_range_loop")
+            .parent_node()
+            .is_some_and(|grandparent| grandparent.kind_name() == "for_range_loop")
     {
         return true;
     }
-    if parent.kind() != "for_statement"
-        && parent.kind() != "for_clause"
-        && parent.kind() != "for_range_loop"
+    if parent.kind_name() != "for_statement"
+        && parent.kind_name() != "for_clause"
+        && parent.kind_name() != "for_range_loop"
     {
         return false;
     }
@@ -195,52 +193,54 @@ fn is_for_header_node(node: Node<'_>) -> bool {
 }
 
 /// Statements only countable by their position: constructs without a dedicated statement node.
-fn counts_contextually(node: Node<'_>) -> bool {
-    let parent_kind = node.parent().map(|parent| parent.kind());
+fn counts_contextually(node: Node<'_>, parent: Option<Node<'_>>) -> bool {
+    let parent_kind = parent.map(|parent| parent.kind_name());
     // A Java instance initializer is a bare `block` in the class body; PMD counts it like the
     // `static_initializer` declaration it parallels.
-    if node.kind() == "block" && parent_kind == Some("class_body") {
+    if node.kind_name() == "block" && parent_kind == Some("class_body") {
         return true;
     }
     // TypeScript interface members (see INTERFACE_MEMBER_NODE_TYPES).
-    if INTERFACE_MEMBER_NODE_TYPES.contains(&node.kind()) && parent_kind == Some("interface_body") {
+    if INTERFACE_MEMBER_NODE_TYPES.contains(&node.kind_name())
+        && parent_kind == Some("interface_body")
+    {
         return true;
     }
     // A braceless Rust match-arm body (`1 => foo()`) has no expression_statement wrapper; count the
     // value expression so braced and unbraced arms measure alike.
     if parent_kind == Some("match_arm")
-        && node.kind() != "block"
-        && is_field_of_parent(node, "value")
+        && node.kind_name() != "block"
+        && is_field_of_parent(node, parent, "value")
     {
         return true;
     }
     // A TypeScript class-body method overload signature declares a member like its interface twin.
-    if node.kind() == "method_signature" && parent_kind == Some("class_body") {
+    if node.kind_name() == "method_signature" && parent_kind == Some("class_body") {
         return true;
     }
     // An ambient `declare namespace M { ... }` is a bare `internal_module`; the non-ambient
     // `namespace N { ... }` is wrapped in an `expression_statement`, which already counts.
-    if node.kind() == "internal_module" && parent_kind != Some("expression_statement") {
+    if node.kind_name() == "internal_module" && parent_kind != Some("expression_statement") {
         return true;
     }
     // A Ruby endless method (`def f(x) = expr`) stores its single-statement body directly in the
     // `body` field instead of a positional `body_statement` container.
     if (parent_kind == Some("method") || parent_kind == Some("singleton_method"))
-        && node.kind() != "body_statement"
-        && is_field_of_parent(node, "body")
+        && node.kind_name() != "body_statement"
+        && is_field_of_parent(node, parent, "body")
     {
         return true;
     }
     // C++ `friend class X;` declares on its own; `friend void g() { ... }` merely wraps a counted
     // definition.
-    if node.kind() == "friend_declaration" {
-        return !crate::util::named_children(node)
-            .iter()
-            .any(|child| child.kind() == "declaration" || child.kind() == "function_definition");
+    if node.kind_name() == "friend_declaration" {
+        return !crate::util::named_children(node).iter().any(|child| {
+            child.kind_name() == "declaration" || child.kind_name() == "function_definition"
+        });
     }
     // A Rust item-position macro invocation (`foo! {}` at module level) has no expression_statement
     // wrapper; the semicolon form does and already counts through it.
-    if node.kind() == "macro_invocation"
+    if node.kind_name() == "macro_invocation"
         && (parent_kind == Some("source_file") || parent_kind == Some("declaration_list"))
     {
         return true;
@@ -248,29 +248,33 @@ fn counts_contextually(node: Node<'_>) -> bool {
     // Go struct fields and interface members count like other languages' member declarations, but
     // only inside a named type declaration; inline anonymous types (`var x struct{ ... }`,
     // `func f(h interface{ ... })`) are part of one declaration.
-    if node.kind() == "field_declaration" && parent_kind == Some("field_declaration_list") {
+    if node.kind_name() == "field_declaration" && parent_kind == Some("field_declaration_list") {
         return is_go_declared_type_body(
-            node.parent().and_then(|parent| parent.parent()),
+            parent.and_then(|parent| parent.parent_node()),
             "struct_type",
         );
     }
-    if node.kind() == "method_elem" || node.kind() == "method_spec" || node.kind() == "type_elem" {
-        return is_go_declared_type_body(node.parent(), "interface_type");
+    if node.kind_name() == "method_elem"
+        || node.kind_name() == "method_spec"
+        || node.kind_name() == "type_elem"
+    {
+        return is_go_declared_type_body(parent, "interface_type");
     }
     false
 }
 
 fn is_go_declared_type_body(type_node: Option<Node<'_>>, expected_kind: &str) -> bool {
-    let Some(type_node) = type_node.filter(|type_node| type_node.kind() == expected_kind) else {
+    let Some(type_node) = type_node.filter(|type_node| type_node.kind_name() == expected_kind)
+    else {
         return false;
     };
-    type_node
-        .parent()
-        .is_some_and(|parent| parent.kind() == "type_spec" || parent.kind() == "type_alias")
+    type_node.parent_node().is_some_and(|parent| {
+        parent.kind_name() == "type_spec" || parent.kind_name() == "type_alias"
+    })
 }
 
-fn is_field_of_parent(node: Node<'_>, field_name: &str) -> bool {
-    let Some(parent) = node.parent() else {
+fn is_field_of_parent(node: Node<'_>, parent: Option<Node<'_>>, field_name: &str) -> bool {
+    let Some(parent) = parent else {
         return false;
     };
     find_children_by_field_name(parent, field_name)
@@ -283,6 +287,6 @@ fn count_bare_alternatives(node: Node<'_>) -> u64 {
     // comment between an `elif_clause` and `else_clause` must not be miscounted as a bare branch.
     find_children_by_field_name(node, "alternative")
         .iter()
-        .filter(|child| !child.is_extra() && !ELSE_CLAUSE_NODE_TYPES.contains(&child.kind()))
+        .filter(|child| !child.is_extra() && !ELSE_CLAUSE_NODE_TYPES.contains(&child.kind_name()))
         .count() as u64
 }

package/native/src/near_miss.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use rustc_hash::{FxHashMap, FxHashSet};
 
 /// N-gram size for the candidate index and local-match anchors (NIL's default); shared with
 /// crossFileNearMiss.ts.
@@ -40,7 +40,7 @@ pub(crate) struct Block {
     is_content: Vec<bool>,
     /// Identifiers anonymized by first occurrence within the block.
     sequence: Vec<i32>,
-    pub ngrams: HashSet<i32>,
+    pub ngrams: FxHashSet<i32>,
     /// The n-grams occurring exactly once in the block with their offsets, sorted by hash so two
     /// blocks' local-match anchors intersect by merging.
     unique_ngrams: Vec<(i32, usize)>,
@@ -77,7 +77,7 @@ impl Block {
                 })
             })
             .collect();
-        let mut occurrence_counts: HashMap<i32, usize> = HashMap::new();
+        let mut occurrence_counts: FxHashMap<i32, usize> = FxHashMap::default();
         for &hash in &ngram_hashes {
             *occurrence_counts.entry(hash).or_insert(0) += 1;
         }
@@ -134,13 +134,13 @@ pub(crate) struct Matcher {
     /// capped at MAX_CONTENT_WEIGHT.
     /// Rare names and values (the logic a copy preserves) outweigh ubiquitous ones, following
     /// the information-theoretic weighting of ECScan's essence-clone detection (2025).
-    weights: HashMap<i32, u64>,
+    weights: FxHashMap<i32, u64>,
 }
 
 impl Matcher {
     /// Weights every block's content counts, which verification requires.
     pub fn new(blocks: &mut [Block], min_tokens: usize, min_similarity_percent: usize) -> Matcher {
-        let mut document_frequencies: HashMap<i32, usize> = HashMap::new();
+        let mut document_frequencies: FxHashMap<i32, usize> = FxHashMap::default();
         for block in blocks.iter() {
             for &(symbol, _) in &block.content {
                 *document_frequencies.entry(symbol).or_insert(0) += 1;
@@ -347,7 +347,7 @@ fn anchored_token_count(segment: &[(usize, usize)]) -> usize {
 /// Identifiers renumbered by first occurrence within `symbols`, so a range compares the same
 /// wherever it sits in its file.
 fn anonymize(symbols: &[i32]) -> Vec<i32> {
-    let mut index_by_identifier: HashMap<i32, i32> = HashMap::new();
+    let mut index_by_identifier: FxHashMap<i32, i32> = FxHashMap::default();
     symbols
         .iter()
         .map(|&symbol| {
@@ -427,7 +427,7 @@ fn lcs_length(a: &[i32], b: &[i32]) -> usize {
         return 0;
     }
     let word_count = a.len().div_ceil(64);
-    let mut position_masks: HashMap<i32, Vec<u64>> = HashMap::new();
+    let mut position_masks: FxHashMap<i32, Vec<u64>> = FxHashMap::default();
     for (index, &symbol) in a.iter().enumerate() {
         position_masks
             .entry(symbol)

package/native/src/tree_index.rs

@@ -0,0 +1,119 @@
+use std::cell::{Cell, RefCell};
+use std::marker::PhantomData;
+
+use rustc_hash::FxHashMap;
+use tree_sitter::{Node, Tree};
+
+use crate::languages::LanguageDefinition;
+
+thread_local! {
+    /// Node id -> parent for the tree indexed on this thread. The lifetime is erased to store the
+    /// nodes; TreeIndex borrows the tree and clears the map on drop, so no entry outlives it.
+    static PARENTS: RefCell<FxHashMap<usize, Node<'static>>> = RefCell::new(FxHashMap::default());
+    /// Node kind names of the indexed tree's language, indexed by kind id.
+    static KIND_NAMES: Cell<&'static [&'static str]> = const { Cell::new(&[]) };
+    /// Name of the indexed tree's language.
+    static LANGUAGE_NAME: Cell<&'static str> = const { Cell::new("") };
+}
+
+/// The language of the tree indexed on this thread, or "" when none is.
+pub fn language_name() -> &'static str {
+    LANGUAGE_NAME.get()
+}
+
+/// Makes NodeExt lookups O(1) while the tree is being measured: tree-sitter's `Node::parent`
+/// rescans from the root on every call (linear in the sibling counts along the path), and
+/// `Node::kind` measures and UTF-8-validates the C string on every call.
+pub struct TreeIndex<'t> {
+    tree: PhantomData<&'t Tree>,
+}
+
+/// The metric passes recurse per tree level and would overflow the native stack (a
+/// process-killing SIGSEGV, not a catchable error) around depth ~20k, so deeper trees are refused.
+const MAX_TREE_DEPTH: usize = 5_000;
+
+impl<'t> TreeIndex<'t> {
+    pub fn new(tree: &'t Tree, language: &LanguageDefinition) -> Result<TreeIndex<'t>, String> {
+        // Constructed first so that the depth error below also clears the partial index on drop.
+        let index = TreeIndex { tree: PhantomData };
+        KIND_NAMES.set(language.kind_names());
+        LANGUAGE_NAME.set(language.name);
+        PARENTS.with_borrow_mut(|parents| {
+            assert!(
+                parents.is_empty(),
+                "one tree is indexed per thread at a time"
+            );
+            let mut cursor = tree.walk();
+            let mut stack: Vec<Node<'static>> = Vec::new();
+            loop {
+                let node = erase_lifetime(cursor.node());
+                if let Some(&parent) = stack.last() {
+                    parents.insert(node.id(), parent);
+                }
+                if cursor.goto_first_child() {
+                    stack.push(node);
+                    if stack.len() > MAX_TREE_DEPTH {
+                        return Err(format!("tree depth exceeds {MAX_TREE_DEPTH}"));
+                    }
+                    continue;
+                }
+                while !cursor.goto_next_sibling() {
+                    if !cursor.goto_parent() {
+                        return Ok(());
+                    }
+                    stack.pop();
+                }
+            }
+        })?;
+        Ok(index)
+    }
+}
+
+impl Drop for TreeIndex<'_> {
+    fn drop(&mut self) {
+        PARENTS.with_borrow_mut(|parents| parents.clear());
+        KIND_NAMES.set(&[]);
+        LANGUAGE_NAME.set("");
+    }
+}
+
+fn erase_lifetime(node: Node<'_>) -> Node<'static> {
+    // SAFETY: Node only borrows its tree; the erased node is stored in PARENTS, which the
+    // TreeIndex borrowing that tree empties before the tree can be dropped.
+    unsafe { std::mem::transmute::<Node<'_>, Node<'static>>(node) }
+}
+
+pub trait NodeExt<'t> {
+    /// `Node::parent`, answered from the TreeIndex when one is installed.
+    fn parent_node(self) -> Option<Node<'t>>;
+    /// `Node::kind`, answered from the TreeIndex when one is installed.
+    fn kind_name(self) -> &'static str;
+}
+
+impl<'t> NodeExt<'t> for Node<'t> {
+    fn parent_node(self) -> Option<Node<'t>> {
+        // tree-sitter locates the parent by byte range, which for a zero-width node (a MISSING
+        // token, an empty construct) can select a sibling touching the same offset instead of the
+        // structural parent; those rare nodes keep tree-sitter's answer so metrics stay unchanged.
+        if self.start_byte() == self.end_byte() {
+            return self.parent();
+        }
+        PARENTS
+            .with_borrow(|parents| {
+                parents.get(&self.id()).map(|parent| {
+                    // SAFETY: ids are addresses inside the indexed tree, which outlives the
+                    // index, so a hit means `parent` belongs to the tree `self` borrows.
+                    unsafe { std::mem::transmute::<Node<'static>, Node<'t>>(*parent) }
+                })
+            })
+            .or_else(|| self.parent())
+    }
+
+    fn kind_name(self) -> &'static str {
+        KIND_NAMES
+            .get()
+            .get(usize::from(self.kind_id()))
+            .copied()
+            .unwrap_or_else(|| self.kind())
+    }
+}

package/native/src/util.rs

@@ -1,5 +1,7 @@
 use tree_sitter::Node;
 
+use crate::tree_index::NodeExt;
+
 /// The measured source. Trees are parsed from UTF-16 (matching node-tree-sitter, which parses
 /// JavaScript strings as UTF-16 — tree-sitter's error recovery can differ between encodings), so
 /// node "byte" offsets and columns are UTF-16 code units x 2; this maps them back to UTF-8 slices
@@ -51,30 +53,12 @@ pub fn node_text<'a>(node: Node<'_>, code: &Source<'a>) -> &'a str {
     &code.code[code.utf8_offset(node.start_byte())..code.utf8_offset(node.end_byte())]
 }
 
-/// Kotlin spells the bound receiver of a callable reference (`xs::size`) as a `type_identifier`,
-/// the same kind as an unbound type (`List::size`); the receiver position is what distinguishes
-/// it, and only a visible definition then tells a variable from a type.
-pub fn is_kotlin_callable_receiver(node: Node<'_>) -> bool {
-    node.kind() == "type_identifier"
-        && node.parent().is_some_and(|parent| {
-            parent.kind() == "callable_reference"
-                && parent
-                    .named_child(0)
-                    .is_some_and(|first| first.id() == node.id())
-        })
-}
-
-/// Whether the node is a leaf for token-level walks. Kotlin soft keywords used as names (`value`,
-/// `data`, `get`, ...) parse as a `simple_identifier` — or its aliases `interpolated_identifier`
-/// (`"$value"`) and `type_identifier` (`value::size`) — wrapping an anonymous keyword token, so a
-/// plain leaf check would see the keyword instead of the identifier. Every other grammar's
-/// identifier kinds are already leaves.
-pub fn is_identifier_leaf(node: Node<'_>) -> bool {
-    node.child_count() == 0
-        || matches!(
-            node.kind(),
-            "simple_identifier" | "interpolated_identifier" | "type_identifier"
-        )
+/// Kotlin spells `true`, `false`, and `null` as plain identifiers, which the other grammars give
+/// literal node kinds of their own (an identifier with that text, e.g. Go's `null`, is a variable).
+pub fn is_kotlin_keyword_literal(node: Node<'_>, code: &Source<'_>) -> bool {
+    crate::tree_index::language_name() == "kotlin"
+        && node.kind_name() == "identifier"
+        && matches!(node_text(node, code), "true" | "false" | "null")
 }
 
 pub fn named_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
@@ -89,8 +73,8 @@ pub fn all_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
 
 /// Children carrying the field, with node-tree-sitter's vendored-core semantics: extra children
 /// (error-recovery nodes, comments) inherit the field of the preceding structural sibling.
-/// tree-sitter 0.22.6 instead reports no field for extras (ts_node_field_name_for_child gained an
-/// is_extra early return), which would desynchronize field-based extraction on malformed source.
+/// The core instead reports no field for extras (ts_node_field_name_for_child returns early for
+/// them), which would desynchronize field-based extraction on malformed source.
 pub fn find_children_by_field_name<'t>(node: Node<'t>, field_name: &str) -> Vec<Node<'t>> {
     let mut children = Vec::new();
     let mut preceding_structural_field: Option<&'static str> = None;
@@ -164,35 +148,11 @@ pub fn to_int32(value: i64) -> i32 {
     value as i32
 }
 
-/// The body following a Kotlin `if_expression`'s bare `else` keyword (the grammar has no else
-/// clause node and no fields), or None for other languages' if nodes and else-less ifs.
-pub fn kotlin_else_body(if_node: Node<'_>) -> Option<Node<'_>> {
-    if if_node.kind() != "if_expression" {
-        return None;
-    }
-    let children = all_children(if_node);
-    let else_index = children
-        .iter()
-        .position(|child| !child.is_named() && child.kind() == "else")?;
-    children[else_index + 1..]
-        .iter()
-        .copied()
-        .find(|child| child.kind() == "control_structure_body")
-}
-
 /// Kotlin's `try { } catch { }` shares its node kind with Rust's `?` operator; only the Kotlin form
-/// holds a body or clause child.
+/// starts with the `try` keyword.
 pub fn is_kotlin_try_expression(node: Node<'_>) -> bool {
-    node.kind() == "try_expression"
-        && named_children(node)
-            .iter()
-            .any(|child| matches!(child.kind(), "statements" | "catch_block" | "finally_block"))
-}
-
-/// Whether a Kotlin else body is a braceless `else if`: the nested if sits directly in the
-/// control_structure_body, whereas a braced `else { if ... }` wraps it in `statements`.
-pub fn is_kotlin_else_if_body(else_body: Node<'_>) -> bool {
-    named_children(else_body)
-        .iter()
-        .any(|child| child.kind() == "if_expression")
+    node.kind_name() == "try_expression"
+        && node
+            .child(0)
+            .is_some_and(|keyword| !keyword.is_named() && keyword.kind_name() == "try")
 }