code-gauge 4.2.1 → 4.3.0

package/native/src/complexity.rs

@@ -12,6 +12,7 @@ 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>,
@@ -22,6 +23,7 @@ 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(),
@@ -74,7 +76,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 +97,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 +105,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 +121,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 +146,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 +191,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;
@@ -211,6 +216,19 @@ 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),
+                )
+            };
+        }
         if is_decision && !is_case_clause {
             if is_continuation {
                 self.top_frame().cognitive_complexity += 1;
@@ -295,6 +313,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,
@@ -562,8 +581,11 @@ fn find_boolean_operator_text<'a>(binary_node: Node<'_>, code: &Source<'a>) -> O
         .map(|child| node_text(child, code))
 }
 
-/// Java `guard`, C# `when_clause`, Ruby `if_guard`, Python `if_clause`, and Rust guards inside
-/// `match_pattern`. A C# exception filter (`catch (E e) when (...)`, a `catch_filter_clause`) is
+/// Java `guard`, C# `when_clause`, Ruby `if_guard`, a Python `case` guard (an `if_clause` under a
+/// `case_clause`), and Rust guards inside `match_pattern`. A Python comprehension filter shares
+/// the `if_clause` type but is a per-element predicate of one expression, not an extra execution
+/// path: Sonar ports differ on it (complexipy charges it), and code-gauge does not, unlike
+/// ternaries and conditions, which are charged. A C# exception filter (`catch (E e) when (...)`, a `catch_filter_clause`) is
 /// deliberately not charged: the catch itself already counts, and the filter is part of the same
 /// handler condition rather than an extra path (SonarC# does not charge it either).
 fn is_pattern_guard(node: Node<'_>) -> bool {
@@ -571,14 +593,14 @@ fn is_pattern_guard(node: Node<'_>) -> bool {
         return false;
     }
     let kind = node.kind();
-    if kind == "guard"
-        || kind == "when_clause"
-        || kind == "if_guard"
-        || kind == "unless_guard"
-        || kind == "if_clause"
-    {
+    if kind == "guard" || kind == "when_clause" || kind == "if_guard" || kind == "unless_guard" {
         return true;
     }
+    if kind == "if_clause" {
+        return node
+            .parent()
+            .is_some_and(|parent| parent.kind() == "case_clause");
+    }
     kind == "match_pattern"
         && all_children(node)
             .iter()
@@ -618,39 +640,51 @@ fn is_default_switch_branch(node: Node<'_>) -> bool {
         return node.child_by_field_name("value").is_none();
     }
 
-    if kind == "switch_block_statement_group" || kind == "switch_rule" {
-        let label = crate::util::named_children(node)
-            .into_iter()
-            .find(|child| child.kind() == "switch_label");
-        return label.is_some_and(|label| label.named_child_count() == 0);
+    // 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")
             });
     }
 
@@ -664,6 +698,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/cyclomatic.rs

@@ -0,0 +1,79 @@
+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>()
+}

package/native/src/dep_degree.rs

@@ -72,6 +72,20 @@ const CSHARP_QUERY_BINDING_PARENT_TYPES: &[&str] = &[
     "query_expression",
 ];
 
+/// C/C++ declarators wrapping the declared name (`int* p = q;`, `int& r = *q;`, `int a[n] = {};`,
+/// `int (*fp)(int) = g;`, member pointer `int C::* p = q;`): the definition field is checked on the
+/// outermost wrapper.
+const DECLARATOR_WRAPPER_TYPES: &[&str] = &[
+    "pointer_declarator",
+    "reference_declarator",
+    "array_declarator",
+    "parenthesized_declarator",
+    "function_declarator",
+    "attributed_declarator",
+    "pointer_type_declarator",
+    "qualified_identifier",
+];
+
 /// Multi-target lists (`a, b = ...`, `a, b := ...`) whose holder's `left` field marks definitions.
 const DEFINITION_LIST_NODE_TYPES: &[&str] = &["expression_list", "pattern_list", "tuple_pattern"];
 const DEFINITION_LIST_HOLDER_TYPES: &[&str] = &[
@@ -119,9 +133,7 @@ pub fn measure_dep_degree(
     let mut pairs = 0u64;
     for index in 0..leaves.len() {
         let leaf = &leaves[index];
-        if !VARIABLE_NODE_TYPES.contains(&leaf.node.kind())
-            && !crate::util::is_kotlin_callable_receiver(leaf.node)
-        {
+        if !is_variable_leaf(leaf.node) {
             continue;
         }
         let name = node_text(leaf.node, code);
@@ -147,6 +159,33 @@ pub fn measure_dep_degree(
     pairs
 }
 
+/// A C++ member-pointer variable (`int C::* p`, also `int C::* arr[1]`) is declared as a
+/// `type_identifier` under the `pointer_type_declarator` spelling `C::*`, possibly through further
+/// declarator wrappers; every other `type_identifier` names a type, not a variable.
+fn is_variable_leaf(node: Node<'_>) -> bool {
+    VARIABLE_NODE_TYPES.contains(&node.kind())
+        || crate::util::is_kotlin_callable_receiver(node)
+        || (node.kind() == "type_identifier" && is_member_pointer_name(node))
+}
+
+fn is_member_pointer_name(node: Node<'_>) -> bool {
+    let mut current = node;
+    while let Some(parent) = current.parent() {
+        if parent.kind() == "pointer_type_declarator" {
+            return true;
+        }
+        // The climb follows the declared-name position only, exactly like unwrap_declarator_wrappers.
+        if !DECLARATOR_WRAPPER_TYPES.contains(&parent.kind())
+            || parent.kind() == "qualified_identifier"
+            || field_name_in_parent(current, parent).is_some_and(|field| field != "declarator")
+        {
+            return false;
+        }
+        current = parent;
+    }
+    false
+}
+
 /// Names a C# accessor body can read without declaring them in its own subtree: the owning
 /// indexer's parameters (including a `params` array, which the grammar names directly on the
 /// parameter list) and, in a setter, initializer, or event accessor, the implicit `value`.
@@ -270,11 +309,10 @@ fn is_structural_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
     {
         return true;
     }
-    if DEFINITION_FIELD_BY_PARENT_TYPE
-        .iter()
-        .any(|(parent_type, definition_field)| {
-            *parent_type == parent.kind() && leaf.field_name == Some(definition_field)
-        })
+    let (declared, declared_field) = unwrap_declarator_wrappers(leaf);
+    if declared
+        .parent()
+        .is_some_and(|holder| is_definition_field(holder, declared_field))
     {
         return true;
     }
@@ -288,6 +326,42 @@ fn is_structural_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
         && field_name_in_parent(parent, holder) == Some("left")
 }
 
+fn is_definition_field(holder: Node<'_>, field_name: Option<&str>) -> bool {
+    DEFINITION_FIELD_BY_PARENT_TYPE
+        .iter()
+        .any(|(parent_type, definition_field)| {
+            *parent_type == holder.kind() && field_name == Some(definition_field)
+        })
+}
+
+/// Climbs from the identifier through the C/C++ declarator wrappers it is the declared name of
+/// (`reference_declarator` and `parenthesized_declarator` expose no field, so their name is the
+/// fieldless child; a member pointer's `pointer_type_declarator` is the `name` of a
+/// `qualified_identifier`; an `array_declarator` size or a nested parameter has another field and
+/// stops the climb) to the outermost wrapper and its field in the declaration.
+fn unwrap_declarator_wrappers<'t>(leaf: &DepDegreeLeaf<'t>) -> (Node<'t>, Option<&'static str>) {
+    let mut current = leaf.node;
+    let mut field_name = leaf.field_name;
+    while let Some(parent) = current
+        .parent()
+        .filter(|parent| DECLARATOR_WRAPPER_TYPES.contains(&parent.kind()))
+    {
+        let declared_field = if parent.kind() == "qualified_identifier" {
+            "name"
+        } else {
+            "declarator"
+        };
+        if field_name.is_some_and(|name| name != declared_field) {
+            break;
+        }
+        field_name = parent
+            .parent()
+            .and_then(|grandparent| field_name_in_parent(parent, grandparent));
+        current = parent;
+    }
+    (current, field_name)
+}
+
 /// Mirrors isParameterDefinition in metrics.ts: an ancestor reached through declarator wrappers
 /// (C/C++ function-pointer or array parameters) is a parameter-ish node, or the identifier
 /// directly occupies a parameter field; type annotations and default values bind nothing.
@@ -306,14 +380,31 @@ fn is_parameter_definition(leaf: &DepDegreeLeaf<'_>) -> bool {
     }
     let mut current = leaf.node;
     let mut depth = 0usize;
+    // Only the member pointer's own declared name may climb past its qualified name; a size or
+    // other expression inside the same declarator (`int C::* a[n]`) is a read.
+    let declares_member_pointer = is_member_pointer_name(leaf.node);
+    let mut in_member_pointer = false;
     loop {
         let Some(parent) = current.parent() else {
             return false;
         };
         let parent_is_parameterish = parent.kind().contains("parameter");
-        // Beyond the grandparent, only declarator wrappers keep climbing; checking this before
-        // the field lookup also keeps reads inside high-arity nodes O(1).
-        if depth >= 1 && !parent_is_parameterish && !parent.kind().contains("declarator") {
+        // Beyond the grandparent, only declarator wrappers keep climbing, plus the
+        // `qualified_identifier` nodes that spell a member-pointer parameter's class (`int C::* q`,
+        // `int N::C::* q`) — entered from the pointer declarator and continued through the `name`
+        // side, so a qualified constant in a default value or array size (`int x = N::M::C`) stays
+        // a read. Checking this before the field lookup also keeps reads inside high-arity nodes
+        // O(1).
+        let continues_member_pointer = declares_member_pointer
+            && parent.kind() == "qualified_identifier"
+            && (current.kind() == "pointer_type_declarator" || in_member_pointer)
+            && field_name_in_parent(current, parent) == Some("name");
+        in_member_pointer = continues_member_pointer;
+        if depth >= 1
+            && !parent_is_parameterish
+            && !parent.kind().contains("declarator")
+            && !continues_member_pointer
+        {
             return false;
         }
         let field = if depth == 0 {