code-gauge 10.3.0 → 10.4.1

package/native/src/duplication.rs

@@ -234,6 +234,7 @@ const STRING_FRAGMENT_TYPES: &[&str] = &[
     "raw_string_content",
     "interpreted_string_literal_content",
     "raw_string_literal_content",
+    "format_specifier",
     "raw_string_start",
     "raw_string_end",
     "escape_sequence",
@@ -299,6 +300,7 @@ const STRING_CONTENT_FRAGMENT_TYPES: &[&str] = &[
     "raw_string_content",
     "interpreted_string_literal_content",
     "raw_string_literal_content",
+    "format_specifier",
     "escape_sequence",
     "heredoc_content",
 ];
@@ -570,6 +572,9 @@ fn collect_tokens<'a>(
         statement_list_statements: &mut Vec<TokenRange>,
     ) -> TokenRange {
         let start_token_index = tokens.len();
+        // The span of the node's tokens, which can be narrower than the node: a Python block
+        // starts at its header's colon, and a Rust declaration starts at its doc comment.
+        let mut token_span: Option<SourceSpan> = None;
         let is_token = is_token(node);
         let atomic_kind = if is_token {
             None
@@ -602,6 +607,7 @@ fn collect_tokens<'a>(
                     container_statement_ranges,
                     &mut child_statements,
                 );
+                token_span = widen_token_span(token_span, &child_range);
                 // A Kotlin lambda's parameters sit beside its statements.
                 if is_container
                     && child.is_named()
@@ -625,13 +631,19 @@ fn collect_tokens<'a>(
             }
         }
 
-        let range = TokenRange {
-            start_token_index,
-            end_token_index: tokens.len(),
+        let span = token_span.unwrap_or(SourceSpan {
             start_index: node.start_byte(),
             end_index: node.end_byte(),
             start_line: node.start_position().row + 1,
             end_line: node.end_position().row + 1,
+        });
+        let range = TokenRange {
+            start_token_index,
+            end_token_index: tokens.len(),
+            start_index: span.start_index,
+            end_index: span.end_index,
+            start_line: span.start_line,
+            end_line: span.end_line,
         };
         if is_duplicate_block(node) {
             block_ranges.push(TokenRange { ..range });
@@ -649,6 +661,28 @@ fn collect_tokens<'a>(
     );
 }
 
+#[derive(Clone, Copy)]
+struct SourceSpan {
+    start_index: usize,
+    end_index: usize,
+    start_line: usize,
+    end_line: usize,
+}
+
+/// `span` extended to the end of `child`'s tokens, or `child`'s token span when `span` is empty;
+/// a child without tokens leaves it as it is.
+fn widen_token_span(span: Option<SourceSpan>, child: &TokenRange) -> Option<SourceSpan> {
+    if child.start_token_index == child.end_token_index {
+        return span;
+    }
+    Some(SourceSpan {
+        start_index: span.map_or(child.start_index, |span| span.start_index),
+        end_index: child.end_index,
+        start_line: span.map_or(child.start_line, |span| span.start_line),
+        end_line: child.end_line,
+    })
+}
+
 /// Comments and dependency declarations contribute no tokens, so no clone consists of them; the
 /// tokens around them stay adjacent, so a clone may still extend across one.
 fn is_tokenless(node: Node<'_>, code: &Source<'_>) -> bool {

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
@@ -71,11 +73,13 @@ pub fn count_parameters(node: Node<'_>, code: &Source<'_>) -> usize {
         return 0;
     };
 
-    // A Java bare lambda parameter (`x -> x + 1`) puts a lone identifier in the `parameters` field;
-    // a C# one (`x => x + 1`) is an `implicit_parameter` leaf.
-    if parameters_node.kind_name() == "identifier"
-        || parameters_node.kind_name() == "implicit_parameter"
-    {
+    // A Java bare lambda parameter (`x -> x + 1`, `_ -> 1`) puts a lone identifier or unnamed
+    // `underscore_pattern` in the `parameters` field; a C# one (`x => x + 1`) is an
+    // `implicit_parameter` leaf.
+    if matches!(
+        parameters_node.kind_name(),
+        "identifier" | "underscore_pattern" | "implicit_parameter"
+    ) {
         return 1;
     }
     // Kotlin default values (`x: Int = 0`) are siblings of their `parameter`, not children.
@@ -127,12 +131,7 @@ pub fn count_parameters(node: Node<'_>, code: &Source<'_>) -> usize {
             1
         };
     }
-    // C++ C-style varargs (`int f(int a, ...)`) leave `...` as an anonymous token.
-    let anonymous_variadic_count = all_children(parameters_node)
-        .iter()
-        .filter(|child| !child.is_named() && node_text(**child, code) == "...")
-        .count();
-    count + anonymous_variadic_count + usize::from(!csharp_params_array_ids.is_empty())
+    count + usize::from(!csharp_params_array_ids.is_empty())
 }
 
 /// C/C++ `int f(void)` has a `parameter_declaration` whose type is a bare `void` with no declarator.
@@ -197,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);
         }
 
@@ -907,7 +906,8 @@ pub fn find_string_literal_content(literal: Node<'_>, code: &Source<'_>) -> Opti
             "string_content"
             | "string_fragment"
             | "interpreted_string_literal_content"
-            | "raw_string_literal_content" => {
+            | "raw_string_literal_content"
+            | "format_specifier" => {
                 has_content_node = true;
                 content.push_str(node_text(*child, code));
             }

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] =
@@ -434,9 +439,8 @@ const RUST_NCSS_NODES: &[&str] = &[
     "else_clause",
     "match_arm",
 ];
-// `else_clause` is a container so `else if` chains count the nested if_expression; a plain
-// `else { ... }` is unaffected because its only child is a `block`, itself a container.
-const RUST_NCSS_CONTAINERS: &[&str] = &["block", "else_clause"];
+
+const RUST_NCSS_CONTAINERS: &[&str] = &["block"];
 
 const JAVA_NCSS_NODES: &[&str] = &[
     "package_declaration",

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")
 }