code-gauge 4.7.0 → 4.7.1

package/native/src/ncss.rs

@@ -1,7 +1,8 @@
-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",
@@ -56,54 +57,39 @@ 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>,
 ) -> 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")
+    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())
+    let positional = is_in_container_position(parent, containers)
+        && !containers.contains(node.kind_name())
+        && !POSITIONAL_EXCLUSION_TYPES.contains(&node.kind_name())
         && !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))
+        && !(node.kind_name() == "label" && node.child_count() == 0);
+    if (counts_through_node_type(node, countable)
+        || positional
+        || counts_contextually(node, parent))
         && !is_declaration_wrapper(node, countable)
     {
         contribution += 1;
@@ -112,7 +98,7 @@ pub fn ncss_contribution(
     // 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()) {
+    if IF_NODE_TYPES.contains(&node.kind_name()) {
         contribution += count_bare_alternatives(node)
             + u64::from(crate::util::kotlin_else_body(node).is_some());
     }
@@ -120,16 +106,16 @@ pub fn ncss_contribution(
     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 +123,31 @@ 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
 }
 
 /// `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 +158,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 +184,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 +239,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 +278,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,110 @@
+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(&[]) };
+}
+
+/// 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());
+        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(&[]);
+    }
+}
+
+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
@@ -55,9 +57,9 @@ pub fn node_text<'a>(node: Node<'_>, code: &Source<'a>) -> &'a str {
 /// 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"
+    node.kind_name() == "type_identifier"
+        && node.parent_node().is_some_and(|parent| {
+            parent.kind_name() == "callable_reference"
                 && parent
                     .named_child(0)
                     .is_some_and(|first| first.id() == node.id())
@@ -72,7 +74,7 @@ pub fn is_kotlin_callable_receiver(node: Node<'_>) -> bool {
 pub fn is_identifier_leaf(node: Node<'_>) -> bool {
     node.child_count() == 0
         || matches!(
-            node.kind(),
+            node.kind_name(),
             "simple_identifier" | "interpolated_identifier" | "type_identifier"
         )
 }
@@ -167,26 +169,29 @@ pub fn to_int32(value: i64) -> 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" {
+    if if_node.kind_name() != "if_expression" {
         return None;
     }
     let children = all_children(if_node);
     let else_index = children
         .iter()
-        .position(|child| !child.is_named() && child.kind() == "else")?;
+        .position(|child| !child.is_named() && child.kind_name() == "else")?;
     children[else_index + 1..]
         .iter()
         .copied()
-        .find(|child| child.kind() == "control_structure_body")
+        .find(|child| child.kind_name() == "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.
 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"))
+    node.kind_name() == "try_expression"
+        && named_children(node).iter().any(|child| {
+            matches!(
+                child.kind_name(),
+                "statements" | "catch_block" | "finally_block"
+            )
+        })
 }
 
 /// Whether a Kotlin else body is a braceless `else if`: the nested if sits directly in the
@@ -194,5 +199,5 @@ pub fn is_kotlin_try_expression(node: Node<'_>) -> bool {
 pub fn is_kotlin_else_if_body(else_body: Node<'_>) -> bool {
     named_children(else_body)
         .iter()
-        .any(|child| child.kind() == "if_expression")
+        .any(|child| child.kind_name() == "if_expression")
 }

package/native/src/worker_pool.rs

@@ -0,0 +1,53 @@
+use std::num::NonZeroUsize;
+use std::sync::{mpsc, Arc, Mutex, OnceLock};
+use std::thread;
+
+type Job = Box<dyn FnOnce() + Send>;
+
+/// The metric passes recurse per tree level (TreeIndex refuses trees deeper than 5,000), so workers
+/// get the stack size of a typical main thread instead of Rust's 2 MiB default.
+const STACK_SIZE: usize = 8 * 1024 * 1024;
+
+/// Runs the job on a process-wide pool with one thread per available core. A dedicated pool rather
+/// than libuv's (4 threads by default) lets measurements use every core without the embedding
+/// process having to raise UV_THREADPOOL_SIZE before its first I/O. The pool keeps however many
+/// workers the OS allows (a thread or PID limit may refuse some); with none, the job runs on the
+/// calling thread instead.
+pub fn spawn(job: impl FnOnce() + Send + 'static) {
+    static SENDER: OnceLock<Option<mpsc::Sender<Job>>> = OnceLock::new();
+    let sender = SENDER.get_or_init(|| {
+        let (sender, receiver) = mpsc::channel::<Job>();
+        let receiver = Arc::new(Mutex::new(receiver));
+        let mut started = 0;
+        for _ in 0..thread::available_parallelism().map_or(1, NonZeroUsize::get) {
+            let receiver = Arc::clone(&receiver);
+            let spawned = thread::Builder::new()
+                .name("code-gauge-worker".to_string())
+                .stack_size(STACK_SIZE)
+                .spawn(move || loop {
+                    let job = receiver
+                        .lock()
+                        .expect("jobs run after the lock is released, so it is never poisoned")
+                        .recv();
+                    match job {
+                        Ok(job) => job(),
+                        Err(_) => return,
+                    }
+                });
+            if spawned.is_err() {
+                break;
+            }
+            started += 1;
+        }
+        (started > 0).then_some(sender)
+    });
+    let job: Job = Box::new(job);
+    match sender {
+        Some(sender) => {
+            if let Err(mpsc::SendError(job)) = sender.send(job) {
+                job();
+            }
+        }
+        None => job(),
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "4.7.0",
+  "version": "4.7.1",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -94,12 +94,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "4.7.0",
-    "code-gauge-linux-arm64-gnu": "4.7.0",
-    "code-gauge-linux-x64-musl": "4.7.0",
-    "code-gauge-linux-arm64-musl": "4.7.0",
-    "code-gauge-darwin-x64": "4.7.0",
-    "code-gauge-darwin-arm64": "4.7.0",
-    "code-gauge-win32-x64-msvc": "4.7.0"
+    "code-gauge-linux-x64-gnu": "4.7.1",
+    "code-gauge-linux-arm64-gnu": "4.7.1",
+    "code-gauge-linux-x64-musl": "4.7.1",
+    "code-gauge-linux-arm64-musl": "4.7.1",
+    "code-gauge-darwin-x64": "4.7.1",
+    "code-gauge-darwin-arm64": "4.7.1",
+    "code-gauge-win32-x64-msvc": "4.7.1"
   }
 }