code-gauge 4.3.0 → 4.3.1

package/README.md

@@ -173,9 +173,9 @@ The `duplication` section tunes how clones are detected:
   import declarations count, and statement-shaped content is counted uniformly in expression
   positions too
 - Per-function and file-level nesting depth
-- Per-function cyclomatic complexity (McCabe, own body only), matching PMD's
-  `CyclomaticComplexity` rule for Java; an API-only compatibility metric that ranking and the
-  regression gate ignore
+- Per-function cyclomatic complexity (McCabe, own body only), counted as NIST SP 500-235 defines it:
+  every decision and short-circuit operator adds one, one per case-labelled statement; an API-only
+  metric that ranking and the regression gate ignore
 - Per-function parameter counts and locations (name, node type, line span)
 - Within-file duplication: copy-pasted blocks matched on normalized tokens (identifiers anonymized
   consistently, literals by kind, and literal-dense data tables excluded unless their values also

package/dist/types.d.ts

@@ -65,13 +65,12 @@ export interface FunctionMetrics {
     /** Exclusive end column, so functions can be tested for containment in each other. */
     endColumn: number;
     /**
-     * McCabe cyclomatic complexity of the function's own body: 1 plus one per decision point
-     * (branch, loop, non-default case label, catch, ternary, boolean operator, pattern guard). Java
-     * follows PMD's `CyclomaticComplexity` instead, which also counts `throw` but counts `&&`/`||`
-     * only inside branch, loop, ternary, and switch conditions and adds nothing for pattern labels
-     * and guards. Nested function bodies are excluded, so summing over functions counts each
-     * decision point once. Not used by ranking or the regression gate; exposed for consumers that
-     * report PMD-compatible metrics.
+     * McCabe cyclomatic complexity of the function's own body, counted from source as NIST SP 500-235
+     * §4 prescribes: 1 plus one per decision (branch, loop, catch, ternary, pattern guard), per
+     * short-circuit operator (`&&`, `||`, `and`, `or`) wherever it appears, and per case-labelled
+     * statement or match arm (stacked labels share one; default and catch-all arms add none).
+     * Full-evaluation operators and `throw` add nothing. Nested function bodies are excluded, so
+     * summing over functions counts each decision once. Not used by ranking or the regression gate.
      */
     cyclomaticComplexity: number;
     cognitiveComplexity: number;

package/native/src/complexity.rs

@@ -12,7 +12,6 @@ pub struct ComplexityResult {
 pub struct LanguageSets {
     pub function_nodes: HashSet<&'static str>,
     pub decision_nodes: HashSet<&'static str>,
-    pub pmd_cyclomatic: bool,
     pub nesting_nodes: HashSet<&'static str>,
     pub ncss_nodes: HashSet<&'static str>,
     pub ncss_containers: HashSet<&'static str>,
@@ -23,7 +22,6 @@ impl LanguageSets {
         LanguageSets {
             function_nodes: language.function_node_types.iter().copied().collect(),
             decision_nodes: language.decision_node_types.iter().copied().collect(),
-            pmd_cyclomatic: language.pmd_cyclomatic,
             nesting_nodes: language.nesting_node_types.iter().copied().collect(),
             ncss_nodes: language.ncss_node_types.iter().copied().collect(),
             ncss_containers: language.ncss_container_node_types.iter().copied().collect(),
@@ -201,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
@@ -216,18 +214,12 @@ impl FunctionBodyPass<'_, '_, '_> {
         // surcharge (Sonar cognitive-complexity semantics).
         let is_continuation = is_decision && is_flat_chain_continuation(current);
 
-        if counts_for_own_body {
-            self.top_frame().cyclomatic_complexity += if self.sets.pmd_cyclomatic {
-                crate::cyclomatic::pmd_cyclomatic_increment(current, self.code)
-            } else {
-                // Each boolean operator and pattern guard is one more execution path; `else` adds
-                // none.
-                u64::from(
-                    is_decision
-                        || is_boolean_operator(current, self.code)
-                        || is_pattern_guard(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 {
@@ -380,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
@@ -633,13 +625,93 @@ 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" {
+        return non_comment_children(node)
+            .into_iter()
+            .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

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/languages.rs

@@ -7,9 +7,6 @@ pub struct LanguageDefinition {
     grammar_id: GrammarId,
     pub function_node_types: &'static [&'static str],
     pub decision_node_types: &'static [&'static str],
-    /// Whether cyclomatic complexity follows PMD's Java CycloVisitor (see cyclomatic.rs) instead of
-    /// the generic one-path-per-decision rule.
-    pub pmd_cyclomatic: bool,
     pub nesting_node_types: &'static [&'static str],
     pub ncss_node_types: &'static [&'static str],
     pub ncss_container_node_types: &'static [&'static str],
@@ -659,7 +656,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::JavaScript,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -670,7 +666,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::JavaScript,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -681,7 +676,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::TypeScript,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -692,7 +686,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Tsx,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -703,7 +696,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Python,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: PYTHON_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -714,7 +706,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Go,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: GO_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: GO_NESTING_NODES,
         ncss_node_types: GO_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -725,7 +716,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Rust,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: RUST_NCSS_NODES,
         ncss_container_node_types: RUST_NCSS_CONTAINERS,
@@ -736,7 +726,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Java,
         function_node_types: JAVA_FUNCTION_NODES,
         decision_node_types: JAVA_DECISION_NODES,
-        pmd_cyclomatic: true,
         nesting_node_types: JAVA_DECISION_NODES,
         ncss_node_types: JAVA_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -747,7 +736,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Ruby,
         function_node_types: RUBY_FUNCTION_NODES,
         decision_node_types: RUBY_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: RUBY_DECISION_NODES,
         ncss_node_types: RUBY_NCSS_NODES,
         ncss_container_node_types: RUBY_NCSS_CONTAINERS,
@@ -758,7 +746,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::C,
         function_node_types: C_FUNCTION_NODES,
         decision_node_types: C_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: C_DECISION_NODES,
         ncss_node_types: C_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -769,7 +756,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Cpp,
         function_node_types: C_FUNCTION_NODES,
         decision_node_types: CPP_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: CPP_DECISION_NODES,
         ncss_node_types: CPP_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -780,7 +766,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::CSharp,
         function_node_types: CSHARP_FUNCTION_NODES,
         decision_node_types: CSHARP_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: CSHARP_DECISION_NODES,
         ncss_node_types: CSHARP_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -791,7 +776,6 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Kotlin,
         function_node_types: KOTLIN_FUNCTION_NODES,
         decision_node_types: KOTLIN_DECISION_NODES,
-        pmd_cyclomatic: false,
         nesting_node_types: KOTLIN_DECISION_NODES,
         ncss_node_types: KOTLIN_NCSS_NODES,
         ncss_container_node_types: KOTLIN_NCSS_CONTAINERS,

package/native/src/lib.rs

@@ -6,7 +6,6 @@ use napi_derive::napi;
 use crate::duplication::DuplicationSettings;
 
 mod complexity;
-mod cyclomatic;
 mod dep_degree;
 mod duplication;
 mod functions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "4.3.0",
+  "version": "4.3.1",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -89,12 +89,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "4.3.0",
-    "code-gauge-linux-arm64-gnu": "4.3.0",
-    "code-gauge-linux-x64-musl": "4.3.0",
-    "code-gauge-linux-arm64-musl": "4.3.0",
-    "code-gauge-darwin-x64": "4.3.0",
-    "code-gauge-darwin-arm64": "4.3.0",
-    "code-gauge-win32-x64-msvc": "4.3.0"
+    "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"
   }
 }

package/native/src/cyclomatic.rs

@@ -1,79 +0,0 @@
-use tree_sitter::Node;
-
-use crate::util::{named_children, node_text, Source};
-
-/// Cyclomatic paths a Java node adds to its function, following PMD 7.26.0's CycloVisitor with
-/// its default options: branches and loops add 1 plus the boolean paths of their condition,
-/// `throw`/`catch`/enhanced `for` add 1, and a switch adds the boolean paths of its tested
-/// expression plus the expression alternatives of each non-default label. `&&`/`||` outside these
-/// conditions (initializers, returns, arguments) and pattern labels and guards add nothing.
-pub fn pmd_cyclomatic_increment(node: Node<'_>, code: &Source<'_>) -> u64 {
-    match node.kind() {
-        "if_statement" | "while_statement" | "do_statement" | "for_statement"
-        | "ternary_expression" => {
-            1 + node
-                .child_by_field_name("condition")
-                .map_or(0, |condition| {
-                    boolean_expression_complexity(condition, code)
-                })
-        }
-        "enhanced_for_statement" | "catch_clause" | "throw_statement" => 1,
-        "switch_expression" => node
-            .child_by_field_name("condition")
-            .map_or(0, |condition| {
-                boolean_expression_complexity(condition, code)
-            }),
-        "switch_block_statement_group" | "switch_rule" => named_children(node)
-            .into_iter()
-            .filter(|child| child.kind() == "switch_label")
-            .flat_map(named_children)
-            .filter(|child| {
-                child.kind() != "guard"
-                    && child.kind() != "pattern"
-                    && !crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind())
-            })
-            .count() as u64,
-        _ => 0,
-    }
-}
-
-/// PMD's booleanExpressionComplexity: a conditional expression costs 2 plus its parts; any other
-/// expression costs its `&&`/`||` operators. PMD has no parenthesis nodes, so they are unwrapped.
-fn boolean_expression_complexity(expression: Node<'_>, code: &Source<'_>) -> u64 {
-    let mut expression = expression;
-    while expression.kind() == "parenthesized_expression" {
-        let Some(inner) = named_children(expression)
-            .into_iter()
-            .find(|child| !crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind()))
-        else {
-            return 0;
-        };
-        expression = inner;
-    }
-    if expression.kind() == "ternary_expression" {
-        return 2 + ["condition", "consequence", "alternative"]
-            .iter()
-            .filter_map(|field| expression.child_by_field_name(field))
-            .map(|part| boolean_expression_complexity(part, code))
-            .sum::<u64>();
-    }
-    count_conditional_operators(expression, code)
-}
-
-/// `&&`/`||` binaries in the subtree, not descending into lambdas or class bodies, which PMD treats
-/// as find boundaries.
-fn count_conditional_operators(node: Node<'_>, code: &Source<'_>) -> u64 {
-    if node.kind() == "lambda_expression" || node.kind() == "class_body" {
-        return 0;
-    }
-    let own = u64::from(
-        node.kind() == "binary_expression"
-            && node
-                .child_by_field_name("operator")
-                .is_some_and(|operator| matches!(node_text(operator, code), "&&" | "||")),
-    );
-    own + named_children(node)
-        .into_iter()
-        .map(|child| count_conditional_operators(child, code))
-        .sum::<u64>()
-}