code-gauge 10.4.0 → 10.4.1

package/native/src/measure.rs

@@ -3,7 +3,7 @@ use std::sync::OnceLock;
 use tree_sitter::Node;
 
 use crate::complexity::{is_lambda_body_block, measure_function_body_metrics, LanguageSets};
-use crate::dep_degree::measure_dep_degree;
+use crate::dep_degree::measure_dep_degrees;
 use crate::duplication::{
     collect_cross_file_file_data, hash_text, measure_duplication, tokenize, DuplicationSettings,
     TokenizedSource,
@@ -12,7 +12,7 @@ use crate::functions::{
     collect_nodes, count_parameters, find_function_name, is_implemented_function,
 };
 use crate::languages::LanguageDefinition;
-use crate::tree_index::{NodeExt, TreeIndex};
+use crate::tree_index::{KindSet, NodeExt, TreeIndex};
 use crate::types::{
     CrossFileFileData, FunctionMetrics, HalsteadCounts, LineMetrics, NativeMetrics,
 };
@@ -20,6 +20,7 @@ use crate::util::{
     all_children, is_js_whitespace, is_token, named_children, node_text, split_lines, Source,
 };
 
+// code-gauge-allow functionNcss 32 -- assembles the file's metrics from every pass in one place
 pub fn measure(
     code: &str,
     language: &LanguageDefinition,
@@ -32,23 +33,26 @@ pub fn measure(
     let _index = TreeIndex::new(&tree, language)?;
     let root = tree.root_node();
     let code = &source;
-    let sets = LanguageSets::new(language);
+    let sets = LanguageSets::of(language);
 
     // One walk collects both function and initializer-block candidates (Ruby's `block` is both).
-    let candidates = collect_nodes(root, |kind| {
-        sets.function_nodes.contains(kind) || INITIALIZER_NODE_TYPES.contains(&kind)
+    let candidates = collect_nodes(root, |node| {
+        sets.function_nodes.contains(node) || INITIALIZER_KINDS.contains(node)
     });
     let initializer_block_count = count_initializer_blocks(&candidates);
     let functions: Vec<Node<'_>> = candidates
         .into_iter()
         .filter(|node| {
-            sets.function_nodes.contains(node.kind_name())
+            sets.function_nodes.contains(*node)
                 && !is_lambda_body_block(*node)
                 && is_implemented_function(*node)
         })
         .collect();
 
-    let body_metrics = measure_function_body_metrics(root, &sets, code);
+    let body_metrics = measure_function_body_metrics(root, sets, code);
+    let (halstead_counts, mut halstead_counts_by_function) =
+        measure_halstead(root, &functions, code);
+    let dep_degrees = measure_dep_degrees(root, &functions, code, &sets.function_nodes);
     let inline_namespaces = crate::container::find_inline_namespaces(root, code);
     let function_metrics: Vec<FunctionMetrics> = functions
         .iter()
@@ -86,14 +90,15 @@ pub fn measure(
                 nesting_depth: body_metrics.nesting_depth,
                 ncss: body_metrics.ncss,
                 parameter_count: count_parameters(*node, code),
-                halstead_counts: measure_halstead(*node, code),
-                dep_degree: measure_dep_degree(*node, code, &sets.function_nodes),
+                halstead_counts: halstead_counts_by_function
+                    .remove(&node.id())
+                    .expect("every function's Halstead counts are measured"),
+                dep_degree: dep_degrees[&node.id()],
             }
         })
         .collect();
 
     let (lines, code_line_numbers) = classify_lines(code, root);
-    let halstead_counts = measure_halstead(root, code);
     let tokenized = tokenize(root, code);
 
     Ok(NativeMetrics {
@@ -144,16 +149,16 @@ pub fn measure(
 /// Initializer blocks run code of their own, so each is a component like a function: Java static
 /// and instance initializers, Kotlin `init` blocks, and JavaScript/TypeScript class `static`
 /// blocks. Their decisions already count as decisions outside functions.
-const INITIALIZER_NODE_TYPES: &[&str] = &[
+static INITIALIZER_KINDS: KindSet = KindSet::new(&[
     "static_initializer",
     "anonymous_initializer",
     "class_static_block",
     "block",
-];
+]);
 
 /// A block of a class that runs when the class or an instance is initialized.
 pub fn is_initializer_block(node: Node<'_>) -> bool {
-    INITIALIZER_NODE_TYPES.contains(&node.kind_name())
+    INITIALIZER_KINDS.contains(node)
         // A bare block is an initializer only as a direct member of a Java class or enum body.
         && (node.kind_name() != "block"
             || node.parent_node().is_some_and(|parent| {
@@ -270,9 +275,9 @@ pub fn collect_function_token_sequences(
     let tree = parse_source(&source, language)?;
     let _index = TreeIndex::new(&tree, language)?;
     let root = tree.root_node();
-    let sets = LanguageSets::new(language);
+    let sets = LanguageSets::of(language);
     Ok(
-        collect_nodes(root, |kind| sets.function_nodes.contains(kind))
+        collect_nodes(root, |node| sets.function_nodes.contains(node))
             .into_iter()
             .filter(|node| !is_lambda_body_block(*node) && is_implemented_function(*node))
             .map(|node| {
@@ -321,13 +326,11 @@ fn collect_token_symbols(
     }
     // Remaining operand leaves are literals, normalized by kind; everything else (keywords,
     // operators, punctuation) is kept verbatim.
-    symbols.push(hash_text(
-        if operand_node_types().contains(node.kind_name()) {
-            node.kind_name()
-        } else {
-            node_text(node, code)
-        },
-    ));
+    symbols.push(hash_text(if OPERAND_KINDS.contains(node) {
+        node.kind_name()
+    } else {
+        node_text(node, code)
+    }));
 }
 
 /// Parses the source from UTF-16, matching node-tree-sitter's JavaScript string semantics:
@@ -566,7 +569,7 @@ const OPERATOR_TEXTS: &[&str] = &[
     "continue",
 ];
 
-const OPERAND_NODE_TYPES: &[&str] = &[
+static OPERAND_KINDS: KindSet = KindSet::new(&[
     "identifier",
     "implicit_parameter",
     "property_identifier",
@@ -624,11 +627,11 @@ const OPERAND_NODE_TYPES: &[&str] = &[
     "undefined",
     "nil",
     "none",
-];
+]);
 
 /// Non-leaf literals counted as one Halstead operand without descending.
 /// `character_literal` is a leaf in Java but wraps its content in C# and Kotlin.
-const ATOMIC_OPERAND_NODE_TYPES: &[&str] = &[
+static ATOMIC_OPERAND_KINDS: KindSet = KindSet::new(&[
     "interpreted_string_literal",
     "character_literal",
     "regex",
@@ -637,89 +640,160 @@ const ATOMIC_OPERAND_NODE_TYPES: &[&str] = &[
     "floating_point_type",
     "sized_type_specifier",
     "placeholder_type_specifier",
-];
+]);
 
 fn operator_texts() -> &'static FxHashSet<&'static str> {
     static SET: OnceLock<FxHashSet<&'static str>> = OnceLock::new();
     SET.get_or_init(|| OPERATOR_TEXTS.iter().copied().collect())
 }
 
-fn operand_node_types() -> &'static FxHashSet<&'static str> {
-    static SET: OnceLock<FxHashSet<&'static str>> = OnceLock::new();
-    SET.get_or_init(|| OPERAND_NODE_TYPES.iter().copied().collect())
-}
+/// Node kinds spelled like an operator.
+static OPERATOR_KINDS: KindSet = KindSet::new(OPERATOR_TEXTS);
 
-fn atomic_operand_node_types() -> &'static FxHashSet<&'static str> {
-    static SET: OnceLock<FxHashSet<&'static str>> = OnceLock::new();
-    SET.get_or_init(|| ATOMIC_OPERAND_NODE_TYPES.iter().copied().collect())
+/// Halstead operator and operand occurrences by text.
+#[derive(Default)]
+struct HalsteadTally<'a> {
+    operators: FxHashMap<&'a str, u64>,
+    operands: FxHashMap<&'a str, u64>,
 }
 
-fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
-    let mut operators: FxHashMap<&str, u64> = FxHashMap::default();
-    let mut operands: FxHashMap<&str, u64> = FxHashMap::default();
-
-    fn visit<'a>(
-        node: Node<'a>,
-        code: &Source<'a>,
-        operators: &mut FxHashMap<&'a str, u64>,
-        operands: &mut FxHashMap<&'a str, u64>,
-    ) {
-        if matches!(
-            node.kind_name(),
-            "comment" | "line_comment" | "block_comment"
-        ) {
-            return;
+impl<'a> HalsteadTally<'a> {
+    fn counts(&self) -> HalsteadCounts {
+        HalsteadCounts {
+            distinct_operators: self.operators.len(),
+            distinct_operands: self.operands.len(),
+            total_operators: self.operators.values().sum(),
+            total_operands: self.operands.values().sum(),
         }
+    }
 
-        if is_atomic_operand(node) {
-            *operands.entry(node_text(node, code)).or_insert(0) += 1;
-            return;
+    fn absorb(&mut self, other: HalsteadTally<'a>) {
+        for (text, count) in other.operators {
+            *self.operators.entry(text).or_insert(0) += count;
+        }
+        for (text, count) in other.operands {
+            *self.operands.entry(text).or_insert(0) += count;
         }
+    }
+}
 
-        // Operators are counted from leaf tokens only: keyword-named nodes always contain a
-        // same-text anonymous keyword leaf, so counting the named node as well would double-count.
-        if is_token(node) {
-            let text = node_text(node, code);
-            // Operands win over text matches so identifiers spelled like word operators stay operands;
-            // C# `nameof(x)` is the one keyword operator the grammar parses as a plain callee.
-            if is_csharp_nameof_callee(node, text) {
-                *operators.entry(text).or_insert(0) += 1;
-            } else if operand_node_types().contains(node.kind_name()) {
-                *operands.entry(text).or_insert(0) += 1;
-            } else if (operator_texts().contains(text)
-                || operator_texts().contains(node.kind_name()))
-                && is_countable_contextual_token(node, text)
-            {
-                let key = if text.is_empty() {
-                    node.kind_name()
-                } else {
-                    text
-                };
-                *operators.entry(key).or_insert(0) += 1;
+/// Halstead counts of the subtree of `root` and, by node id, of each function in `functions`.
+fn measure_halstead<'a>(
+    root: Node<'a>,
+    functions: &[Node<'a>],
+    code: &Source<'a>,
+) -> (HalsteadCounts, FxHashMap<usize, HalsteadCounts>) {
+    let (counts, mut by_function) =
+        count_halstead(root, &functions.iter().map(Node::id).collect(), code);
+    for function in functions {
+        // The walk counts atomic operands and tokens without descending into them and skips
+        // comments, any of which can hold a function (a C++ lambda in a constrained `auto` type).
+        by_function
+            .entry(function.id())
+            .or_insert_with(|| count_halstead(*function, &FxHashSet::default(), code).0);
+    }
+    (counts, by_function)
+}
+
+/// Halstead counts of the subtree of `root` and, by node id, of each function in `function_ids`
+/// whose subtree the walk enters: a function's tokens are counted the same wherever the walk
+/// starts, so its tally is kept apart while its subtree is walked and then joins the enclosing one.
+fn count_halstead<'a>(
+    root: Node<'a>,
+    function_ids: &FxHashSet<usize>,
+    code: &Source<'a>,
+) -> (HalsteadCounts, FxHashMap<usize, HalsteadCounts>) {
+    struct Walk<'a, 'w> {
+        code: &'w Source<'a>,
+        function_ids: &'w FxHashSet<usize>,
+        /// The tally of the walked subtree, then that of each function being walked.
+        tallies: Vec<HalsteadTally<'a>>,
+        by_function: FxHashMap<usize, HalsteadCounts>,
+    }
+
+    impl<'a> Walk<'a, '_> {
+        fn visit(&mut self, node: Node<'a>) {
+            let tally = self.tallies.last_mut().expect("the walked subtree's tally");
+            if !count_halstead_token(node, self.code, tally) {
+                return;
+            }
+            let is_function = self.function_ids.contains(&node.id());
+            if is_function {
+                self.tallies.push(HalsteadTally::default());
+            }
+            for child in all_children(node) {
+                self.visit(child);
+            }
+            if is_function {
+                let tally = self.tallies.pop().expect("pushed above");
+                self.by_function.insert(node.id(), tally.counts());
+                self.tallies
+                    .last_mut()
+                    .expect("the walked subtree's tally")
+                    .absorb(tally);
             }
-            return;
         }
+    }
 
-        for child in all_children(node) {
-            visit(child, code, operators, operands);
-        }
+    let mut walk = Walk {
+        code,
+        function_ids,
+        tallies: vec![HalsteadTally::default()],
+        by_function: FxHashMap::default(),
+    };
+    walk.visit(root);
+    (walk.tallies[0].counts(), walk.by_function)
+}
+
+/// Counts the node into `tally` if it is a token or an atomic operand, returning whether its
+/// children are to be counted instead.
+fn count_halstead_token<'a>(
+    node: Node<'a>,
+    code: &Source<'a>,
+    tally: &mut HalsteadTally<'a>,
+) -> bool {
+    if matches!(
+        node.kind_name(),
+        "comment" | "line_comment" | "block_comment"
+    ) {
+        return false;
     }
 
-    visit(root, code, &mut operators, &mut operands);
+    if is_atomic_operand(node) {
+        *tally.operands.entry(node_text(node, code)).or_insert(0) += 1;
+        return false;
+    }
 
-    HalsteadCounts {
-        distinct_operators: operators.len(),
-        distinct_operands: operands.len(),
-        total_operators: operators.values().sum(),
-        total_operands: operands.values().sum(),
+    // Operators are counted from leaf tokens only: keyword-named nodes always contain a
+    // same-text anonymous keyword leaf, so counting the named node as well would double-count.
+    if !is_token(node) {
+        return true;
+    }
+    let text = node_text(node, code);
+    // Operands win over text matches so identifiers spelled like word operators stay operands;
+    // C# `nameof(x)` is the one keyword operator the grammar parses as a plain callee.
+    if is_csharp_nameof_callee(node, text) {
+        *tally.operators.entry(text).or_insert(0) += 1;
+    } else if OPERAND_KINDS.contains(node) {
+        *tally.operands.entry(text).or_insert(0) += 1;
+    } else if (operator_texts().contains(text) || OPERATOR_KINDS.contains(node))
+        && is_countable_contextual_token(node, text)
+    {
+        let key = if text.is_empty() {
+            node.kind_name()
+        } else {
+            text
+        };
+        *tally.operators.entry(key).or_insert(0) += 1;
     }
+    false
 }
 
-/// A literal counted as one operand without descending: ATOMIC_OPERAND_NODE_TYPES, or a Go raw
+/// A literal counted as one operand without descending: ATOMIC_OPERAND_KINDS, or a Go raw
 /// string, which wraps its content like Go's interpreted strings (the Rust and C++
 /// `raw_string_literal`s count their content leaves instead).
 fn is_atomic_operand(node: Node<'_>) -> bool {
-    atomic_operand_node_types().contains(node.kind_name())
+    ATOMIC_OPERAND_KINDS.contains(node)
         || (node.kind_name() == "raw_string_literal" && crate::tree_index::language_name() == "go")
 }
 

package/native/src/ncss.rs

@@ -1,7 +1,6 @@
-use rustc_hash::FxHashSet;
 use tree_sitter::Node;
 
-use crate::tree_index::NodeExt;
+use crate::tree_index::{KindSet, NodeExt};
 use crate::util::find_children_by_field_name;
 
 pub const COMMENT_NODE_TYPES: &[&str] = &["comment", "line_comment", "block_comment"];
@@ -12,7 +11,7 @@ pub const COMMENT_NODE_TYPES: &[&str] = &["comment", "line_comment", "block_comm
 /// 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] = &[
+static POSITIONAL_EXCLUSION_KINDS: KindSet = KindSet::new(&[
     "attribute_item",
     "inner_attribute_item",
     "empty_statement",
@@ -24,7 +23,7 @@ const POSITIONAL_EXCLUSION_TYPES: &[&str] = &[
     "shebang",
     "enum_entry",
     "lambda_parameters",
-];
+]);
 
 /// TypeScript interface members count like Java interface members, but the same node types appear
 /// inside object-type annotations (`let x: { a: number }`), which are part of one declaration, so
@@ -59,9 +58,9 @@ const BODYLESS_NCSS_SPECIFIER_TYPES: &[&str] = &[
 pub fn ncss_contribution(
     node: Node<'_>,
     parent: Option<Node<'_>>,
-    countable: &FxHashSet<&'static str>,
-    containers: &FxHashSet<&'static str>,
-    bare_body_parents: &FxHashSet<&'static str>,
+    countable: &KindSet,
+    containers: &KindSet,
+    bare_body_parents: &KindSet,
 ) -> u64 {
     if !node.is_named()
         || COMMENT_NODE_TYPES.contains(&node.kind_name())
@@ -82,8 +81,8 @@ pub fn ncss_contribution(
     // 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())
+        && (!containers.contains(node) || node.kind_name() == "lambda_literal")
+        && !POSITIONAL_EXCLUSION_KINDS.contains(node)
         && !crate::util::is_kotlin_try_expression(node);
     if (counts_through_node_type(node, countable)
         || positional
@@ -109,8 +108,8 @@ pub fn ncss_contribution(
     contribution
 }
 
-fn counts_through_node_type(node: Node<'_>, countable: &FxHashSet<&'static str>) -> bool {
-    if !countable.contains(node.kind_name()) {
+fn counts_through_node_type(node: Node<'_>, countable: &KindSet) -> bool {
+    if !countable.contains(node) {
         return false;
     }
     if BODYLESS_NCSS_SPECIFIER_TYPES.contains(&node.kind_name()) {
@@ -130,14 +129,11 @@ const TRANSPARENT_WRAPPER_TYPES: &[&str] = &["parenthesized_statements", "attrib
 
 /// Direct container children count positionally, as do the children of TRANSPARENT_WRAPPER_TYPES
 /// in that position.
-fn is_in_container_position(
-    parent: Option<Node<'_>>,
-    containers: &FxHashSet<&'static str>,
-) -> bool {
+fn is_in_container_position(parent: Option<Node<'_>>, containers: &KindSet) -> bool {
     let mut ancestor = parent;
     while let Some(current) = ancestor {
         if !TRANSPARENT_WRAPPER_TYPES.contains(&current.kind_name()) {
-            return containers.contains(current.kind_name());
+            return containers.contains(current);
         }
         ancestor = current.parent_node();
     }
@@ -146,12 +142,8 @@ fn is_in_container_position(
 
 /// 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()))
+fn is_bare_body(node: Node<'_>, parent: Option<Node<'_>>, bare_body_parents: &KindSet) -> bool {
+    parent.is_some_and(|parent| bare_body_parents.contains(parent))
         && ["consequence", "alternative", "body"]
             .iter()
             .any(|field_name| is_field_of_parent(node, parent, field_name))
@@ -159,13 +151,13 @@ fn is_bare_body(
 
 /// `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: &FxHashSet<&'static str>) -> bool {
+fn is_declaration_wrapper(node: Node<'_>, countable: &KindSet) -> bool {
     if node.kind_name() != "export_statement" {
         return false;
     }
     node.child_by_field_name("declaration")
         .is_some_and(|declaration| {
-            countable.contains(declaration.kind_name())
+            countable.contains(declaration)
                 || declaration.kind_name() == "internal_module"
                 || declaration.kind_name() == "ambient_declaration"
         })