code-gauge 4.2.2 → 4.3.1

package/native/src/complexity.rs

@@ -74,7 +74,7 @@ const SWITCH_LIKE_NODE_TYPES: &[&str] = &[
     "case_match",
 ];
 
-// Per-case decision nodes add no cognitive point because the switch itself carries the cost.
+// Per-case decision nodes: cyclomatic-only, because the switch itself carries the cognitive cost.
 const CASE_CLAUSE_NODE_TYPES: &[&str] = &[
     "case_clause",
     "switch_case",
@@ -95,6 +95,7 @@ const CASE_CLAUSE_NODE_TYPES: &[&str] = &[
 const IF_LIKE_NODE_TYPES: &[&str] = &["if_statement", "if_expression", "if", "unless"];
 
 pub struct FunctionBodyMetrics {
+    pub cyclomatic_complexity: u64,
     pub cognitive_complexity: u64,
     pub nesting_depth: u64,
     pub ncss: u64,
@@ -102,6 +103,7 @@ pub struct FunctionBodyMetrics {
 
 /// Accumulator for one function body during measure_function_body_metrics' post-order pass.
 struct FunctionBodyFrame {
+    cyclomatic_complexity: u64,
     cognitive_complexity: u64,
     /// Count of `1 + nesting` cognitive increments, for re-basing on hoist into the parent frame.
     nesting_sensitive_count: u64,
@@ -117,6 +119,7 @@ struct FunctionBodyFrame {
 impl FunctionBodyFrame {
     fn new(entry_cognitive_nesting: u64, entry_structural_nesting: u64) -> Self {
         FunctionBodyFrame {
+            cyclomatic_complexity: 1,
             cognitive_complexity: 0,
             nesting_sensitive_count: 0,
             nesting_depth: 0,
@@ -141,8 +144,8 @@ struct FunctionBodyPass<'sets, 'code, 'source> {
 /// already-computed totals: NCSS hoists as-is; cognitive complexity re-bases the nested function's
 /// nesting-sensitive increments (each worth `1 + nesting`) by the nesting offset at the embedding
 /// site, while flat increments (else branches, boolean-operator sequences, chain continuations,
-/// jumps, guards) hoist unchanged; nesting depth describes the own body only, so it does not
-/// hoist.
+/// jumps, guards) hoist unchanged; cyclomatic complexity and nesting depth describe the own body
+/// only, so nothing hoists.
 pub fn measure_function_body_metrics(
     root: Node<'_>,
     sets: &LanguageSets,
@@ -186,7 +189,7 @@ impl FunctionBodyPass<'_, '_, '_> {
         }
         // The node's own increments target the frame it is embedded in, not the one it opens; a
         // frame-opening or charged-class-body node contributes nothing to that frame's own body
-        // (nesting), matching the per-function traversal this pass replaces.
+        // (cyclomatic/nesting), matching the per-function traversal this pass replaces.
         let entry_cognitive_nesting = self.top_frame().entry_cognitive_nesting;
         let entry_structural_nesting = self.top_frame().entry_structural_nesting;
         let relative_nesting = current_nesting + function_nesting_bonus - entry_cognitive_nesting;
@@ -196,7 +199,7 @@ impl FunctionBodyPass<'_, '_, '_> {
         // `if` keyword token), so only named nodes count as decisions.
         let is_decision = current.is_named()
             && self.sets.decision_nodes.contains(current.kind())
-            && !is_default_switch_branch(current);
+            && !is_pathless_switch_branch(current, self.code);
         let is_case_clause = current.is_named() && CASE_CLAUSE_NODE_TYPES.contains(&current.kind());
         // Ruby's `case ... else` arm is an `else` node; like every other language's default branch
         // it nests its contents inside the switch (it cannot go in the Ruby nesting set because
@@ -211,6 +214,13 @@ impl FunctionBodyPass<'_, '_, '_> {
         // surcharge (Sonar cognitive-complexity semantics).
         let is_continuation = is_decision && is_flat_chain_continuation(current);
 
+        // Each branch, short-circuit operator, and pattern guard adds one path (McCabe; NIST SP
+        // 500-235 §4); `else` adds none.
+        if counts_for_own_body
+            && (is_decision || is_boolean_operator(current, self.code) || is_pattern_guard(current))
+        {
+            self.top_frame().cyclomatic_complexity += 1;
+        }
         if is_decision && !is_case_clause {
             if is_continuation {
                 self.top_frame().cognitive_complexity += 1;
@@ -295,6 +305,7 @@ impl FunctionBodyPass<'_, '_, '_> {
             self.results.insert(
                 current.id(),
                 FunctionBodyMetrics {
+                    cyclomatic_complexity: closed.cyclomatic_complexity,
                     cognitive_complexity: closed.cognitive_complexity,
                     nesting_depth: closed.nesting_depth,
                     // A function node without a countable declaration of its own (arrow functions,
@@ -361,7 +372,7 @@ pub fn measure_complexity(
         // `if` keyword token), so only named nodes count as decisions.
         let is_decision = current.is_named()
             && sets.decision_nodes.contains(current.kind())
-            && !is_default_switch_branch(current);
+            && !is_pathless_switch_branch(current, code);
         let is_case_clause = current.is_named() && CASE_CLAUSE_NODE_TYPES.contains(&current.kind());
         // Ruby's `case ... else` arm is an `else` node; like every other language's default branch
         // it nests its contents inside the switch (it cannot go in the Ruby nesting set because
@@ -614,46 +625,138 @@ fn is_flat_chain_continuation(node: Node<'_>) -> bool {
             .is_some_and(|alternative| alternative.id() == node.id())
 }
 
-/// Default branches of switch-like constructs add no decision.
-fn is_default_switch_branch(node: Node<'_>) -> bool {
+/// Switch branches that add no path. NIST SP 500-235 counts one path per case-labelled statement:
+/// a label-only case shares the statement of the case below it, and that statement adds a path
+/// unless one of its stacked labels is an unguarded default or catch-all (`case 3: default: g();`
+/// and `default: case 3: g();` are the default outcome) or all of them are catch-alls. Guards are
+/// charged separately, so a guarded catch-all never absorbs a case stacked with it.
+fn is_pathless_switch_branch(node: Node<'_>, code: &Source<'_>) -> bool {
+    if is_label_only_case(node) {
+        return true;
+    }
+    let mut stacked = vec![node];
+    let mut previous = node.prev_named_sibling();
+    while let Some(sibling) = previous {
+        if !crate::ncss::COMMENT_NODE_TYPES.contains(&sibling.kind()) {
+            if !is_label_only_case(sibling) {
+                break;
+            }
+            stacked.push(sibling);
+        }
+        previous = sibling.prev_named_sibling();
+    }
+    stacked
+        .iter()
+        .any(|label| is_default_switch_branch(*label, code) && !has_pattern_guard(*label))
+        || stacked
+            .iter()
+            .all(|label| is_default_switch_branch(*label, code))
+}
+
+/// A guard directly on the arm (C# `when`, Python `if`, Ruby `if`/`unless`) or inside its label or
+/// pattern (Java `when`, Rust `if`).
+fn has_pattern_guard(node: Node<'_>) -> bool {
+    crate::util::named_children(node).into_iter().any(|child| {
+        is_pattern_guard(child)
+            || crate::util::named_children(child)
+                .into_iter()
+                .any(is_pattern_guard)
+    })
+}
+
+/// A C/C++/JS/Java/C# case whose labels share the next case's statements; every grammar parses each
+/// stacked label as its own case node.
+fn is_label_only_case(node: Node<'_>) -> bool {
+    let children = non_comment_children(node);
+    match node.kind() {
+        "case_statement" => {
+            let value = node.child_by_field_name("value").map(|value| value.id());
+            children.iter().all(|child| Some(child.id()) == value)
+        }
+        "switch_case" | "switch_default" => node.child_by_field_name("body").is_none(),
+        "switch_block_statement_group" => {
+            children.iter().all(|child| child.kind() == "switch_label")
+        }
+        // A C# label is a pattern (`case 1:` parses as a constant pattern) plus an optional `when`
+        // guard; anything else, a `#if` block included, is the section's body.
+        "switch_section" => children.iter().all(|child| {
+            child.kind().ends_with("pattern")
+                || child.kind() == "discard"
+                || child.kind() == "when_clause"
+        }),
+        _ => false,
+    }
+}
+
+fn is_default_switch_branch(node: Node<'_>, code: &Source<'_>) -> bool {
     let kind = node.kind();
+    if kind == "switch_default" {
+        return true;
+    }
     if kind == "case_statement" {
         return node.child_by_field_name("value").is_none();
     }
 
+    // Java `default:` groups and `default ->` rules: a label with no expression or pattern, or a
+    // `case null, default` label, whose `default` the grammar parses as an identifier.
     if kind == "switch_block_statement_group" || kind == "switch_rule" {
-        let label = crate::util::named_children(node)
+        return non_comment_children(node)
             .into_iter()
-            .find(|child| child.kind() == "switch_label");
-        return label.is_some_and(|label| label.named_child_count() == 0);
+            .filter(|child| child.kind() == "switch_label")
+            .any(|label| {
+                let parts = non_comment_children(label);
+                parts.is_empty()
+                    || parts.iter().any(|part| {
+                        part.kind() == "identifier" && node_text(*part, code) == "default"
+                    })
+            });
+    }
+
+    // C# `default:` sections and catch-all (`_`, `var x`) labels and arms, and Kotlin `else ->`
+    // entries. A guarded catch-all (`_ when cond =>`) is still a default arm: only its guard
+    // branches, which is_pattern_guard charges, like Python's `case _ if cond:` and Rust's
+    // `_ if cond =>`.
+    if kind == "switch_section" {
+        return node.child(0).is_some_and(|first| first.kind() == "default")
+            || crate::util::named_children(node)
+                .into_iter()
+                .any(is_csharp_catch_all_pattern);
+    }
+    if kind == "switch_expression_arm" {
+        return crate::util::named_children(node)
+            .first()
+            .is_some_and(|first| is_csharp_catch_all_pattern(*first));
+    }
+    if kind == "when_entry" {
+        return !crate::util::named_children(node)
+            .iter()
+            .any(|child| child.kind() == "when_condition");
     }
 
-    // Python `case _:` / `case y:` and Rust `_ =>` fallback arms are unconditional like `default`.
-    if kind == "case_clause" || kind == "match_arm" {
-        let pattern = crate::util::named_children(node)
+    // Python arms with an irrefutable pattern are unconditional like `default`.
+    // A bare `case y, z:` or `case y,:` is a sequence pattern: its elements are direct
+    // case_pattern children separated by comma tokens of the clause itself.
+    if kind == "case_clause" {
+        let patterns: Vec<Node<'_>> = crate::util::named_children(node)
             .into_iter()
-            .find(|child| child.kind() == "case_pattern" || child.kind() == "match_pattern");
-        let Some(pattern) = pattern else {
-            return false;
-        };
-        if pattern.child(0).is_some_and(|first| first.kind() == "_")
-            && (pattern.child_count() == 1
-                || pattern.child(1).is_some_and(|second| second.kind() == "if"))
-        {
-            return true;
-        }
-        let sole_child = if pattern.named_child_count() == 1 {
-            pattern.named_child(0)
-        } else {
-            None
-        };
-        return kind == "case_clause"
-            && sole_child.is_some_and(|child| {
-                child.kind() == "dotted_name"
-                    && child.named_child_count() == 1
-                    && child
-                        .named_child(0)
-                        .is_some_and(|inner| inner.kind() == "identifier")
+            .filter(|child| child.kind() == "case_pattern")
+            .collect();
+        return !all_children(node).iter().any(|child| child.kind() == ",")
+            && matches!(patterns[..], [pattern] if is_python_irrefutable_pattern(pattern));
+    }
+    // Rust `_ =>` (optionally guarded) fallback arms.
+    if kind == "match_arm" {
+        return crate::util::named_children(node)
+            .into_iter()
+            .find(|child| child.kind() == "match_pattern")
+            .is_some_and(|pattern| {
+                // The guard keyword is anonymous, so filter all children, not just named ones.
+                let parts: Vec<Node<'_>> = all_children(pattern)
+                    .into_iter()
+                    .filter(|child| !crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind()))
+                    .collect();
+                matches!(parts[..], [first, ..] if first.kind() == "_")
+                    && parts.get(1).is_none_or(|second| second.kind() == "if")
             });
     }
 
@@ -667,6 +770,64 @@ fn is_default_switch_branch(node: Node<'_>) -> bool {
     false
 }
 
+/// PEP 634's irrefutable patterns: the wildcard `_`, a capture `y`, a group `(p)`, `p as y`, and
+/// `p | q` when `p` (or, for `|`, any alternative) is irrefutable. A group parses as a one-element
+/// tuple pattern that differs from the real tuple `(p,)` only by the comma token.
+fn is_python_irrefutable_pattern(node: Node<'_>) -> bool {
+    match node.kind() {
+        "_" => true,
+        "case_pattern" => match non_comment_children(node)[..] {
+            [] => all_children(node).iter().any(|child| child.kind() == "_"),
+            [inner] => is_python_irrefutable_pattern(inner),
+            _ => false,
+        },
+        "dotted_name" => matches!(
+            non_comment_children(node)[..],
+            [name] if name.kind() == "identifier"
+        ),
+        "tuple_pattern" => {
+            !all_children(node).iter().any(|child| child.kind() == ",")
+                && matches!(
+                    non_comment_children(node)[..],
+                    [inner] if is_python_irrefutable_pattern(inner)
+                )
+        }
+        "as_pattern" => non_comment_children(node)
+            .first()
+            .is_some_and(|pattern| is_python_irrefutable_pattern(*pattern)),
+        "union_pattern" => all_children(node)
+            .into_iter()
+            .any(is_python_irrefutable_pattern),
+        _ => false,
+    }
+}
+
+fn non_comment_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
+    crate::util::named_children(node)
+        .into_iter()
+        .filter(|child| !crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind()))
+        .collect()
+}
+
+/// C# patterns that match every value: the discard `_` and `var x`/`var _`, possibly parenthesized
+/// (but not a `var (a, b)` deconstruction, which requires a deconstructible value).
+fn is_csharp_catch_all_pattern(node: Node<'_>) -> bool {
+    if node.kind() == "parenthesized_pattern" {
+        return crate::util::named_children(node)
+            .into_iter()
+            .find(|child| !crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind()))
+            .is_some_and(is_csharp_catch_all_pattern);
+    }
+    node.kind() == "discard"
+        || (node.kind() == "declaration_pattern"
+            && node
+                .child_by_field_name("type")
+                .is_some_and(|ty| ty.kind() == "implicit_type")
+            && !crate::util::named_children(node)
+                .iter()
+                .any(|child| child.kind() == "parenthesized_variable_designation"))
+}
+
 /// The parent guard is required because the same tokens appear in non-boolean syntax (C++ `int&&`,
 /// `operator&&`, Rust's empty closure parameter list `|| 5`).
 fn is_boolean_operator(node: Node<'_>, code: &Source<'_>) -> bool {

package/native/src/functions.rs

@@ -3,15 +3,16 @@ use tree_sitter::Node;
 
 use crate::util::{all_children, find_children_by_field_name, named_children, node_text, Source};
 
-/// C++ `function_definition` also covers pure-virtual/`= default`/`= delete` members; those have no
-/// `body` and are signatures, not implementations, matching how TypeScript method signatures are
-/// excluded. Java `method_declaration` is NOT here: PMD reports abstract/interface methods as
-/// methods (NCSS 1), so bodyless Java methods stay in the function list (as do C#'s and Kotlin's).
-/// C# auto-property accessors (`{ get; set; }`) and Kotlin visibility-only accessors (`private
+/// 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
+/// how TypeScript method signatures are excluded. C# auto-property accessors (`{ get; set; }`) and Kotlin visibility-only accessors (`private
 /// set`) hold no code, so they need a body too; a C# property or indexer is a function only in its
 /// expression-bodied form (`int X => ...`), otherwise its accessors are the functions.
 const BODY_REQUIRED_FUNCTION_TYPES: &[&str] = &[
     "function_definition",
+    "function_declaration",
+    "method_declaration",
     "constructor_declaration",
     "compact_constructor_declaration",
     "function_signature_item",
@@ -35,8 +36,9 @@ pub fn is_implemented_function(node: Node<'_>) -> bool {
             .is_some_and(|value| value.kind() == "arrow_expression_clause");
     }
 
-    // The Kotlin grammar has no fields; an implemented accessor holds a `function_body` child.
-    if node.kind() == "getter" || node.kind() == "setter" {
+    // The Kotlin grammar has no fields; an implemented function or accessor holds a
+    // `function_body` child.
+    if node.kind() == "getter" || node.kind() == "setter" || node.kind() == "function_declaration" {
         return named_children(node)
             .iter()
             .any(|child| child.kind() == "function_body");

package/native/src/lib.rs

@@ -21,7 +21,7 @@ mod util;
 /// together with `expectedPayloadVersion` in src/nativeMetrics.ts.
 #[napi]
 pub fn payload_version() -> u32 {
-    4
+    5
 }
 
 /// Measures code metrics for the given source, returning the NativeMetrics payload as JSON.

package/native/src/measure.rs

@@ -53,6 +53,8 @@ pub fn measure(
                 // yields the JavaScript string (UTF-16 code unit) column.
                 start_column: node.start_position().column / 2,
                 end_line: node.end_position().row + 1,
+                end_column: node.end_position().column / 2,
+                cyclomatic_complexity: body_metrics.cyclomatic_complexity,
                 // Sonar's written spec adds +1 cognitive complexity per function in a recursion
                 // cycle, but this is intentionally not implemented (issue #22): mainstream
                 // implementations (PMD, SonarQube analyzers) omit it.

package/native/src/types.rs

@@ -40,6 +40,8 @@ pub struct FunctionMetrics {
     pub start_line: usize,
     pub start_column: usize,
     pub end_line: usize,
+    pub end_column: usize,
+    pub cyclomatic_complexity: u64,
     pub cognitive_complexity: u64,
     pub nesting_depth: u64,
     pub ncss: u64,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "4.2.2",
+  "version": "4.3.1",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -65,16 +65,16 @@
     "@tsconfig/bun": "1.0.10",
     "@tsconfig/node-lts": "24.0.0",
     "@tsconfig/node-ts": "23.6.4",
-    "@types/bun": "1.4.0",
+    "@types/bun": "1.4.2",
     "@types/node": "25.9.4",
     "@willbooster/oxfmt-config": "1.2.2",
     "@willbooster/oxlint-config": "1.4.8",
-    "@willbooster/wb": "22.1.3",
-    "build-ts": "21.0.10",
+    "@willbooster/wb": "22.7.0",
+    "build-ts": "21.0.16",
     "conventional-changelog-conventionalcommits": "9.3.1",
-    "lefthook": "2.1.10",
-    "oxfmt": "0.64.0",
-    "oxlint": "1.79.0",
+    "lefthook": "2.1.14",
+    "oxfmt": "0.68.0",
+    "oxlint": "1.83.0",
     "oxlint-tsgolint": "7.0.2001",
     "semantic-release": "25.0.5",
     "sort-package-json": "4.0.0",
@@ -89,12 +89,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "4.2.2",
-    "code-gauge-linux-arm64-gnu": "4.2.2",
-    "code-gauge-linux-x64-musl": "4.2.2",
-    "code-gauge-linux-arm64-musl": "4.2.2",
-    "code-gauge-darwin-x64": "4.2.2",
-    "code-gauge-darwin-arm64": "4.2.2",
-    "code-gauge-win32-x64-msvc": "4.2.2"
+    "code-gauge-linux-x64-gnu": "4.3.1",
+    "code-gauge-linux-arm64-gnu": "4.3.1",
+    "code-gauge-linux-x64-musl": "4.3.1",
+    "code-gauge-linux-arm64-musl": "4.3.1",
+    "code-gauge-darwin-x64": "4.3.1",
+    "code-gauge-darwin-arm64": "4.3.1",
+    "code-gauge-win32-x64-msvc": "4.3.1"
   }
 }