big_code_analysis/metrics/

cyclomatic.rs

// Per-language metric and AST modules deliberately consume the macro-
// generated tree-sitter token enums via `use crate::*` and `use Foo::*`
// inside match expressions — explicit imports would list dozens of
// variants per arm and obscure the per-language token sets that are the
// point of these files. Allowed at the module level rather than per
// function so the per-language impl blocks stay readable.
#![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
// Metric counts (token, function, branch, argument, etc.) are stored as
// `usize` and crossed with `f64` averages, ratios, and Halstead scores
// across the cyclomatic / MI / Halstead computations. The `usize as f64`
// and `f64 as usize` casts are intentional and snapshot-anchored — every
// site is bounded by the count it came from. Allowing the lints at the
// module level keeps the metric arithmetic legible.
#![allow(
    clippy::cast_precision_loss,
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss
)]

use std::fmt;

use crate::checker::Checker;
use crate::macros::implement_metric_trait;
use crate::metrics::ConstraintReach;
use crate::*;

/// The `Cyclomatic` metric.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct Stats {
    cyclomatic_sum: f64,
    cyclomatic: f64,
    /// Number of function/closure spaces in this subtree, used as the
    /// per-function divisor for the cyclomatic averages.
    ///
    /// Seeded to `1` for a [`SpaceKind::Function`][crate::SpaceKind]
    /// space and `0` otherwise (see [`Stats::note_function_space`]), then
    /// summed across child spaces in [`Stats::merge`]. This is the
    /// per-function divisor convention shared with `cognitive`/`exit`/
    /// `nargs`, sourced independently of whether the `Nom` metric was
    /// selected (#512).
    ///
    /// It counts the function/closure *spaces* — the spaces that each
    /// contribute a base cyclomatic value to the sum — so it equals
    /// `nom.total()` wherever every function and closure opens its own
    /// space (the common case). The known exception is a closure form
    /// that opens no space, such as a Python `lambda`: `nom` counts it
    /// but it folds its decisions into the enclosing space, so
    /// `function_spaces` does not count it as a separate divisor unit.
    function_spaces: usize,
    cyclomatic_max: f64,
    cyclomatic_min: f64,
    cyclomatic_modified_sum: f64,
    cyclomatic_modified: f64,
    cyclomatic_modified_max: f64,
    cyclomatic_modified_min: f64,
    constraint: ConstraintReach,
}

impl Default for Stats {
    fn default() -> Self {
        Self {
            cyclomatic_sum: 0.,
            cyclomatic: 1.,
            function_spaces: 0,
            cyclomatic_max: 0.,
            cyclomatic_min: f64::MAX,
            cyclomatic_modified_sum: 0.,
            cyclomatic_modified: 1.,
            cyclomatic_modified_max: 0.,
            cyclomatic_modified_min: f64::MAX,
            constraint: ConstraintReach::default(),
        }
    }
}

impl fmt::Display for Stats {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "sum: {}, average: {}, min: {}, max: {}, \
             modified_sum: {}, modified_average: {}, modified_min: {}, modified_max: {}",
            self.cyclomatic_sum(),
            self.cyclomatic_average(),
            self.cyclomatic_min(),
            self.cyclomatic_max(),
            self.cyclomatic_modified_sum(),
            self.cyclomatic_modified_average(),
            self.cyclomatic_modified_min(),
            self.cyclomatic_modified_max(),
        )
    }
}

impl Stats {
    /// Merges a second `Cyclomatic` metric into the first one
    pub fn merge(&mut self, other: &Stats) {
        self.cyclomatic_max = self.cyclomatic_max.max(other.cyclomatic_max);
        self.cyclomatic_min = self.cyclomatic_min.min(other.cyclomatic_min);
        self.cyclomatic_sum += other.cyclomatic_sum;
        self.function_spaces += other.function_spaces;

        self.cyclomatic_modified_max = self
            .cyclomatic_modified_max
            .max(other.cyclomatic_modified_max);
        self.cyclomatic_modified_min = self
            .cyclomatic_modified_min
            .min(other.cyclomatic_modified_min);
        self.cyclomatic_modified_sum += other.cyclomatic_modified_sum;
    }

    /// Returns the `Cyclomatic` metric value for the current space.
    #[must_use]
    pub fn cyclomatic(&self) -> u64 {
        self.cyclomatic as u64
    }

    /// Returns the sum of standard cyclomatic values across all spaces.
    #[must_use]
    pub fn cyclomatic_sum(&self) -> u64 {
        self.cyclomatic_sum as u64
    }

    /// Returns the average standard cyclomatic complexity.
    ///
    /// The divisor is the number of function/closure spaces in the
    /// subtree (`function_spaces`), guarded with `.max(1)` via the shared
    /// `average` helper. This is the per-function convention shared with
    /// `cognitive`/`exit`/`nargs`; before #512 the divisor was the
    /// per-space count `n`, which also counted classes, structs, and the
    /// file unit and so reported a different — lower — average.
    #[must_use]
    pub fn cyclomatic_average(&self) -> f64 {
        crate::metrics::average(self.cyclomatic_sum() as f64, self.function_spaces)
    }

    /// Returns the maximum standard cyclomatic complexity.
    #[must_use]
    pub fn cyclomatic_max(&self) -> u64 {
        self.cyclomatic_max as u64
    }

    /// Returns the minimum standard cyclomatic complexity.
    ///
    /// Collapses the `f64::MAX` sentinel that `Stats::default()` plants
    /// into `cyclomatic_min` to `0`, so a never-observed space
    /// serializes to a meaningful number rather than `1.7976931e308`.
    #[allow(clippy::float_cmp)]
    #[must_use]
    pub fn cyclomatic_min(&self) -> u64 {
        if self.cyclomatic_min == f64::MAX {
            0
        } else {
            self.cyclomatic_min as u64
        }
    }

    /// Returns the modified cyclomatic complexity for the current space.
    ///
    /// Modified cyclomatic counts each switch/match/when/select container as
    /// one decision point regardless of how many case arms it contains.  All
    /// other branching constructs are weighted identically to standard CCN.
    ///
    /// Edge case: an empty switch (`switch (x) {}`) yields modified = 1
    /// and standard = 0, so modified can exceed standard for arm-less
    /// containers.  This matches Lizard's `-m` convention, which keys on
    /// the switch keyword rather than the presence of arms.
    #[must_use]
    pub fn cyclomatic_modified(&self) -> u64 {
        self.cyclomatic_modified as u64
    }

    /// Returns the sum of modified cyclomatic values across all spaces.
    #[must_use]
    pub fn cyclomatic_modified_sum(&self) -> u64 {
        self.cyclomatic_modified_sum as u64
    }

    /// Returns the average modified cyclomatic complexity.
    ///
    /// Uses the same per-function divisor (`function_spaces`, guarded by
    /// the shared `average` helper) as [`Stats::cyclomatic_average`].
    #[must_use]
    pub fn cyclomatic_modified_average(&self) -> f64 {
        crate::metrics::average(self.cyclomatic_modified_sum() as f64, self.function_spaces)
    }

    /// Returns the maximum modified cyclomatic complexity.
    #[must_use]
    pub fn cyclomatic_modified_max(&self) -> u64 {
        self.cyclomatic_modified_max as u64
    }

    /// Returns the minimum modified cyclomatic complexity.
    ///
    /// Same `f64::MAX` sentinel collapse as `cyclomatic_min`.
    #[allow(clippy::float_cmp)]
    #[must_use]
    pub fn cyclomatic_modified_min(&self) -> u64 {
        if self.cyclomatic_modified_min == f64::MAX {
            0
        } else {
            self.cyclomatic_modified_min as u64
        }
    }

    /// Marks this space as a function/closure space, seeding the
    /// per-function divisor (`function_spaces`) with `1`.
    ///
    /// Called once at space construction for every
    /// [`SpaceKind::Function`][crate::SpaceKind] space; non-function
    /// spaces leave the seed at its `0` default. [`Stats::merge`] then
    /// sums the seeds so each space's `function_spaces` reflects the
    /// function/closure count of its whole subtree — independently of
    /// the `Nom` metric (#512).
    #[inline]
    pub(crate) fn note_function_space(&mut self) {
        self.function_spaces = 1;
    }

    #[inline]
    pub(crate) fn compute_sum(&mut self) {
        self.cyclomatic_sum += self.cyclomatic;
        self.cyclomatic_modified_sum += self.cyclomatic_modified;
    }

    #[inline]
    pub(crate) fn compute_minmax(&mut self) {
        self.cyclomatic_max = self.cyclomatic_max.max(self.cyclomatic);
        self.cyclomatic_min = self.cyclomatic_min.min(self.cyclomatic);
        self.cyclomatic_modified_max = self.cyclomatic_modified_max.max(self.cyclomatic_modified);
        self.cyclomatic_modified_min = self.cyclomatic_modified_min.min(self.cyclomatic_modified);
        self.compute_sum();
    }
}

#[doc(hidden)]
/// Per-language computation of cyclomatic complexity.
pub(crate) trait Cyclomatic
where
    Self: Checker,
{
    /// Walk `node` and update `stats` with this metric for the language
    /// implementing the trait.
    ///
    /// `code` is the source bytes the node spans, so that languages
    /// whose branching constructs surface as untyped `Call` nodes
    /// (Elixir's `if`/`unless`/`for`/`while`/`with`/`case`/`cond`,
    /// for example) can identify them by inspecting the call target's
    /// text. Most languages discard the parameter with `_`.
    fn compute<'a>(
        node: &Node<'a>,
        code: &'a [u8],
        _ancestors: Ancestors<'a, '_>,
        stats: &mut Stats,
    );

    /// Like [`Cyclomatic::compute`], but honors per-traversal options.
    ///
    /// `count_try` toggles whether Rust's `?` operator (the
    /// `try_expression` grammar node) contributes to cyclomatic
    /// complexity. The default body ignores `count_try` and delegates
    /// to [`Cyclomatic::compute`], so every language whose grammar has
    /// no `try_expression` node keeps its existing behaviour with no
    /// per-language edit. Only [`RustCode`] overrides this to act on
    /// the flag (#409).
    #[inline]
    fn compute_with_options<'a>(
        node: &Node<'a>,
        code: &'a [u8],
        ancestors: Ancestors<'a, '_>,
        stats: &mut Stats,
        count_try: bool,
    ) {
        let _ = count_try;
        Self::compute(node, code, ancestors, stats);
    }
}

/// C-family cyclomatic: `Case` adds standard, `SwitchStatement` adds
/// modified, and the shared branching kinds add both.  The ternary token
/// name varies (`TernaryExpression` for JS-family, `ConditionalExpression`
/// for Cpp), so it's a parameter.  The short-circuit operator list is
/// also a parameter because JS-family languages include nullish
/// coalescing (`??`, token `QMARKQMARK`) and the three compound short-
/// circuit assignment forms `&&=` (`AMPAMPEQ`), `||=` (`PIPEPIPEEQ`),
/// `??=` (`QMARKQMARKEQ`) on top of `&&` and `||`, while C++ has only
/// `&&` and `||` (issues #226, #231, #248).
///
/// **`If` / `For` / `While` are keyword tokens in the per-language
/// enums (e.g. `Cpp::While == "while"`), not statement nodes.** The
/// `while` token therefore fires once inside both `WhileStatement` AND
/// `DoStatement` (the `while` keyword of `do { … } while (…)`), and
/// the `for` token fires once inside `ForStatement`, C++
/// `ForRangeLoop`, Java `EnhancedForStatement`, and any other
/// grammar-specific loop form that spells the keyword `for`. So
/// adding the statement nodes themselves would double-count those
/// loops — see issue #284 for the false-positive analysis. The
/// regression tests `cpp_do_statement_counts_in_cyclomatic`,
/// `cpp_for_range_loop_counts_in_cyclomatic`,
/// `java_do_statement_counts_in_cyclomatic`, and
/// `java_enhanced_for_statement_counts_in_cyclomatic` pin the
/// correct keyword-driven counts.
///
/// `applied_if = <fn(&Node, Ancestors) -> bool>` gates the short-circuit
/// arm on the token's ancestry, for a grammar that spells the operator
/// token in productions where it applies nothing (C++'s `int&& x`).
///
/// `constraints = [<kinds>]` names the nodes whose whole subtree scores
/// no decision, tracked by [`ConstraintReach`] so the test is `O(1)` per
/// node: C++'s compile-time `requires` clause and expression.
macro_rules! impl_cyclomatic_c_family {
    (
        $code:ty,
        $lang:ident,
        $ternary:ident,
        [$($short_circuit:ident),+ $(,)?]
        $(, applied_if = $applied:path)?
        $(, constraints = [$($constraint:ident),+ $(,)?])? $(,)?
    ) => {
        impl Cyclomatic for $code {
            fn compute<'a>(
                node: &Node<'a>,
                _code: &'a [u8],
                ancestors: Ancestors<'a, '_>,
                stats: &mut Stats,
            ) {
                use $lang::*;
                $(
                    let opens = matches!(node.kind_id().into(), $($constraint)|+);
                    if stats.constraint.covers(node, opens) {
                        return;
                    }
                )?
                match node.kind_id().into() {
                    Case => stats.cyclomatic += 1.,
                    SwitchStatement => stats.cyclomatic_modified += 1.,
                    If | For | While | Catch | $ternary => {
                        stats.cyclomatic += 1.;
                        stats.cyclomatic_modified += 1.;
                    }
                    $($short_circuit)|+ => {
                        $(
                            if !$applied(node, ancestors) {
                                return;
                            }
                        )?
                        stats.cyclomatic += 1.;
                        stats.cyclomatic_modified += 1.;
                    }
                    _ => {}
                }
                // Read only by a gated expansion.
                let _ = ancestors;
            }
        }
    };
}

/// Whether a C++ binary operator token applies its operator under
/// `parent`, as opposed to spelling the same token in a declaration:
/// an overload name (`operator&&`, `operator<`), a reference declarator
/// or ref-qualifier (`int&& x`, `void f() &&`), a requires-clause
/// constraint (`requires A<T> && B<T>`), or a template delimiter.
///
/// It answers from the parent alone, so it stays O(1) per token. A
/// parenthesised constraint (`requires (A<T> && B<T>)`) parses as an
/// ordinary `binary_expression` and passes; the callers leave it out
/// through [`ConstraintReach`], because climbing to the enclosing
/// `requires_clause` from every token made a long `&&` chain quadratic.
///
/// An allowlist, so a grammar bump adding a production fails closed and
/// a token reparented under `{ERROR}` stops counting. Compared by kind
/// *name* so one body serves both tree-sitter-cpp and the vendored
/// Mozcpp fork, whose ids differ; every `binary_expression` (an `#if`
/// operand included) carries the aliased id `BinaryExpression2` at the
/// pinned grammars, and the name also covers the never-emitted
/// pre-alias id. A fold counts once, through its `operator` field,
/// because a binary fold `(0 && ... && a)` spells its operator twice.
pub(crate) fn cpp_operator_is_applied<'a>(node: &Node<'a>, ancestors: Ancestors<'a, '_>) -> bool {
    ancestors
        .parent(node)
        .is_some_and(|parent| match parent.kind() {
            "binary_expression" => true,
            "fold_expression" => parent
                .child_by_field_name("operator")
                .is_some_and(|op| op.id() == node.id()),
            _ => false,
        })
}

// JS-family: include nullish coalescing (`??`) and the three compound
// short-circuit assignments `&&=`, `||=`, `??=` as short-circuit
// decisions in addition to `&&` and `||` (issues #226, #231, #248).
// Each `op=` is semantically `x = x op y` — one short-circuit decision
// edge, same as the bare operator. Cognitive parity comes from #236.
//
// Optional chaining `?.` is also short-circuit (it skips the rest of
// the chain when the LHS is nullish) and adds one decision point per
// occurrence (issue #281). The token varies across grammars:
// JS/MozJS expose only `OptionalChain` (which IS the `?.` token in
// those grammars), while TS/TSX expose both an `optional_chain`
// wrapper and a child `?.` token (`QMARKDOT`); counting `QMARKDOT`
// matches every textual `?.` exactly once in TS/TSX.
macro_rules! impl_cyclomatic_js_family {
    ($code:ty, $lang:ident, $opt_chain:ident) => {
        impl_cyclomatic_c_family!(
            $code,
            $lang,
            TernaryExpression,
            [
                AMPAMP,
                PIPEPIPE,
                QMARKQMARK,
                AMPAMPEQ,
                PIPEPIPEEQ,
                QMARKQMARKEQ,
                $opt_chain
            ]
        );
    };
}

// Java and Groovy share the same decision-kind set for cyclomatic
// complexity; Groovy adds `Assert` as an extra branch (its `assert`
// keyword is a runtime check that branches on its condition,
// matching Sonar's standard-CCN treatment). `impl_cyclomatic_java_like!`
// emits the same match body against each enum, with an
// `[$($extra:ident),*]` list for any language-specific decision kinds
// (issue #300; mirrors `impl_npm_java_like!` / `impl_npa_java_like!`).
//
// Why a dedicated macro instead of reusing `impl_cyclomatic_c_family!`:
// the C-family macro uses `SwitchStatement` (the wrapping node) as the
// modified-CCN container marker, whereas Java/Groovy use the `Switch`
// keyword token — which fires exactly once per switch (both classic
// switch statements and Java 14+ switch expressions). Counting the
// keyword keeps the modified-CCN tally aligned with the standard-CCN
// `Case` arms.
//
// Keyword-vs-statement (issue #284): `If` / `For` / `While` here are
// the *keyword* tokens (`Java::While == "while"`, etc.), not the
// statement nodes. The `while` keyword therefore fires inside both
// `WhileStatement` and `DoStatement`, and the `for` keyword fires
// inside both `ForStatement` and `EnhancedForStatement`. The
// grammar-specific loop forms are already counted via their inner
// keyword tokens; listing the statement nodes here would
// double-count. The regression tests
// `java_do_statement_counts_in_cyclomatic`,
// `java_enhanced_for_statement_counts_in_cyclomatic`,
// `groovy_do_statement_counts_in_cyclomatic`, and
// `groovy_enhanced_for_statement_counts_in_cyclomatic` pin the
// correct keyword-driven counts.
//
// Groovy note: under the pinned dekobon grammar (root Cargo.toml),
// Elvis `?:` and the safe-navigation operators `?.` / `??.` all parse
// cleanly to dedicated nodes with real lexer tokens, so they are
// counted as branches via the GroovyCode extra-token list below (see
// the per-call rationale at that invocation). This differs from
// amaanq's grammar, which emitted ERROR nodes for those constructs.
macro_rules! impl_cyclomatic_java_like {
    ($code:ty, $lang:ident, [$($extra:ident),* $(,)?]) => {
        impl Cyclomatic for $code {
            fn compute<'a>(
                node: &Node<'a>,
                _code: &'a [u8],
                _ancestors: Ancestors<'a, '_>,
                stats: &mut Stats,
            ) {
                use $lang::*;

                match node.kind_id().into() {
                    Case => {
                        stats.cyclomatic += 1.;
                    }
                    Switch => {
                        stats.cyclomatic_modified += 1.;
                    }
                    If | For | While | Catch | TernaryExpression | AMPAMP | PIPEPIPE
                    $(| $extra)* => {
                        stats.cyclomatic += 1.;
                        stats.cyclomatic_modified += 1.;
                    }
                    _ => {}
                }
            }
        }
    };
}

// Real defaults — no executable branches. Audited in #188.
implement_metric_trait!(Cyclomatic, PreprocCode, CcommentCode);

/// Detects C# `switch_expression_arm`s whose pattern is a bare discard
/// (`_` or `var _`) and which carry no `when` guard — the analogue of
/// the C-family `default:` arm. Such arms must NOT contribute to
/// standard CCN, mirroring Rust's `_ =>` and Java/C#'s `default:`
/// treatment (lesson 11 / parity family 5). A guarded discard
/// (`_ when g => …`) still counts because the guard introduces a
/// non-trivial decision, matching Rust's `_ if g` rule.
pub(crate) fn csharp_switch_expression_arm_is_bare_discard(node: &Node) -> bool {
    use Csharp::*;

    /// Classification of a `switch_expression_arm`'s pattern child.
    /// `BareDiscard` means `_` or `var _` (the C# analogue of
    /// `default:`); any concrete type test, constant, or composite
    /// pattern is `NotDiscard` and still contributes to standard CCN.
    enum PatternKind {
        BareDiscard,
        NotDiscard,
    }

    fn classify_pattern(child: &Node) -> PatternKind {
        match child.kind_id().into() {
            // `pattern` is a supertype: tree-sitter flattens it to the
            // concrete subtype in the parse tree, so a bare `_` arm
            // surfaces as a direct `discard` child.
            Discard => PatternKind::BareDiscard,
            // `var _` parses as a `declaration_pattern` with children
            // `implicit_type` (`var`) and `discard` (`_`) rather than
            // as a `var_pattern` — tree-sitter-c-sharp treats `var` as
            // an implicit type designator. A `declaration_pattern`
            // whose only named children are `implicit_type` and
            // `discard` is therefore semantically the bare discard.
            // A non-implicit type (`int _`) is NOT excluded — the
            // type test is still a non-trivial decision.
            DeclarationPattern => {
                let mut saw_discard = false;
                let mut saw_implicit_type = false;
                for sub in child.children().filter(Node::is_named) {
                    match sub.kind_id().into() {
                        Discard => saw_discard = true,
                        ImplicitType => saw_implicit_type = true,
                        _ => return PatternKind::NotDiscard,
                    }
                }
                if saw_discard && saw_implicit_type {
                    PatternKind::BareDiscard
                } else {
                    PatternKind::NotDiscard
                }
            }
            _ => PatternKind::NotDiscard,
        }
    }

    let mut named = node.children().filter(Node::is_named);
    let Some(pattern) = named.next() else {
        return false;
    };
    let PatternKind::BareDiscard = classify_pattern(&pattern) else {
        return false;
    };
    // A guarded discard (`_ when g => …`) still counts because the
    // guard introduces a non-trivial decision, matching Rust's
    // `_ if g` rule.
    !named.any(|c| c.kind_id() == WhenClause)
}

/// Distinguishes the C# `case` keyword of a real `switch` arm from the
/// one inside `goto case 2;`, which spells the same token (id 114) from
/// a second production and is an unconditional jump, not a decision.
///
/// A `grammar.json` sweep of tree-sitter-c-sharp 0.23.5 finds the
/// `"case"` string in exactly two rules — `switch_section` and
/// `goto_statement` — and only the first is an arm. `Csharp::Case` and
/// `Csharp::SwitchSection` each carry no numeric-suffix alias at this
/// pin (`.claude/rules/grammar-dispatch.md` §1), and `switch_section`
/// is not a hidden `_`-prefixed rule (§2), so the one-variant allowlist
/// is the whole answer.
///
/// Allowlist polarity, matching the comparison-token gate in
/// `src/metrics/abc/csharp.rs`: naming the one decision parent means a
/// grammar bump that grows a third `case`-bearing production fails
/// *closed* — the new spelling stops counting rather than silently
/// counting as an arm. It also covers error recovery, where a token the
/// parser reparents under `{ERROR}` stops counting; nothing pins that,
/// because a fixture the language rejects would make the grammar's
/// present recovery the contract (§6).
///
/// Both C# metrics that count the bare token gate on this — ABC's
/// `conditions` and cyclomatic's decision count — so `goto case` moves
/// them together. Cognitive models the construct on a different node
/// entirely (`GotoStatement`, +1 as an unstructured jump per
/// SonarSource §B2, `src/metrics/cognitive/csharp.rs`) and is
/// unaffected: a `goto case` remains a jump there, it merely stops
/// also being an arm here.
///
/// `goto default;` needed no equivalent gate: `Default` is a distinct
/// token that neither metric counts, since it is the switch's
/// unconditional fallthrough (#456, #469).
pub(crate) fn csharp_case_token_is_switch_arm<'a>(
    node: &Node<'a>,
    ancestors: Ancestors<'a, '_>,
) -> bool {
    ancestors.parent_has_kind(node, Csharp::SwitchSection as u16)
}

/// Detects Kotlin `when_entry` nodes that are `else -> …` arms — the
/// analogue of the C-family `default:` arm. tree-sitter-kotlin-ng
/// attaches a `condition` field to every case-style entry; the `else`
/// arm has no `condition` field (only an anonymous `else` keyword
/// child). Such arms must NOT contribute to standard CCN.
pub(crate) fn kotlin_when_entry_is_else(node: &Node) -> bool {
    node.child_by_field_name("condition").is_none()
}

/// Detects Bash `*)` catch-all arms inside `case … esac`. Returns
/// `true` when the case_item has exactly one `value` field whose
/// source text is the literal `*`. Multi-value patterns (`a|b`,
/// `*|b`) are NOT bare and still count as decisions.
pub(crate) fn bash_case_item_is_bare_wildcard(node: &Node, code: &[u8]) -> bool {
    // tree-sitter-bash attaches the `value` field to each alternation
    // in the case pattern (`a|b)` produces two `value` children).
    // Walk via a single `TreeCursor`: `field_name()` exposes the field
    // for the current position and `goto_next_sibling()` is O(1), so
    // total cost is linear in child count — avoiding the per-call
    // O(i) `Node::child(i)` access that an index-based loop would
    // pay on every iteration.
    let mut cursor = node.as_tree_sitter().walk();
    if !cursor.goto_first_child() {
        return false;
    }
    let mut value_count = 0usize;
    let mut sole_value_is_star = false;
    loop {
        if cursor.field_name() == Some("value") {
            value_count += 1;
            if value_count > 1 {
                return false;
            }
            sole_value_is_star = cursor.node().utf8_text(code).is_ok_and(|s| s.trim() == "*");
        }
        if !cursor.goto_next_sibling() {
            break;
        }
    }
    value_count == 1 && sole_value_is_star
}

// Per-language `Cyclomatic` impls live in sibling modules. The `mod`
// declarations sit after the local `macro_rules!` so textual macro
// scoping reaches the child files (mirrors `getter.rs` and
// `metrics::abc`).
mod bash;
mod c;
mod cpp;
mod csharp;
mod elixir;
mod go;
mod groovy;
mod irules;
mod java;
mod javascript;
mod kotlin;
mod lua;
mod mozcpp;
mod mozjs;
mod objc;
mod perl;
mod php;
mod python;
mod ruby;
mod rust;
mod tcl;
mod tsx;
mod typescript;

#[cfg(test)]
#[allow(
    clippy::float_cmp,
    clippy::cast_precision_loss,
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss,
    clippy::similar_names,
    clippy::doc_markdown,
    clippy::needless_raw_string_hashes,
    clippy::too_many_lines
)]
mod tests {
    #[cfg(feature = "csharp")]
    use crate::test_support::assert_csharp_fixture_spells;
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    use crate::test_support::assert_fixture_spells;
    use crate::test_support::{
        ast_has_kind_id, check_func_space_only, check_metrics_only_shim, child_space,
    };

    use super::*;

    check_metrics_only_shim!(check_metrics, Cyclomatic);
    // Two tests reconcile the cyclomatic per-function divisor against
    // `nom.total()` (#512). Cyclomatic deliberately does *not* declare
    // Nom as a dependency — `cyclomatic_average_per_function_without_nom_512`
    // exists to pin that the divisor comes from the space kind, not from
    // Nom — so those two ask for Nom explicitly.
    check_metrics_only_shim!(check_cyclomatic_and_nom, Cyclomatic, Nom);

    /// A `Stats::default()` that never sees an
    /// observation must not leak the `f64::MAX` sentinel for
    /// `cyclomatic_min` or `cyclomatic_modified_min`. Both getters
    /// collapse the sentinel to `0.0` so JSON never emits
    /// `1.7976931e308`.
    #[test]
    fn cyclomatic_empty_file_min_is_zero() {
        let stats = Stats::default();
        assert_eq!(stats.cyclomatic_min(), 0);
        assert_eq!(stats.cyclomatic_modified_min(), 0);
    }

    /// A `Stats::default()` with no function spaces and an unguarded
    /// divisor would divide by zero. The shared `average` helper guards
    /// the divisor with `.max(1)`, so a function-less aggregate yields a
    /// finite `0.0` rather than `NaN` (#512 — the guard `cognitive`/
    /// `exit`/`nargs` already had, now applied to cyclomatic too).
    #[test]
    fn cyclomatic_no_function_spaces_average_is_finite() {
        let stats = Stats::default();
        assert_eq!(stats.cyclomatic_average(), 0.0);
        assert_eq!(stats.cyclomatic_modified_average(), 0.0);
    }

    /// #512: the cyclomatic average divisor is now the per-function count
    /// (`function_spaces`), reconciled with the `cognitive`/`exit`/`nargs`
    /// convention, *not* the per-space count `n` it used before. For a
    /// file with one class holding two methods the spaces are
    /// `{unit, class, method, method}` (4) but only the two methods are
    /// functions, so the divisor is 2.
    ///
    /// Here every function/closure opens its own space, so
    /// `function_spaces == nom.total()` and
    /// `cyclomatic_average == cyclomatic_sum / nom.total()` — the same
    /// denominator `cognitive_average` divides by. (That equality can
    /// break for closure forms that open no space, e.g. Python lambdas —
    /// see `cyclomatic_python_lambda_divisor_excludes_spaceless_closure`.)
    /// Before #512 the divisor was 4 (every space, base 1 each) and the
    /// averages were two-thirds of these values (`6 / 4 == 1.5`).
    #[cfg(feature = "csharp")]
    #[test]
    fn cyclomatic_average_is_per_function_512() {
        check_cyclomatic_and_nom::<CsharpParser>(
            "class A {
                 int f(int x) { return x > 0 ? 1 : 2; }
                 int g(int x) { return x > 0 ? 1 : 2; }
             }",
            "foo.cs",
            |metric| {
                // Sum is over every space's base 1 plus its decisions:
                // unit(1) + class(1) + f(1 + ternary 1) + g(1 + ternary 1)
                // = 6.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 6);
                // Divisor is the two function spaces, not the four total
                // spaces: 6 / 2 = 3.0 (was 6 / 4 = 1.5 before #512).
                assert_eq!(metric.cyclomatic.cyclomatic_average(), 3.0);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_average(), 3.0);
                // Reconciliation invariant: cyclomatic divides by the same
                // function/closure count cognitive does.
                assert_eq!(
                    metric.cyclomatic.cyclomatic_average(),
                    metric.cyclomatic.cyclomatic_sum() as f64 / metric.nom.total() as f64
                );
                assert_eq!(metric.nom.total(), 2);
            },
        );
    }

    /// #512: the per-function divisor is sourced from the space kind, not
    /// from the `Nom` metric, so selecting `cyclomatic` *alone* (which
    /// does not pull `Nom` in via the metric-selection dependency graph)
    /// still divides by the function count. This guards the load-bearing
    /// "one selected metric emits exactly that metric" contract: coupling
    /// cyclomatic to `nom` to obtain the divisor would have leaked a
    /// `nom` block into a cyclomatic-only selection.
    ///
    /// `nom.total()` is `0.0` here (Nom was never computed) yet the
    /// average is still the correct per-function `6 / 2 == 3.0` — proof
    /// the divisor does not read `nom`.
    #[cfg(feature = "csharp")]
    #[test]
    fn cyclomatic_average_per_function_without_nom_512() {
        let space = crate::analyze(
            crate::Source::new(
                crate::LANG::Csharp,
                b"class A {\n  int f(int x) { return x > 0 ? 1 : 2; }\n  int g(int x) { return x > 0 ? 1 : 2; }\n}",
            )
            .with_name(Some("foo.cs".to_owned())),
            crate::MetricsOptions::default().with_only(&[crate::Metric::Cyclomatic]),
        )
        .expect("analyze must succeed on a well-formed C# fixture");

        let c = &space.metrics.cyclomatic;
        assert_eq!(c.cyclomatic_sum(), 6);
        assert_eq!(c.cyclomatic_average(), 3.0);
        assert_eq!(c.cyclomatic_modified_average(), 3.0);
        // Nom was not selected, so its count stays at the zero default —
        // the cyclomatic divisor must not depend on it.
        assert_eq!(space.metrics.nom.total(), 0);
    }

    /// #512 edge case: a Python `lambda` is counted by `nom` (as a
    /// closure) but opens **no** function space — it folds its decisions
    /// into the enclosing space. So `function_spaces` counts only the
    /// spaces that actually carry a cyclomatic value (here the single
    /// `def`), and the cyclomatic divisor is `1`, not `nom.total()`'s `2`.
    ///
    /// This documents that the per-function reconciliation with
    /// `cognitive` is exact only where every function/closure opens its
    /// own space; for spaceless closures `function_spaces` is the divisor
    /// that matches the spaces contributing to `cyclomatic_sum`. The
    /// behaviour is intentional, not a bug — pinning it so a future change
    /// to lambda space-handling is a deliberate, visible decision.
    #[cfg(feature = "python")]
    #[test]
    fn cyclomatic_python_lambda_divisor_excludes_spaceless_closure() {
        check_cyclomatic_and_nom::<PythonParser>(
            "def f(x):\n    return x if x > 0 else -x\ng = lambda y: y if y else 0\n",
            "p.py",
            |metric| {
                // sum: unit(1 + lambda's ternary 1) + f(1 + ternary 1) = 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                // nom counts the lambda as a closure, so total == 2 …
                assert_eq!(metric.nom.total(), 2);
                // … but only the `def` opens a function space, so the
                // cyclomatic divisor is 1: 4 / 1 = 4.0, which deliberately
                // differs from cyclomatic_sum / nom.total() (4 / 2 = 2.0).
                assert_eq!(metric.cyclomatic.cyclomatic_average(), 4.0);
            },
        );
    }

    /// A plain `if/else` must not be credited
    /// as a loop-`else`. The `Else` arm of `impl Cyclomatic for
    /// PythonCode` previously fired for every `else_clause` because
    /// the old `has_ancestors` helper only verified the second
    /// predicate; the rewritten `parent_grandparent_match` requires
    /// the grandparent to be `for/while/try`.
    ///
    /// Expected: unit(1) + fn(1) + if(1) = 3. No contribution from
    /// `else`.
    #[cfg(feature = "python")]
    #[test]
    fn python_if_else_does_not_overcount_229() {
        check_metrics::<PythonParser>(
            "def f(x):
    if x > 0:
        y = 1
    else:
        y = 2
",
            "foo.py",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 3,
                  "value": 1,
                  "average": 3.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Companion to #229: a chained `if/elif/else` must count one
    /// per `if` and per `elif`, never the bare `else`.
    ///
    /// Expected: unit(1) + fn(1) + if(1) + elif(1) + elif(1) = 5.
    #[cfg(feature = "python")]
    #[test]
    fn python_if_elif_else_chain_229() {
        check_metrics::<PythonParser>(
            "def f(x):
    if x == 1:
        return 10
    elif x == 2:
        return 20
    elif x == 3:
        return 30
    else:
        return 0
",
            "foo.py",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
            },
        );
    }

    /// The for/else feature must still count: the `else` body runs
    /// only when the loop completes without `break`, which is a
    /// distinct decision point.
    ///
    /// Expected: unit(1) + fn(1) + for(1) + else(1) = 4.
    #[cfg(feature = "python")]
    #[test]
    fn python_for_else_still_counts_229() {
        check_metrics::<PythonParser>(
            "def f(xs):
    for x in xs:
        if x < 0:
            break
    else:
        return True
    return False
",
            "foo.py",
            |metric| {
                // fn body has: for(1) + if(1) + for/else(1) = 3 over base 1 -> max = 4
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
            },
        );
    }

    /// Symmetric to for/else: while/else also runs only on normal
    /// completion of the loop.
    ///
    /// Expected: unit(1) + fn(1) + while(1) + else(1) = 4.
    #[cfg(feature = "python")]
    #[test]
    fn python_while_else_still_counts_229() {
        check_metrics::<PythonParser>(
            "def f(n):
    while n > 0:
        n -= 1
    else:
        return True
    return False
",
            "foo.py",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    /// try/except/else: the `else` body runs only when no exception
    /// was raised in `try`, mirroring loop-`else` semantics. Counts
    /// alongside the `except` arm.
    ///
    /// Expected: unit(1) + fn(1) + except(1) + try/else(1) = 4.
    #[cfg(feature = "python")]
    #[test]
    fn python_try_except_else_counts_229() {
        check_metrics::<PythonParser>(
            "def f():
    try:
        x = risky()
    except ValueError:
        x = -1
    else:
        x = x + 1
    return x
",
            "foo.py",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    /// `with` is unconditional resource management, not a branch, so it
    /// must not add to cyclomatic complexity — matching the C-family
    /// `using` sibling and textbook McCabe. Regression test for #418.
    ///
    /// Expected: unit(1) + fn(1) = 2; the `with` adds nothing.
    #[cfg(feature = "python")]
    #[test]
    fn python_with_is_not_a_decision_point_418() {
        check_metrics::<PythonParser>(
            "def f():
    with open('a') as fp:
        return fp.read()
",
            "foo.py",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 1);
            },
        );
    }

    /// A `with` managing multiple context managers (`with a, b:`) parses
    /// as a single `with_statement` with one `with` keyword token, so it
    /// stays uncounted just like the single-manager form. Companion to
    /// #418.
    ///
    /// Expected: unit(1) + fn(1) = 2.
    #[cfg(feature = "python")]
    #[test]
    fn python_with_multiple_managers_is_not_a_decision_point_418() {
        check_metrics::<PythonParser>(
            "def f(a, b):
    with a, b:
        return 1
",
            "foo.py",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 2);
            },
        );
    }

    /// `async with` reuses the same `with` keyword token as plain
    /// `with`, so dropping `With` from the decision arm stops counting
    /// it too. Companion to #418.
    ///
    /// Expected: unit(1) + fn(1) = 2; neither `async` nor `with` counts.
    #[cfg(feature = "python")]
    #[test]
    fn python_async_with_is_not_a_decision_point_418() {
        check_metrics::<PythonParser>(
            "async def f():
    async with open('a') as fp:
        return fp.read()
",
            "foo.py",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 2);
            },
        );
    }

    /// Dropping `With` must not suppress real branches *inside* a `with`
    /// body: an `if` in the body still counts. Guards against an
    /// over-broad fix. Companion to #418.
    ///
    /// Expected: unit(1) + fn(1) + if(1) = 3; the `with` adds nothing.
    #[cfg(feature = "python")]
    #[test]
    fn python_with_body_branch_still_counts_418() {
        check_metrics::<PythonParser>(
            "def f(x):
    with open('a') as fp:
        if x:
            return fp.read()
        return None
",
            "foo.py",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_simple_function() {
        check_metrics::<PythonParser>(
            "def f(a, b): # +2 (+1 unit space)
                if a and b:  # +2 (+1 and)
                   return 1
                if c and d: # +2 (+1 and)
                   return 1",
            "foo.py",
            |metric| {
                // nspace = 2 (func and unit)
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 6,
                    "value": 1,
                    "average": 6.0,
                    "min": 1,
                    "max": 5
                  }
                }
                "#
                );
            },
        );
    }

    /// Python `match`/`case` (PEP 634, 3.10+): each non-bare-wildcard
    /// arm contributes one standard decision; the containing
    /// `match_statement` contributes one modified decision. A bare
    /// `case _:` (no guard) is skipped, mirroring Rust's `MatchArm`
    /// bare-wildcard filter. Regression test for #212.
    #[cfg(feature = "python")]
    #[test]
    fn python_match_two_arm_wildcard() {
        check_metrics::<PythonParser>(
            "def f(x):
    match x:
        case 1:
            return 'one'
        case _:
            return 'other'
",
            "foo.py",
            |metric| {
                // standard: 1 (unit) + 1 (fn) + 1 (case 1; case _ skipped) = 3
                // modified: 1 (unit) + 1 (fn) + 1 (match_statement) = 3
                // function space alone holds 1 decision -> max = 2
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 3,
                  "value": 1,
                  "average": 3.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// `case _ if guard:` still counts because the guard is an
    /// `if_clause` sibling on the `case_clause`, escaping the bare-
    /// wildcard filter. The guard's own `if` keyword token is also
    /// counted via the existing `If` arm (every `if` keyword in
    /// Python contributes a decision) — long-standing behaviour
    /// shared with regular `if` statements. Companion to the
    /// `python_match_case_guarded_wildcard_counts` test in `abc.rs`.
    #[cfg(feature = "python")]
    #[test]
    fn python_match_guarded_wildcard_counts() {
        check_metrics::<PythonParser>(
            "def f(x):
    match x:
        case 1:
            return 'one'
        case _ if x > 0:
            return 'positive'
        case _:
            return 'other'
",
            "foo.py",
            |metric| {
                // standard: 1 (unit) + 1 (fn) + 1 (case 1)
                //         + 1 (guarded `case _ if ...` — bare-_ filter
                //              escaped by the guard)
                //         + 1 (`if` keyword inside the guard)
                //         = 5; bare `case _:` is filtered.
                // modified: 1 (unit) + 1 (fn) + 1 (match_statement)
                //         + 1 (`if` keyword in the guard) = 4.
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_1_level_nesting() {
        check_metrics::<PythonParser>(
            "def f(a, b): # +2 (+1 unit space)
                if a:  # +1
                    for i in range(b):  # +1
                        return 1",
            "foo.py",
            |metric| {
                // nspace = 2 (func and unit)
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_1_level_nesting() {
        check_metrics::<RustParser>(
            "fn f() { // +2 (+1 unit space)
                 if true { // +1
                     match true {
                         true => println!(\"test\"), // +1
                         false => println!(\"test\"), // +1
                     }
                 }
             }",
            "foo.rs",
            |metric| {
                // nspace = 2 (func and unit)
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: a match with N arms counts as 1 decision, not N.
    /// Bare `_ =>` wildcard arm does not count toward standard CCN (same
    /// as C-family `default:`).
    #[cfg(feature = "rust")]
    #[test]
    fn rust_match_modified() {
        check_metrics::<RustParser>(
            "fn f(x: u8) -> &'static str { // standard: +1 (unit) +1 (fn) +2 (arms 1,2) = 4; modified: +1 (unit) +1 (fn) +1 (MatchExpr) = 3
                 match x {
                     1 => \"one\",
                     2 => \"two\",
                     _ => \"other\",
                 }
             }",
            "foo.rs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    // The `?` operator (TryExpression) is the configurable arm (#409).
    // Fixture has exactly N=3 `?` operators in a single function. With
    // counting on (the default) each adds +1 to both standard and
    // modified; with counting off they add nothing. The two runs must
    // therefore differ by exactly N on both sub-metrics.
    #[cfg(feature = "rust")]
    const RUST_TRY_FIXTURE: &str = "fn f(s: &str) -> Result<i64, std::num::ParseIntError> {
             let a: i64 = s.parse()?;
             let b: i64 = s.parse()?;
             let c: i64 = s.parse()?;
             Ok(a + b + c)
         }";
    #[cfg(feature = "rust")]
    const RUST_TRY_COUNT: u64 = 3;

    #[cfg(feature = "rust")]
    fn rust_cyclomatic_with_try(count_try: bool) -> super::Stats {
        let func_space = crate::analyze(
            crate::Source::new(crate::LANG::Rust, RUST_TRY_FIXTURE.as_bytes())
                .with_name(Some("try.rs".to_owned())),
            crate::MetricsOptions::default().with_count_cyclomatic_try(count_try),
        )
        .expect("analyze must succeed on a well-formed Rust fixture");
        func_space.metrics.cyclomatic.clone()
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_try_toggle_differs_by_exactly_n() {
        let with = rust_cyclomatic_with_try(true);
        let without = rust_cyclomatic_with_try(false);

        // Headline acceptance (#409): the toggle's whole effect is the N
        // `?` operators, on both standard and modified cyclomatic.
        assert_eq!(
            with.cyclomatic_sum() - without.cyclomatic_sum(),
            RUST_TRY_COUNT,
            "standard cyclomatic must drop by exactly N when `?` is not counted"
        );
        assert_eq!(
            with.cyclomatic_modified_sum() - without.cyclomatic_modified_sum(),
            RUST_TRY_COUNT,
            "modified cyclomatic must drop by exactly N when `?` is not counted"
        );
        // Guard against a no-op toggle: the two runs must actually differ.
        assert_ne!(with.cyclomatic_sum(), without.cyclomatic_sum());
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_try_default_counts() {
        // The default (no options) must keep counting `?`, preserving
        // every published metric value (#409). Equivalent to the
        // `count_try == true` run above.
        let default_path = {
            let func_space = crate::analyze(
                crate::Source::new(crate::LANG::Rust, RUST_TRY_FIXTURE.as_bytes())
                    .with_name(Some("try.rs".to_owned())),
                crate::MetricsOptions::default(),
            )
            .expect("analyze must succeed on a well-formed Rust fixture");
            func_space.metrics.cyclomatic.clone()
        };
        let explicit_on = rust_cyclomatic_with_try(true);
        assert_eq!(default_path.cyclomatic_sum(), explicit_on.cyclomatic_sum());
        assert_eq!(
            default_path.cyclomatic_modified_sum(),
            explicit_on.cyclomatic_modified_sum()
        );
        // unit(1) + fn(entry 1 + 3*`?` = 4) = 5 standard; modified same
        // shape (no match container here): 1 + 4 = 5.
        assert_eq!(default_path.cyclomatic_sum(), 5);
        assert_eq!(default_path.cyclomatic_modified_sum(), 5);
    }

    /// `Cyclomatic::compute` for Rust is the trait's plain entry point,
    /// and the metric walk never reaches it: `compute_per_node` calls
    /// `compute_with_options` directly so it can pass the
    /// `count_cyclomatic_try` option through. The plain form is still
    /// the documented default for any caller that goes through the
    /// trait, and #409 fixes that default as "`?` counts" — so it needs
    /// a test of its own rather than inheriting the option tests above,
    /// which exercise the other entry point.
    ///
    /// Asserting only that the two forms agree would be satisfied by a
    /// `compute` that delegated with `false` *and* a
    /// `compute_with_options` that ignored the flag, so the count is
    /// pinned against the opted-out run as well.
    #[cfg(feature = "rust")]
    #[test]
    fn rust_compute_delegates_with_try_counting_on() {
        use crate::traits::ParserTrait;

        let parser = crate::RustParser::new(
            RUST_TRY_FIXTURE.as_bytes().to_vec(),
            std::path::Path::new("try.rs"),
            None,
        );
        let code = parser.code();

        let mut plain = Stats::default();
        let mut opted_in = Stats::default();
        let mut opted_out = Stats::default();
        for node in parser.root().preorder() {
            RustCode::compute(&node, code, Ancestors::unknown(), &mut plain);
            RustCode::compute_with_options(&node, code, Ancestors::unknown(), &mut opted_in, true);
            RustCode::compute_with_options(
                &node,
                code,
                Ancestors::unknown(),
                &mut opted_out,
                false,
            );
        }

        assert_eq!(
            (plain.cyclomatic(), plain.cyclomatic_modified()),
            (opted_in.cyclomatic(), opted_in.cyclomatic_modified()),
            "`compute` must be `compute_with_options(.., true)`"
        );
        assert_eq!(
            plain.cyclomatic() - opted_out.cyclomatic(),
            RUST_TRY_COUNT,
            "the fixture's {RUST_TRY_COUNT} `?` operators are what the default counts"
        );
    }

    #[cfg(feature = "c")]
    #[test]
    fn c_switch() {
        check_metrics::<CParser>(
            "void f() { // +2 (+1 unit space)
                 switch (1) {
                     case 1: // +1
                         printf(\"one\");
                         break;
                     case 2: // +1
                         printf(\"two\");
                         break;
                     case 3: // +1
                         printf(\"three\");
                         break;
                     default:
                         printf(\"all\");
                         break;
                 }
             }",
            "foo.c",
            |metric| {
                // nspace = 2 (func and unit)
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: 3 case arms in one switch collapse to 1 decision.
    #[cfg(feature = "c")]
    #[test]
    fn c_switch_modified() {
        check_metrics::<CParser>(
            "void f() {
                 switch (x) {
                     case 1: break;
                     case 2: break;
                     case 3: break;
                     default: break;
                 }
             }",
            "foo.c",
            |metric| {
                // standard: unit(1) + fn(1) + 3 cases = 5
                // modified: unit(1) + fn(1) + switch(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "c")]
    #[test]
    fn c_real_function() {
        check_metrics::<CParser>(
            "int sumOfPrimes(int max) { // +2 (+1 unit space)
                 int total = 0;
                 OUT: for (int i = 1; i <= max; ++i) { // +1
                   for (int j = 2; j < i; ++j) { // +1
                       if (i % j == 0) { // +1
                          continue OUT;
                       }
                   }
                   total += i;
                 }
                 return total;
            }",
            "foo.c",
            |metric| {
                // nspace = 2 (func and unit)
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "c")]
    #[test]
    fn c_unit_before() {
        check_metrics::<CParser>(
            "
            int a=42;
            if(a==42) //+2(+1 unit space)
            {

            }
            if(a==34) //+1
            {

            }
            int sumOfPrimes(int max) { // +1
                 int total = 0;
                 OUT: for (int i = 1; i <= max; ++i) { // +1
                   for (int j = 2; j < i; ++j) { // +1
                       if (i % j == 0) { // +1
                          continue OUT;
                       }
                   }
                   total += i;
                 }
                 return total;
            }",
            "foo.c",
            |metric| {
                // nspace = 2 (func and unit)
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 7,
                  "value": 3,
                  "average": 7.0,
                  "min": 3,
                  "max": 4,
                  "modified": {
                    "sum": 7,
                    "value": 3,
                    "average": 7.0,
                    "min": 3,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    /// Test to handle the case of min and max when merge happen before the final value of one module are set.
    /// In this case the min value should be 3 because the unit space has 2 branches and a complexity of 3
    /// while the function sumOfPrimes has a complexity of 4.
    #[cfg(feature = "c")]
    #[test]
    fn c_unit_after() {
        check_metrics::<CParser>(
            "
            int sumOfPrimes(int max) { // +1
                 int total = 0;
                 OUT: for (int i = 1; i <= max; ++i) { // +1
                   for (int j = 2; j < i; ++j) { // +1
                       if (i % j == 0) { // +1
                          continue OUT;
                       }
                   }
                   total += i;
                 }
                 return total;
            }

            int a=42;
            if(a==42) //+2(+1 unit space)
            {

            }
            if(a==34) //+1
            {

            }",
            "foo.c",
            |metric| {
                // nspace = 2 (func and unit)
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 7,
                  "value": 3,
                  "average": 7.0,
                  "min": 3,
                  "max": 4,
                  "modified": {
                    "sum": 7,
                    "value": 3,
                    "average": 7.0,
                    "min": 3,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_simple_class() {
        check_metrics::<JavaParser>(
            "
            public class Example { // +2 (+1 unit space)
                int a = 10;
                boolean b = (a > 5) ? true : false; // +1
                boolean c = b && true; // +1

                public void m1() { // +1
                    if (a % 2 == 0) { // +1
                        b = b || c; // +1
                    }
                }
                public void m2() { // +1
                    while (a > 3) { // +1
                        m1();
                        a--;
                    }
                }
            }",
            "foo.java",
            |metric| {
                // nspace = 4 (unit, class and 2 methods)
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 9,
                  "value": 1,
                  "average": 4.5,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 9,
                    "value": 1,
                    "average": 4.5,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_real_class() {
        check_metrics::<JavaParser>(
            "
            public class Matrix { // +2 (+1 unit space)
                private int[][] m = new int[5][5];

                public void init() { // +1
                    for (int i = 0; i < m.length; i++) { // +1
                        for (int j = 0; j < m[i].length; j++) { // +1
                            m[i][j] = i * j;
                        }
                    }
                }
                public int compute(int i, int j) { // +1
                    try {
                        return m[i][j] / m[j][i];
                    } catch (ArithmeticException e) { // +1
                        return -1;
                    } catch (ArrayIndexOutOfBoundsException e) { // +1
                        return -2;
                    }
                }
                public void print(int result) { // +1
                    switch (result) {
                        case -1: // +1
                            System.out.println(\"Division by zero\");
                            break;
                        case -2: // +1
                            System.out.println(\"Wrong index number\");
                            break;
                        default:
                            System.out.println(\"The result is \" + result);
                    }
                }
            }",
            "foo.java",
            |metric| {
                // nspace = 5 (unit, class and 3 methods)
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 11,
                  "value": 1,
                  "average": 3.6666666666666665,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 10,
                    "value": 1,
                    "average": 3.3333333333333335,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: Java switch with 2 cases counts as 1 (not 2).
    #[cfg(feature = "java")]
    #[test]
    fn java_switch_modified() {
        check_metrics::<JavaParser>(
            "public class A {
                public void print(int result) {
                    switch (result) {
                        case -1:
                            System.out.println(\"minus one\");
                            break;
                        case -2:
                            System.out.println(\"minus two\");
                            break;
                        default:
                            System.out.println(\"other\");
                    }
                }
            }",
            "foo.java",
            |metric| {
                // standard: unit(1) + class(1) + fn(1) + 2 cases = 5
                // modified: unit(1) + class(1) + fn(1) + switch(1) = 4
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_simple_class() {
        check_metrics::<CsharpParser>(
            "public class Example {
                int a = 10;
                bool b = (a > 5) ? true : false;
                bool c = b && true;

                public void M1() {
                    if (a % 2 == 0) {
                        b = b || c;
                    }
                }
                public void M2() {
                    while (a > 3) {
                        M1();
                        a--;
                    }
                }
            }",
            "foo.cs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 9,
                  "value": 1,
                  "average": 4.5,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 9,
                    "value": 1,
                    "average": 4.5,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_real_class() {
        check_metrics::<CsharpParser>(
            "public class Matrix {
                private int[,] m = new int[5, 5];

                public void Init() {
                    for (int i = 0; i < 5; i++) {
                        for (int j = 0; j < 5; j++) {
                            m[i, j] = i * j;
                        }
                    }
                }
                public int Compute(int i, int j) {
                    try {
                        return m[i, j] / m[j, i];
                    } catch (System.DivideByZeroException) {
                        return -1;
                    } catch (System.IndexOutOfRangeException) {
                        return -2;
                    }
                }
                public void Print(int result) {
                    switch (result) {
                        case -1:
                            System.Console.WriteLine(\"Division by zero\");
                            break;
                        case -2:
                            System.Console.WriteLine(\"Wrong index number\");
                            break;
                        default:
                            System.Console.WriteLine(\"The result is \" + result);
                            break;
                    }
                }
            }",
            "foo.cs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 11,
                  "value": 1,
                  "average": 3.6666666666666665,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 10,
                    "value": 1,
                    "average": 3.3333333333333335,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_anonymous_method() {
        check_metrics::<CsharpParser>(
            "public class A {
                public void M() {
                    System.Action f = delegate(int x) {
                        if (x > 0) {
                            System.Console.WriteLine(x);
                        }
                    };
                }
            }",
            "foo.cs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 2.5,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 2.5,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_expression_arms() {
        // Each non-default arm of a switch_expression contributes +1.
        // The discard arm `_ =>` is excluded (issue #282), mirroring
        // Rust's `_ =>` and Java/C#'s `default:` treatment.
        check_metrics::<CsharpParser>(
            "public class A {
                public string Name(int n) =>
                    n switch {
                        1 => \"one\",
                        2 => \"two\",
                        3 => \"three\",
                        _ => \"other\"
                    };
            }",
            "foo.cs",
            |metric| {
                // expected: unit(1) + class(1) + fn(base 1 + 3 explicit arms;
                //           `_ =>` skipped) = sum 6, max 4. modified =
                //           unit(1) + class(1) + fn(base 1 + switch expr 1) = 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 6);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Regression #282: the bare discard arm `_ =>` in a C# switch
    /// expression must NOT contribute to standard CCN, mirroring the
    /// C-family `default:` rule.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_expression_discard_arm_not_counted() {
        check_metrics::<CsharpParser>(
            "public class A {
                public string Name(int n) =>
                    n switch {
                        1 => \"one\",
                        _ => \"other\"
                    };
            }",
            "foo.cs",
            |metric| {
                // expected: unit(1) + class(1) + fn(base 1 + 1 explicit;
                //           `_ =>` skipped) = 4, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
            },
        );
    }

    /// Regression #282: `var _` is also a discard pattern and must be
    /// excluded from standard CCN.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_expression_var_underscore_not_counted() {
        check_metrics::<CsharpParser>(
            "public class A {
                public string Name(int n) =>
                    n switch {
                        1 => \"one\",
                        var _ => \"other\"
                    };
            }",
            "foo.cs",
            |metric| {
                // expected: unit(1) + class(1) + fn(base 1 + 1 explicit;
                //           `var _ =>` skipped) = 4, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
            },
        );
    }

    /// Regression #282: a guarded discard arm `_ when g => …` is NOT a
    /// bare wildcard — the `when` guard adds a non-trivial decision —
    /// so the arm still contributes one standard decision, mirroring
    /// Rust's `_ if g` rule.
    ///
    /// Since #1422 the guard contributes a second decision of its own
    /// (`WhenClause`), so the arm is worth 2: the pattern can match and
    /// the guard still fail, which is a distinct way to fall through to
    /// the next arm. The two counts have different owners —
    /// `csharp_switch_expression_arm_is_bare_discard` keeps the arm out
    /// of the `default:` exclusion, the `WhenClause` arm scores the
    /// guard — so this test would still fail if #282's exclusion were
    /// reintroduced, at sum 5 / max 3 against the asserted 6 / 4.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_expression_guarded_discard_still_counts() {
        check_metrics::<CsharpParser>(
            "public class A {
                public string Name(int n) =>
                    n switch {
                        1 => \"one\",
                        _ when n > 10 => \"big\",
                        _ => \"other\"
                    };
            }",
            "foo.cs",
            |metric| {
                // expected: unit(1) + class(1) + fn(base 1 + 1 explicit +
                //           1 guarded discard + 1 `when` guard (#1422);
                //           bare `_ =>` skipped) = 6, max 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 6);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
            },
        );
    }

    /// Regression #303 / #282: a typed-discard arm `int _ =>` is NOT
    /// a bare discard — the type test (`predefined_type`) is a
    /// non-trivial decision — so the arm still contributes one
    /// standard decision. Locks in the
    /// `DeclarationPattern → _ => return NotDiscard` catch-all in
    /// `csharp_switch_expression_arm_is_bare_discard`.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_expression_typed_discard_still_counts() {
        check_metrics::<CsharpParser>(
            "public class A {
                public string Name(object n) =>
                    n switch {
                        1 => \"one\",
                        int _ => \"int\",
                        _ => \"other\"
                    };
            }",
            "foo.cs",
            |metric| {
                // expected: unit(1) + class(1) + fn(base 1 + 1 explicit `1` +
                //           1 typed-discard `int _`; bare `_ =>` skipped) = 5,
                //           max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    /// Regression #303 / #282: a guarded `var _ when g =>` is NOT a
    /// bare discard — the `when` guard adds a non-trivial decision —
    /// so the arm still contributes one standard decision. Exercises
    /// the `DeclarationPattern` arm of `classify_pattern` combined
    /// with the post-pattern `WhenClause` sweep.
    ///
    /// As with `csharp_switch_expression_guarded_discard_still_counts`,
    /// the guard has scored a decision of its own since #1422, so the
    /// arm is worth 2. Reintroducing #303's exclusion would read sum 5 /
    /// max 3 against the asserted 6 / 4.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_expression_guarded_var_underscore_still_counts() {
        check_metrics::<CsharpParser>(
            "public class A {
                public string Name(int n) =>
                    n switch {
                        1 => \"one\",
                        var _ when n > 10 => \"big\",
                        _ => \"other\"
                    };
            }",
            "foo.cs",
            |metric| {
                // expected: unit(1) + class(1) + fn(base 1 + 1 explicit `1` +
                //           1 guarded `var _` + 1 `when` guard (#1422);
                //           bare `_ =>` skipped) = 6, max 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 6);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
            },
        );
    }

    /// Regression #1450 / #1451: `goto case 2;` spells the same `case`
    /// keyword token (id 114) as a real arm, from a second production
    /// (`goto_statement`), and scored a decision it does not earn — an
    /// unconditional jump to an arm is not a branch point.
    ///
    /// Per member, never through `cyclomatic_sum()`: the sum cannot tell
    /// the shipped `{3, 3, 3}` from the pre-fix `{3, 4, 3}` without also
    /// pinning the member count, and the whole claim is that `jmp` reads
    /// the same as `ctl`. The three methods are identical but for one
    /// statement each, so `jmp`'s `goto case` is the only thing that can
    /// separate them (`.claude/rules/grammar-dispatch.md` §11 — an arm
    /// and a `goto case` are independent paths into the same counter, and
    /// a fixture carrying only arms cannot show the gate works).
    ///
    /// `dfl` is the control that was already correct, by accident rather
    /// than design: `goto default;` spells `Default`, which neither
    /// metric counts because it is the switch's unconditional
    /// fallthrough (#456, #469).
    ///
    /// The `Case` anchor is the second axis. Every member scores 3 from
    /// its two arms alone, so deleting `goto case 2;` from the fixture
    /// leaves every assertion below satisfied and the construct under
    /// test gone; the anchor's count of 7 — six arms plus the one jump —
    /// fails by name instead.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_goto_case_is_not_a_switch_arm() {
        let src = "class A {
                int ctl(int x) { switch (x) { case 1: return 1; case 2: return 2; default: return 0; } }
                int jmp(int x) { switch (x) { case 1: goto case 2; case 2: return 2; default: return 0; } }
                int dfl(int x) { switch (x) { case 1: goto default; case 2: return 2; default: return 0; } }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::Case as u16, 7, "`case` tokens (6 arms + 1 jump)"),
                (Csharp::SwitchSection as u16, 9, "switch arms"),
                (Csharp::GotoStatement as u16, 2, "`goto` statements"),
                (
                    Csharp::Default as u16,
                    4,
                    "`default` tokens (3 arms + 1 jump)",
                ),
            ],
        );
        check_func_space_only::<CsharpParser, _>(src, "foo.cs", &[Metric::Cyclomatic], |space| {
            let class = child_space(&space, "A");
            assert_eq!(class.spaces.len(), 3, "fixture moved, not the metric");
            for name in ["ctl", "jmp", "dfl"] {
                let member = child_space(class, name);
                // base 1 + one decision per `case` arm; the `default:`
                // arm and both `goto` forms contribute nothing.
                assert_eq!(
                    member.metrics.cyclomatic.cyclomatic(),
                    3,
                    "{name}: two arms over a base of 1"
                );
            }
        });
    }

    /// Modified CCN: C# switch statement with 2 cases counts as 1.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_modified() {
        check_metrics::<CsharpParser>(
            "public class A {
                public string Describe(int n) {
                    switch (n) {
                        case 1:
                            return \"one\";
                        case 2:
                            return \"two\";
                        default:
                            return \"other\";
                    }
                }
            }",
            "foo.cs",
            |metric| {
                // standard: unit(1) + class(1) + fn(1) + 2 cases = 5
                // modified: unit(1) + class(1) + fn(1) + switch(1) = 4
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_null_coalescing_and_conditional_access() {
        // Each `??` and `?.` is +1 cyclomatic.
        check_metrics::<CsharpParser>(
            "public class A {
                public int? Get(string s, A b) {
                    return s?.Length ?? b?.Get(null, null) ?? 0;
                }
            }",
            "foo.cs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 7,
                  "value": 1,
                  "average": 7.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 7,
                    "value": 1,
                    "average": 7.0,
                    "min": 1,
                    "max": 5
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_simple_function() {
        check_metrics::<JavascriptParser>(
            "function f(a, b) { // +2 (+1 unit space)
                 if (a) { // +1
                     return a;
                 } else if (b) { // +1
                     return b;
                 }
                 return 0;
             }",
            "foo.js",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_switch() {
        check_metrics::<JavascriptParser>(
            "function f() { // +2 (+1 unit space)
                 switch (x) {
                     case 1: // +1
                         console.log(\"one\");
                         break;
                     case 2: // +1
                         console.log(\"two\");
                         break;
                     case 3: // +1
                         console.log(\"three\");
                         break;
                     default:
                         console.log(\"other\");
                         break;
                 }
             }",
            "foo.js",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: JS switch with 3 cases collapses to 1.
    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_switch_modified() {
        check_metrics::<JavascriptParser>(
            "function f(x) {
                 switch (x) {
                     case 1: return 'one';
                     case 2: return 'two';
                     case 3: return 'three';
                 }
             }",
            "foo.js",
            |metric| {
                // standard: unit(1) + fn(1) + 3 cases = 5
                // modified: unit(1) + fn(1) + switch(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_simple_function() {
        check_metrics::<GoParser>(
            "package main
            func f() {}",
            "foo.go",
            |metric| {
                // nspace = 2 (file unit + func), each base 1.
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 2,
                  "value": 1,
                  "average": 2.0,
                  "min": 1,
                  "max": 1,
                  "modified": {
                    "sum": 2,
                    "value": 1,
                    "average": 2.0,
                    "min": 1,
                    "max": 1
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_if_else() {
        check_metrics::<GoParser>(
            "package main
            func f(x bool) { // +2 (+1 unit)
                if x { // +1
                } else {
                }
            }",
            "foo.go",
            |metric| {
                // `else` clause attaches to the same if_statement node and is
                // not counted again.
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 3,
                  "value": 1,
                  "average": 3.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_else_if_chain() {
        check_metrics::<GoParser>(
            "package main
            func f(x int) { // +2 (+1 unit)
                if x > 0 { // +1
                } else if x < 0 { // +1 (nested if_statement)
                } else if x == 0 { // +1 (nested if_statement)
                } else {
                }
            }",
            "foo.go",
            |metric| {
                // tree-sitter-go represents `else if` as a nested
                // if_statement under the parent's `else` clause; each nested
                // if contributes +1.
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_for_loop() {
        check_metrics::<GoParser>(
            "package main
            func f() { // +2 (+1 unit)
                for i := 0; i < 10; i++ { // +1
                }
            }",
            "foo.go",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 3,
                  "value": 1,
                  "average": 3.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_for_range() {
        check_metrics::<GoParser>(
            "package main
            func f(xs []int) { // +2 (+1 unit)
                for _, v := range xs { // +1
                    _ = v
                }
            }",
            "foo.go",
            |metric| {
                // range_clause is a child of for_statement; only the
                // for_statement contributes.
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 3,
                  "value": 1,
                  "average": 3.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_switch() {
        check_metrics::<GoParser>(
            "package main
            func f(x int) { // +2 (+1 unit)
                switch x {
                case 1: // +1
                case 2: // +1
                default: // not counted
                }
            }",
            "foo.go",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: Go switch with 3 cases collapses to 1.
    #[cfg(feature = "go")]
    #[test]
    fn go_switch_modified() {
        check_metrics::<GoParser>(
            "package main
            func f(x int) {
                switch x {
                case 1:
                    println(\"one\")
                case 2:
                    println(\"two\")
                case 3:
                    println(\"three\")
                }
            }",
            "foo.go",
            |metric| {
                // standard: unit(1) + fn(1) + 3 cases = 5
                // modified: unit(1) + fn(1) + switch(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_type_switch() {
        check_metrics::<GoParser>(
            "package main
            func f(x interface{}) { // +2 (+1 unit)
                switch x.(type) {
                case int: // +1
                case string: // +1
                }
            }",
            "foo.go",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_select() {
        check_metrics::<GoParser>(
            "package main
            func f(c1, c2 chan int) { // +2 (+1 unit)
                select {
                case <-c1: // +1
                case <-c2: // +1
                default: // not counted
                }
            }",
            "foo.go",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_logical_operators() {
        check_metrics::<GoParser>(
            "package main
            func f(a, b, c bool) { // +2 (+1 unit)
                if a && b || c { // +1 if, +1 &&, +1 ||
                }
            }",
            "foo.go",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_defer_and_go_do_not_count() {
        check_metrics::<GoParser>(
            "package main
            func f() { // +2 (+1 unit)
                defer cleanup()
                go work()
            }",
            "foo.go",
            |metric| {
                // defer_statement and go_statement are not branches.
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 2,
                  "value": 1,
                  "average": 2.0,
                  "min": 1,
                  "max": 1,
                  "modified": {
                    "sum": 2,
                    "value": 1,
                    "average": 2.0,
                    "min": 1,
                    "max": 1
                  }
                }
                "#
                );
            },
        );
    }

    // As reported here:
    // https://github.com/sebastianbergmann/php-code-coverage/issues/607
    // An anonymous class declaration is not considered when computing the Cyclomatic Complexity metric for Java
    // Only the complexity of the anonymous class content is considered for the computation
    #[cfg(feature = "java")]
    #[test]
    fn java_anonymous_class() {
        check_metrics::<JavaParser>(
            "
            abstract class A { // +2 (+1 unit space)
                public abstract boolean m1(int n); // +1
                public abstract boolean m2(int n); // +1
            }
            public class B { // +1
                public void test() { // +1
                    A a = new A() {
                        public boolean m1(int n) { // +1
                            if (n % 2 == 0) { // +1
                                return true;
                            }
                            return false;
                        }
                        public boolean m2(int n) { // +1
                            if (n % 5 == 0) { // +1
                                return true;
                            }
                            return false;
                        }
                    };
                }
            }",
            "foo.java",
            |metric| {
                // nspace = 9: unit, the two named classes (A, B), the
                // anonymous class (`new A() { ... }`, now its own Class
                // space — #463), and 5 methods. The anonymous class adds a
                // base +1 to the cyclomatic sum exactly like a named class,
                // so the file-level sum is 11 (was 10 before the anonymous
                // body opened its own space). Each method's complexity is
                // counted once — the +1 is the new class space, not a
                // re-count of any method.
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 11,
                  "value": 1,
                  "average": 2.2,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 11,
                    "value": 1,
                    "average": 2.2,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Java `do { … } while (…)` contributes exactly +1 to both
    /// standard and modified CCN. The +1 comes from the `while`
    /// keyword token (`Java::While`) inside the do-statement, which
    /// the dedicated `JavaCode` impl already counts. Adding
    /// `Java::DoStatement` would double-count — see issue #284. This
    /// test pins the correct keyword-driven count.
    #[cfg(feature = "java")]
    #[test]
    fn java_do_statement_counts_in_cyclomatic() {
        check_metrics::<JavaParser>(
            "class Parity {
                 static void f() {
                     int i = 0;
                     do {           // +1 (via inner `while` keyword)
                         ++i;
                     } while (i < 10);
                 }
             }",
            "foo.java",
            |metric| {
                // standard: unit(1) + class(1) + method(1) + do(1) = 4
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 4);
                assert_eq!(s.cyclomatic_max(), 2);
                assert_eq!(s.cyclomatic_modified_sum(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Java enhanced-for `for (T x : xs)` contributes exactly +1 to
    /// both standard and modified CCN — the `for` keyword token
    /// (`Java::For`) fires inside the `EnhancedForStatement` node
    /// just like inside a classic `ForStatement`. Pinning this
    /// prevents reintroducing the double-count from issue #284's
    /// incorrect fix proposal.
    #[cfg(feature = "java")]
    #[test]
    fn java_enhanced_for_statement_counts_in_cyclomatic() {
        check_metrics::<JavaParser>(
            "class Parity {
                 static void f(int[] xs) {
                     for (int x : xs) {  // +1 (via `for` keyword)
                         g(x);
                     }
                 }
             }",
            "foo.java",
            |metric| {
                // standard: unit(1) + class(1) + method(1) + enhanced-for(1) = 4
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 4);
                assert_eq!(s.cyclomatic_max(), 2);
                assert_eq!(s.cyclomatic_modified_sum(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_simple_class() {
        check_metrics::<GroovyParser>(
            "
            class Example {
                int a = 10
                boolean b = (a > 5) ? true : false
                boolean c = b && true

                void m1() {
                    if (a % 2 == 0) {
                        b = b || c
                    }
                }
                void m2() {
                    while (a > 3) {
                        m1()
                        a--
                    }
                }
            }",
            "foo.groovy",
            |metric| {
                // Same shape as `java_simple_class`. nspace = 4
                // (unit, class, 2 methods); branches mirror Java's.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 9);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_nested_control_flow() {
        check_metrics::<GroovyParser>(
            "void f(int x) {
                if (x > 0) {
                    while (x < 100) {
                        x = x + 1
                    }
                }
            }",
            "foo.groovy",
            |metric| {
                // unit(1) + fn(1) + if(1) + while(1) = 4
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_switch_with_cases() {
        check_metrics::<GroovyParser>(
            "void print(int result) {
                switch (result) {
                    case -1:
                        println 'minus one'
                        break
                    case -2:
                        println 'minus two'
                        break
                    default:
                        println 'other'
                }
            }",
            "foo.groovy",
            |metric| {
                // standard: unit(1) + fn(1) + 2 cases = 4
                // modified: unit(1) + fn(1) + switch(1) = 3
                // (default does NOT add a branch — same as Java/lesson #106)
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_try_catch() {
        check_metrics::<GroovyParser>(
            "void f() {
                try {
                    risky()
                } catch (Exception e) {
                    handle(e)
                }
            }",
            "foo.groovy",
            |metric| {
                // unit(1) + fn(1) + catch(1) = 3
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_closure_body_short_circuit() {
        // Top-level `def pred = { … }` collapses the closure into the
        // unit scope (no class wrapper), so the `&&` inside still
        // contributes one branch but no extra function space is
        // created. Mirrors Java's top-level-lambda behavior.
        check_metrics::<GroovyParser>(
            "def pred = { x -> x > 0 && x < 100 }",
            "foo.groovy",
            |metric| {
                // unit(1) + && (1) = 2
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 2);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_assert_adds_branch() {
        // Groovy `assert` is a runtime check that branches on its
        // condition; mirror Sonar's standard-CCN treatment.
        check_metrics::<GroovyParser>(
            "void check(int x) {
                assert x > 0
            }",
            "foo.groovy",
            |metric| {
                // unit(1) + fn(1) + assert(1) = 3
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
            },
        );
    }

    /// Groovy `do { … } while (…)` contributes exactly +1 to both
    /// standard and modified CCN — the `while` keyword token
    /// (`Groovy::While`) inside the do-statement is already counted
    /// by the dedicated `GroovyCode` impl. Adding `Groovy::DoStatement`
    /// would double-count (issue #284). This test pins the correct
    /// keyword-driven count.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_do_statement_counts_in_cyclomatic() {
        check_metrics::<GroovyParser>(
            "def f() {
                 int i = 0
                 do {           // +1 (via inner `while` keyword)
                     ++i
                 } while (i < 10)
             }",
            "foo.groovy",
            |metric| {
                // standard: unit(1) + fn(1) + do(1) = 3
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 3);
                assert_eq!(s.cyclomatic_max(), 2);
                assert_eq!(s.cyclomatic_modified_sum(), 3);
            },
        );
    }

    /// Groovy enhanced-for `for (T x : xs)` contributes exactly +1 to
    /// both standard and modified CCN — the `for` keyword token
    /// (`Groovy::For`) fires inside `EnhancedForStatement` just like
    /// inside a classic `ForStatement`. Pinning this prevents
    /// reintroducing the double-count from issue #284's incorrect fix
    /// proposal.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_enhanced_for_statement_counts_in_cyclomatic() {
        check_metrics::<GroovyParser>(
            "def f(int[] xs) {
                 for (int x : xs) {  // +1 (via `for` keyword)
                     println(x)
                 }
             }",
            "foo.groovy",
            |metric| {
                // standard: unit(1) + fn(1) + enhanced-for(1) = 3
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 3);
                assert_eq!(s.cyclomatic_max(), 2);
                assert_eq!(s.cyclomatic_modified_sum(), 3);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_safe_navigation_cyclomatic() {
        // Issue #452: Groovy's safe-navigation `?.` (QMARKDOT) is a
        // short-circuit decision point per link, mirroring the
        // Kotlin/PHP/JS/C# treatment of `?.` (#281). The chain
        // `a?.b?.c` adds +2 to both standard and modified CCN.
        check_metrics::<GroovyParser>("def read(a){ return a?.b?.c }", "foo.groovy", |metric| {
            // unit(1) + fn(base 1 + ?. 1 + ?. 1) = sum 4, max 3.
            let s = &metric.cyclomatic;
            assert_eq!(s.cyclomatic_sum(), 4);
            assert_eq!(s.cyclomatic_max(), 3);
            assert_eq!(s.cyclomatic_modified_sum(), 4);
            assert_eq!(s.cyclomatic_modified_max(), 3);
        });
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_safe_subscript_cyclomatic() {
        // Issue #1471: `?[` short-circuits on a null receiver exactly as
        // `?.` does, and had no arm — so `l?[0]` read level with the
        // unconditional `l[0]`. Chained, because the arm matches the
        // token and not the `safe_subscript_expression` wrapper: a
        // chain nests one wrapper inside another, so the wrapper
        // spelling would score this 1 and only the token spelling
        // scores it 2 (grammar-dispatch §5).
        check_metrics::<GroovyParser>("def read(l){ return l?[0]?[1] }", "foo.groovy", |metric| {
            // unit(1) + fn(base 1 + ?[ 1 + ?[ 1) = sum 4, max 3.
            let s = &metric.cyclomatic;
            assert_eq!(s.cyclomatic_sum(), 4);
            assert_eq!(s.cyclomatic_max(), 3);
            assert_eq!(s.cyclomatic_modified_sum(), 4);
            assert_eq!(s.cyclomatic_modified_max(), 3);
        });
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_safe_chain_dot_cyclomatic() {
        // Issue #452: Groovy's `??.` (QMARKQMARKDOT, the spread-safe
        // chain-dot operator) is also a short-circuit decision point,
        // counted once per occurrence like `?.`.
        check_metrics::<GroovyParser>("def read(a){ return a??.b }", "foo.groovy", |metric| {
            // unit(1) + fn(base 1 + ??. 1) = sum 3, max 2.
            let s = &metric.cyclomatic;
            assert_eq!(s.cyclomatic_sum(), 3);
            assert_eq!(s.cyclomatic_max(), 2);
            assert_eq!(s.cyclomatic_modified_sum(), 3);
            assert_eq!(s.cyclomatic_modified_max(), 2);
        });
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_nested_control_flow() {
        check_metrics::<PerlParser>(
            "sub f { # +1 (unit) +1 (sub)
                for my $i (1..10) { # +1 for_statement_2
                    if ($i % 2) { # +1 if_statement
                        print $i;
                    }
                }
            }",
            "foo.pl",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_postfix_conditionals() {
        check_metrics::<PerlParser>(
            "sub f { # +1 (unit) +1 (sub)
                return 1 if $_[0]; # +1 if_simple_statement
                return 0 unless $_[1]; # +1 unless_simple_statement
            }",
            "foo.pl",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_unless_and_until() {
        check_metrics::<PerlParser>(
            "sub f { # +1 (unit) +1 (sub)
                unless ($x) { # +1 unless_statement
                    print 'a';
                }
                until ($n == 0) { # +1 until_statement
                    $n--;
                }
            }",
            "foo.pl",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_logical_operators_and_ternary() {
        check_metrics::<PerlParser>(
            "sub f { # +1 (unit) +1 (sub)
                my $x = $a && $b; # +1 (&&)
                my $y = $c || $d; # +1 (||)
                my $z = $e // $f; # +1 (//)
                my $t = $g ? 1 : 0; # +1 ternary
            }",
            "foo.pl",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 6,
                    "value": 1,
                    "average": 6.0,
                    "min": 1,
                    "max": 5
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_word_logical_operators() {
        check_metrics::<PerlParser>(
            "sub f { # +1 (unit) +1 (sub)
                my $x = $a and $b; # +1 (and)
                my $y = $c or $d; # +1 (or)
            }",
            "foo.pl",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_compound_short_circuit_assignment_249() {
        // Regression for issue #249: `&&=`, `||=`, `//=` are each one
        // short-circuit decision edge — semantically `$x = $x op $y`.
        // Perl exposes the operator token inside `binary_expression`,
        // so adding the three `*EQ` tokens to the cyclomatic arm picks
        // them up alongside the bare `&&` / `||` / `//`.
        check_metrics::<PerlParser>(
            "sub f { # +1 (unit) +1 (sub)
                my ($x, $y, $z) = @_;
                $x ||= 1; # +1 (||=)
                $y &&= 2; # +1 (&&=)
                $z //= 3; # +1 (//=)
                return $x;
            }",
            "foo.pl",
            |metric| {
                // unit(1) + fn(entry 1 + 3 assignments = 4) = sum 5, max 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_foreach_loop() {
        check_metrics::<PerlParser>(
            "sub f { # +1 (unit) +1 (sub)
                foreach my $i (@list) { # +1 for_statement_2
                    print $i;
                }
            }",
            "foo.pl",
            |metric| {
                insta::assert_json_snapshot!(metric.cyclomatic, @r#"
                {
                  "sum": 3,
                  "value": 1,
                  "average": 3.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_else_does_not_count_but_elsif_does() {
        check_metrics::<PerlParser>(
            "sub f { # +1 (unit) +1 (sub)
                if ($x) { # +1 if_statement
                    print 'a';
                } elsif ($y) { # +1 elsif_clause
                    print 'b';
                } else {
                    print 'c';
                }
            }",
            "foo.pl",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_simple_function() {
        check_metrics::<TsxParser>(
            "function f(a: number, b: number) { // +2 (+1 unit space)
                 if (a > 0) { // +1
                     return a;
                 } else if (b > 0) { // +1
                     return b;
                 }
                 return 0;
             }",
            "foo.tsx",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_if_else_and_switch() {
        check_metrics::<TypescriptParser>(
            "function classify(value: number): string {
                 if (value < 0) { // +1
                     return 'negative';
                 } else if (value === 0) { // +1
                     return 'zero';
                 }
                 switch (value) {
                     case 1: // +1
                         return 'one';
                     case 2: // +1
                         return 'two';
                     default:
                         return 'other';
                 }
             }",
            "foo.ts",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: TypeScript switch with 3 cases collapses to 1.
    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_switch_modified() {
        check_metrics::<TypescriptParser>(
            "function f(x: number): string {
                 switch (x) {
                     case 1: return 'one';
                     case 2: return 'two';
                     case 3: return 'three';
                     default: return 'other';
                 }
             }",
            "foo.ts",
            |metric| {
                // standard: unit(1) + fn(1) + 3 cases = 5
                // modified: unit(1) + fn(1) + switch(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_if_else_and_switch() {
        check_metrics::<MozjsParser>(
            "function f(x) { // +2 (+1 unit space)
                 if (x > 0) { // +1
                     return 1;
                 } else if (x < 0) { // +1
                     return -1;
                 }
                 switch (x) {
                     case 0: // +1
                         return 0;
                     case 42: // +1
                         return 42;
                     default:
                         return -2;
                 }
             }",
            "foo.js",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: MozJS switch with 2 cases collapses to 1.
    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_switch_modified() {
        check_metrics::<MozjsParser>(
            "function f(x) {
                 switch (x) {
                     case 1: return 1;
                     case 2: return 2;
                 }
             }",
            "foo.js",
            |metric| {
                // standard: unit(1) + fn(1) + 2 cases = 4
                // modified: unit(1) + fn(1) + switch(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_cyclomatic_mixed() {
        check_metrics::<KotlinParser>(
            "class Calc {
                fun compute(x: Int, y: Int): Int {
                    if (x > 0) {            // +1
                        for (i in 1..x) {   // +1
                            println(i)
                        }
                    }
                    when (y) {
                        1 -> println(\"one\")  // +1 (WhenEntry)
                        2 -> println(\"two\")  // +1
                        else -> println(\"?\") // skipped (else is default)
                    }
                    val ok = x > 0 && y > 0  // +1
                    try {
                        println(x / y)
                    } catch (e: Exception) { // +1
                        println(\"err\")
                    }
                    return x + y
                }
            }",
            "foo.kt",
            |metric| {
                // expected: unit(1) + class(1) + fn(base 1 + if 1 + for 1 +
                //           2 explicit when arms; else skipped + && 1 +
                //           catch 1) = sum 9, max 7.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 9);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 7);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 9,
                  "value": 1,
                  "average": 9.0,
                  "min": 1,
                  "max": 7,
                  "modified": {
                    "sum": 8,
                    "value": 1,
                    "average": 8.0,
                    "min": 1,
                    "max": 6
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: Kotlin when with 3 entries collapses to 1.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_when_modified() {
        check_metrics::<KotlinParser>(
            "fun describe(x: Int): String {
                 return when (x) {
                     1 -> \"one\"
                     2 -> \"two\"
                     3 -> \"three\"
                     else -> \"other\"
                 }
             }",
            "foo.kt",
            |metric| {
                // standard: unit(1) + fn(base 1 + 3 explicit when arms;
                //           else skipped per #282) = 5
                // modified: unit(1) + fn(1) + WhenExpression(1) = 3
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Regression #282: the `else -> …` arm in a Kotlin `when`
    /// expression must NOT contribute to standard CCN, mirroring the
    /// C-family `default:` rule.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_when_else_arm_not_counted() {
        check_metrics::<KotlinParser>(
            "fun describe(x: Int): String {
                 return when (x) {
                     1 -> \"one\"
                     else -> \"other\"
                 }
             }",
            "foo.kt",
            |metric| {
                // expected: unit(1) + fn(base 1 + 1 explicit; else skipped) = 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
            },
        );
    }

    /// Cross-check #282: every case-style arm in a Kotlin `when`
    /// contributes one standard decision; only the `else ->` arm is
    /// skipped. Pairs with `kotlin_when_else_arm_not_counted` (which
    /// pins the single-explicit case) to confirm the count scales
    /// linearly with explicit arms and is not accidentally hard-coded
    /// to one.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_when_multiple_explicit_arms_each_count() {
        check_metrics::<KotlinParser>(
            "fun describe(x: Int): String {
                 return when (x) {
                     1 -> \"one\"
                     2 -> \"two\"
                     3 -> \"three\"
                     else -> \"other\"
                 }
             }",
            "foo.kt",
            |metric| {
                // expected: unit(1) + fn(base 1 + 3 explicit; else skipped) = 5, max 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_1_level_nesting() {
        // chunk: base=1; f: base=1 + for=1 + if=1 = 3; sum=4
        check_metrics::<LuaParser>(
            "local function f(t)
  for i = 1, #t do
    if t[i] > 0 then
      return t[i]
    end
  end
  return 0
end",
            "foo.lua",
            |metric| {
                insta::assert_json_snapshot!(metric.cyclomatic, @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_elseif_branches() {
        // chunk: base=1; classify: base=1 + if=1 + elseif=1 + elseif=1 = 4
        // else does NOT add a branch; sum=5
        check_metrics::<LuaParser>(
            "local function classify(x)
  if x > 0 then
    return 1
  elseif x < 0 then
    return -1
  elseif x == 0 then
    return 0
  else
    return 0
  end
end",
            "foo.lua",
            |metric| {
                insta::assert_json_snapshot!(metric.cyclomatic, @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_logical_operators() {
        // chunk: base=1; f: base=1 + if=1 + and=1 + or=1 = 4; sum=5
        check_metrics::<LuaParser>(
            "local function f(a, b, c)
  if a and b or c then
    return 1
  end
  return 0
end",
            "foo.lua",
            |metric| {
                insta::assert_json_snapshot!(metric.cyclomatic, @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_nested_control_flow() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    if [ $1 -eq 1 ]; then
        for i in 1 2 3; do
            echo $i
        done
    elif [ $1 -eq 2 ]; then
        echo 'two'
    fi
}",
            "foo.sh",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    {".sum" => insta::rounded_redaction(2)}
                );
            },
        );
    }

    /// Regression test for #107: case…esac must not double-count the container.
    /// Standard CCN counts only arms (matching C-family `switch` semantics).
    /// Modified CCN counts only the container.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_case_modified() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    case $1 in
        one)   echo 1 ;;
        two)   echo 2 ;;
        three) echo 3 ;;
    esac
}",
            "foo.sh",
            |metric| {
                // standard: unit(1) + fn(1) + 3 case_items = 5
                // modified: unit(1) + fn(1) + case_stmt(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_1_level_nesting() {
        // chunk: base=1; f: base=1 + while=1 + if=1 = 3; sum=4
        check_metrics::<TclParser>(
            "proc f {x} {
    while {$x > 0} {
        if {$x > 10} {
            set x [expr {$x - 1}]
        }
    }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1 + while 1 + if 1) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_elseif_branch() {
        // if=1, elseif=1; else does NOT add a branch; sum=3 (chunk base=1)
        check_metrics::<TclParser>(
            "proc f {x} {
    if {$x > 10} {
        puts big
    } elseif {$x > 5} {
        puts medium
    } else {
        puts small
    }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1 + if 1 + elseif 1) = sum 4, max 3.
                // else does NOT add a branch.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_logical_operators() {
        check_metrics::<TclParser>(
            "proc f {x y z} {
    if {$x > 0 && $y > 0 || $z > 0} {
        puts ok
    }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1 + if 1 + && 1 + || 1) = sum 5, max 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_catch_branch() {
        // `catch` command adds +1 (conditional handler); `try` does NOT add a branch.
        // source_file(1) + proc_space(base=1 + catch=1 = 2) = sum=3
        check_metrics::<TclParser>(
            "proc f {} {
    catch {
        expr {1 / 0}
    } msg
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1 + catch 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_try_no_branch() {
        // `try` is NOT a conditional construct; it does not add cyclomatic complexity.
        // Only the base counts: source_file(1) + proc_space(base=1) = sum=2, average=1.
        check_metrics::<TclParser>(
            "proc f {} {
    try {
        expr {1 / 0}
    } finally {
        puts done
    }
}",
            "foo.tcl",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 2,
                  "value": 1,
                  "average": 2.0,
                  "min": 1,
                  "max": 1,
                  "modified": {
                    "sum": 2,
                    "value": 1,
                    "average": 2.0,
                    "min": 1,
                    "max": 1
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_switch_cyclomatic() {
        // Tcl `switch` is a generic command; each non-`default` arm is a
        // decision point in standard CCN, while modified CCN counts the
        // construct once (issue #467). Three arms (1, 2, default): the two
        // non-default arms add +2 standard; `default` is free.
        check_metrics::<TclParser>(
            "proc f {x} {
    switch $x {
        1 { puts a }
        2 { puts b }
        default { puts c }
    }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1 + arm 1 + arm 2) = standard sum 4, max 3.
                // modified collapses arms to one container: unit(1) +
                // proc(base 1 + switch 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 2);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_switch_cyclomatic_no_default_with_options() {
        // No `default` arm, and leading `switch` options (`-exact --`) precede
        // the value: the arm list is still the trailing braced word, so both
        // arms count. Guards the option-form arm-list location (issue #467).
        check_metrics::<TclParser>(
            "proc f {x} {
    switch -exact -- $x {
        1 { puts a }
        2 { puts b }
    }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1 + arm 1 + arm 2) = standard sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 2);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_switch_split_form_stays_uncounted() {
        // The split arm form (`switch $x a {…} b {…}`) passes each arm
        // body as its own sibling `braced_word` argument instead of
        // wrapping the whole arm list in one, so there is no arm node to
        // count and `tcl_switch_arm_list` deliberately declines it
        // (issue #467). The construct is then left uncounted in BOTH
        // tiers, exactly as an unrecognised command is — not counted as a
        // container in modified CCN.
        check_metrics::<TclParser>(
            "proc f {x} {
    switch $x a { puts a } b { puts b }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1) and nothing else, in either
                // tier; the brace-list spelling of the same two-arm
                // switch scores 4 / 3 (see `tcl_switch_cyclomatic`).
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 1);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 1);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_for_cyclomatic() {
        // Tcl `for` is a generic command — the grammar has no `for` rule —
        // so it is detected by leading word (issue #1264): one loop decision
        // in both standard and modified CCN, matching `foreach`/`while`.
        check_metrics::<TclParser>(
            "proc f {n} {
    for {set i 0} {$i < $n} {incr i} {
        puts $i
    }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1 + for 1) = sum 3, max 2, both tiers.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 2);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_for_cyclomatic_name_gate() {
        // The detection reads the command's `name` field: a command whose
        // name merely starts with "for" (`format`, with `for`-shaped braced
        // arguments) and a `for` word in argument position (`puts for`) must
        // both stay at zero (issue #1264).
        check_metrics::<TclParser>(
            "proc f {} {
    format {a} {b} {c} {d}
    puts for
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1) only; no decision points.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 1);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 2);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_qualified_for_resolves_to_the_builtin() {
        // `::for` is `for` through the global namespace, so it scores
        // exactly what `tcl_for_cyclomatic` asserts for the bare word.
        check_metrics::<TclParser>(
            "proc f {n} {
    ::for {set i 0} {$i < $n} {incr i} {
        puts $i
    }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1 + for 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_namespaced_for_is_not_the_builtin() {
        // Control: `ns::for` lives in `ns` and is not the core loop, so
        // it adds no decision — the same expectation
        // `tcl_for_cyclomatic_name_gate` holds for `format`, and the
        // braced arguments are operator-free for the same reason.
        check_metrics::<TclParser>(
            "proc f {} {
    ns::for {a} {b} {c} {d}
}",
            "foo.tcl",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 1);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 2);
            },
        );
    }

    #[cfg(all(feature = "irules", feature = "tcl"))]
    #[test]
    fn tcl_irules_for_parity() {
        // iRules models `for` as a dedicated kind counted by the kind
        // dispatch; Tcl detects it by leading word (issue #1264). The same
        // loop must score identically in both — and the iRules figure also
        // pins that its dedicated kind is not double-counted through the
        // Tcl command-name path.
        // unit(1) + container(base 1 + for 1) = sum 3, max 2, both tiers.
        check_metrics::<TclParser>(
            "proc f {} {
    for {set i 0} {$i < 10} {incr i} {
        puts $i
    }
}",
            "foo.tcl",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
            },
        );
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST {
    for {set i 0} {$i < 10} {incr i} {
        puts $i
    }
}
",
            "foo.irule",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_try_on_error_cyclomatic() {
        // Tcl `try` is a dedicated kind whose single permitted `on error`
        // handler is a flat token run (issue #1266): the handler is one
        // decision point in both tiers, matching `catch`; `finally` is
        // unconditional and free.
        check_metrics::<TclParser>(
            "proc f {} {
    try {
        risky
    } on error {msg} {
        puts $msg
    } finally {
        cleanup
    }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1 + handler 1) = sum 3, max 2, both tiers.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 2);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_try_finally_only_cyclomatic() {
        // A `try` with no handler has no decision point: `finally` is
        // unconditional cleanup and must stay +0 (issue #1266, the
        // cross-language `finally` convention of #416).
        check_metrics::<TclParser>(
            "proc f {} {
    try {
        risky
    } finally {
        cleanup
    }
}",
            "foo.tcl",
            |metric| {
                // unit(1) + proc(base 1) only.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 1);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 2);
            },
        );
    }

    #[cfg(feature = "irules")]
    #[test]
    fn irules_try_handlers_cyclomatic() {
        // iRules wraps each `try` handler in a dedicated `on_handler` /
        // `trap_handler` node (unlike Tcl's flat tokens): one decision
        // point each in both tiers (issue #1266). The figure also pins
        // that the handlers no longer open anonymous function spaces —
        // as spaces each would carry its own base 1, making the sum 6.
        check_metrics::<IrulesParser>(
            "proc f {} {
    try {
        risky
    } on error {msg} {
        puts $msg
    } trap {POSIX} {msg} {
        puts $msg
    } finally {
        cleanup
    }
}",
            "foo.irule",
            |metric| {
                // unit(1) + proc(base 1 + on 1 + trap 1) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 3);
            },
        );
    }

    #[cfg(all(feature = "irules", feature = "tcl"))]
    #[test]
    fn tcl_irules_try_parity() {
        // The same single-handler `try` must score identically in Tcl
        // (flat `on`/`error` tokens under `try`) and iRules (a dedicated
        // `on_handler` wrapper) — issue #1266.
        // unit(1) + proc(base 1 + handler 1) = sum 3, max 2, both tiers.
        let source = "proc f {} {
    try {
        risky
    } on error {msg} {
        puts $msg
    } finally {
        cleanup
    }
}";
        check_metrics::<TclParser>(source, "foo.tcl", |metric| {
            assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
            assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
            assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
        });
        check_metrics::<IrulesParser>(source, "foo.irule", |metric| {
            assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
            assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
            assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
        });
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_for_loop() {
        check_metrics::<MozjsParser>(
            "function f(n) { // +2 (+1 unit)
             var s = 0;
             for (var i = 0; i < n; i++) { // +1
                 s += i;
             }
             return s;
         }",
            "foo.js",
            |metric| {
                // unit(1) + fn(base 1 + for 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_logical_operators() {
        check_metrics::<MozjsParser>(
            "function f(a, b, c) { // +2 (+1 unit)
             if (a && b || c) { // +1 if, +1 &&, +1 ||
                 return 1;
             }
             return 0;
         }",
            "foo.js",
            |metric| {
                // unit(1) + fn(base 1 + if 1 + && 1 + || 1) = sum 5, max 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_nullish_coalescing_chain_226() {
        // `??` is short-circuit and must count as
        // a decision point in cyclomatic complexity.  `a ?? b ?? c` adds two
        // `??` decisions on top of the function entry.
        check_metrics::<JavascriptParser>(
            "function pick(a, b, c) { // +1 (entry)
                 return a ?? b ?? c; // +2 (two `??`)
             }",
            "foo.js",
            |metric| {
                // unit(1) + fn(entry 1 + 2*?? = 3) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_nullish_coalescing_with_if_226() {
        // TypeScript must count `??` as a
        // decision.  This mirrors the example in the issue body.
        check_metrics::<TypescriptParser>(
            "function classify(x: string | null, fallback: string | null): string { // +1 (entry)
                 if (x === \"y\") return \"yes\"; // +1 (if)
                 return x ?? fallback ?? \"unknown\"; // +2 (two `??`)
             }",
            "foo.ts",
            |metric| {
                // unit(1) + fn(entry 1 + if 1 + 2*?? = 4) = sum 5, max 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_nullish_coalescing_chain_226() {
        // TSX must count `??` the same as JS/TS.
        check_metrics::<TsxParser>(
            "function pick(a: number | null, b: number | null, c: number): number { // +1 (entry)
                 return a ?? b ?? c; // +2 (two `??`)
             }",
            "foo.tsx",
            |metric| {
                // unit(1) + fn(entry 1 + 2*?? = 3) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_nullish_coalescing_chain_226() {
        // Mozjs must count `??` the same as JS.
        check_metrics::<MozjsParser>(
            "function pick(a, b, c) { // +1 (entry)
                 return a ?? b ?? c; // +2 (two `??`)
             }",
            "foo.js",
            |metric| {
                // unit(1) + fn(entry 1 + 2*?? = 3) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_nullish_coalescing_assignment_231() {
        // `x ??= y` is `x = x ?? y` — one short-circuit decision edge,
        // same as `??`. Two `??=` assignments add +2 on top of the entry.
        check_metrics::<JavascriptParser>(
            "function pick(o) { // +1 (entry)
                 o.x ??= 1; // +1 (??=)
                 o.y ??= 2; // +1 (??=)
                 return o;
             }",
            "foo.js",
            |metric| {
                // unit(1) + fn(entry 1 + 2*??= = 3) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_nullish_coalescing_assignment_231() {
        // TypeScript must count `??=` the same as JS.
        check_metrics::<TypescriptParser>(
            "function pick(o: { x?: number; y?: number }) { // +1 (entry)
                 o.x ??= 1; // +1 (??=)
                 o.y ??= 2; // +1 (??=)
                 return o;
             }",
            "foo.ts",
            |metric| {
                // unit(1) + fn(entry 1 + 2*??= = 3) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_nullish_coalescing_assignment_231() {
        // TSX must count `??=` the same as JS/TS.
        check_metrics::<TsxParser>(
            "function pick(o: { x?: number; y?: number }) { // +1 (entry)
                 o.x ??= 1; // +1 (??=)
                 o.y ??= 2; // +1 (??=)
                 return o;
             }",
            "foo.tsx",
            |metric| {
                // unit(1) + fn(entry 1 + 2*??= = 3) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_nullish_coalescing_assignment_231() {
        // Mozjs must count `??=` the same as JS.
        check_metrics::<MozjsParser>(
            "function pick(o) { // +1 (entry)
                 o.x ??= 1; // +1 (??=)
                 o.y ??= 2; // +1 (??=)
                 return o;
             }",
            "foo.js",
            |metric| {
                // unit(1) + fn(entry 1 + 2*??= = 3) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_short_circuit_assignments_248() {
        // `&&=`, `||=`, `??=` are each one short-circuit decision edge —
        // semantically `x = x op y`. #231 added only `??=`; #248 adds the
        // sibling `&&=` and `||=`.
        check_metrics::<JavascriptParser>(
            "function f(x, y, z) { // +1 (entry)
                 x ??= 1; // +1 (??=)
                 y &&= 2; // +1 (&&=)
                 z ||= 3; // +1 (||=)
                 return x;
             }",
            "foo.js",
            |metric| {
                // unit(1) + fn(entry 1 + 3 assignments = 4) = sum 5, max 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_short_circuit_assignments_248() {
        // TypeScript parallel of #248: `&&=` / `||=` / `??=` each +1.
        check_metrics::<TypescriptParser>(
            "function f(x: number | null, y: number | null, z: number | null): number { // +1 (entry)
                 x ??= 1; // +1 (??=)
                 y &&= 2; // +1 (&&=)
                 z ||= 3; // +1 (||=)
                 return x ?? 0; // +1 (??)
             }",
            "foo.ts",
            |metric| {
                // unit(1) + fn(entry 1 + 3 op= + 1 `??` = 5) = sum 6, max 5.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 6);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 5);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 6,
                    "value": 1,
                    "average": 6.0,
                    "min": 1,
                    "max": 5
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_short_circuit_assignments_248() {
        // TSX parallel of #248: `&&=` / `||=` / `??=` each +1.
        check_metrics::<TsxParser>(
            "function f(x: number | null, y: number | null, z: number | null): number { // +1 (entry)
                 x ??= 1; // +1 (??=)
                 y &&= 2; // +1 (&&=)
                 z ||= 3; // +1 (||=)
                 return x ?? 0; // +1 (??)
             }",
            "foo.tsx",
            |metric| {
                // unit(1) + fn(entry 1 + 3 op= + 1 `??` = 5) = sum 6, max 5.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 6);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 5);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 6,
                    "value": 1,
                    "average": 6.0,
                    "min": 1,
                    "max": 5
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_short_circuit_assignments_248() {
        // Mozjs parallel of #248: `&&=` / `||=` / `??=` each +1.
        check_metrics::<MozjsParser>(
            "function f(x, y, z) { // +1 (entry)
                 x ??= 1; // +1 (??=)
                 y &&= 2; // +1 (&&=)
                 z ||= 3; // +1 (||=)
                 return x;
             }",
            "foo.js",
            |metric| {
                // unit(1) + fn(entry 1 + 3 assignments = 4) = sum 5, max 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 4
                  }
                }
                "#
                );
            },
        );
    }

    // Issue #281: optional chaining (`?.`) is short-circuit (it skips
    // the rest of the chain when the LHS is nullish), so each `?.`
    // adds one cyclomatic decision point. Before the fix, JS-family
    // cyclomatic ignored `?.` entirely. The four tests below mirror
    // the existing `nullish_coalescing_chain_226` pattern but for
    // `?.`: two `?.` in a chain add +2 on top of the function entry.
    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_optional_chain_counted_in_cyclomatic_281() {
        check_metrics::<JavascriptParser>(
            "function pick(a) { // +1 (entry)
                 return a?.b?.c; // +2 (two `?.`)
             }",
            "foo.js",
            |metric| {
                // unit(1) + fn(entry 1 + 2*?. = 3) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_optional_chain_counted_in_cyclomatic_281() {
        check_metrics::<MozjsParser>(
            "function pick(a) { // +1 (entry)
                 return a?.b?.c; // +2 (two `?.`)
             }",
            "foo.js",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_optional_chain_counted_in_cyclomatic_281() {
        // TS exposes `?.` as both an `optional_chain` wrapper (over
        // member expressions) and a bare token (over call
        // expressions). We dispatch on `QMARKDOT` so every textual
        // `?.` adds exactly one decision point regardless of context.
        check_metrics::<TypescriptParser>(
            "function pick(a: any) { // +1 (entry)
                 return a?.b?.c; // +2 (two `?.`)
             }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_optional_chain_counted_in_cyclomatic_281() {
        check_metrics::<TsxParser>(
            "function pick(a: any) { // +1 (entry)
                 return a?.b?.c; // +2 (two `?.`)
             }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    // Mix of member-expression `?.` and call-expression `?.()`:
    // ensures the TS/TSX dispatch on `QMARKDOT` (not the wrapper)
    // counts both forms exactly once. Both forms emit the bare `?.`
    // token; the wrapper only appears around member expressions.
    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_optional_chain_call_form_counted_281() {
        check_metrics::<TypescriptParser>(
            "function pick(a: any) { // +1 (entry)
                 return a?.b?.(); // +2 (member `?.` + call `?.`)
             }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_optional_chain_call_form_counted_281() {
        check_metrics::<TsxParser>(
            "function pick(a: any) { // +1 (entry)
                 return a?.b?.(); // +2 (member `?.` + call `?.`)
             }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_nullish_coalescing_assignment_231() {
        // C#'s `??=` is short-circuit (RHS evaluates only when LHS is null)
        // and must add +1 cyclomatic per occurrence (#231).
        check_metrics::<CsharpParser>(
            "public class A {
                public int? x;
                public int? y;
                public void Pick() { // +1 (entry)
                    x ??= 1; // +1 (??=)
                    y ??= 2; // +1 (??=)
                }
            }",
            "foo.cs",
            |metric| {
                // unit(1) + class(1) + Pick(entry 1 + 2*??= = 3) = sum 5,
                // max 3 (Pick).
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_while_loop() {
        check_metrics::<MozjsParser>(
            "function f(n) { // +2 (+1 unit)
             var i = 0;
             while (i < n) { // +1
                 i++;
             }
             return i;
         }",
            "foo.js",
            |metric| {
                // unit(1) + fn(base 1 + while 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_while_loop() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    local n=$1
    while [ $n -gt 0 ]; do
        echo $n
        n=$((n - 1))
    done
}",
            "foo.sh",
            |metric| {
                // unit(1) + fn(base 1 + while 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_case_statement() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    case $1 in
        start) echo starting ;;
        stop)  echo stopping ;;
        *)     echo unknown  ;;
    esac
}",
            "foo.sh",
            |metric| {
                // standard: unit(1) + fn(base 1 + 2 explicit case_items;
                //          `*)` skipped per #211) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    /// Regression #211: a bare `*)` arm is Bash's analogue of the
    /// C-family `default:` and must NOT contribute to standard CCN.
    /// Without the fix, this 2-arm case reports `cyclomatic_max == 3`
    /// (1 base + 2 arms); with the fix it reports `2` (1 base + 1
    /// explicit arm), matching every other switch-bearing language
    /// in `tests/parity/cyclomatic_cross_language_parity.rs`.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_case_bare_wildcard_excluded() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    case \"$1\" in
        one) echo 1 ;;
        *)   echo 0 ;;
    esac
}",
            "foo.sh",
            |metric| {
                // standard: unit(1) + fn(base 1 + 1 explicit; `*)` skipped) = 3, max 2.
                // modified: unit(1) + fn(base 1 + case_stmt 1) = 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    /// A multi-value pattern containing `*` (`a|*)`) is NOT a bare
    /// wildcard — both alternations make it a non-default case. The
    /// arm still contributes one standard decision.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_case_multi_value_with_star_counts() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    case \"$1\" in
        a|*) echo any ;;
    esac
}",
            "foo.sh",
            |metric| {
                // standard: unit(1) + fn(base 1 + 1 arm) = 3, max 2.
                // The `a|*` pattern has TWO `value` fields, so the
                // bare-wildcard filter (`value_count == 1`) skips it.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_arithmetic_ternary_is_a_decision() {
        // Regression for #1268: the arithmetic ternary is the only ternary
        // form Bash has, and it contributed nothing to either cyclomatic
        // tier while every sibling with a ternary counts one. Both
        // arithmetic contexts are covered — the `$(( … ))` expansion and
        // the bare `(( … ))` statement — since the grammar admits the
        // construct in both and only a fixture in each shows both reach
        // the arm.
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    local m=$(( a > b ? a : b ))
}
g() {
    (( x = a ? b : c ))
}",
            "foo.sh",
            |metric| {
                // unit(1) + f(base 1 + ternary 1) + g(base 1 + ternary 1)
                // = sum 5, max 2. Both tiers move: a ternary is a decision
                // point in the modified count too.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 5);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_ternary_expression_alias_is_unreachable() {
        // Drift marker for the defensive `TernaryExpression2` arm (lesson
        // 34 / grammar-dispatch §1). The Bash enum carries two kinds
        // mapping to `"ternary_expression"`, but at the pinned grammar
        // only 223 is ever emitted — verified across every arithmetic
        // context the grammar admits: `$(( … ))` expansion, bare
        // `(( … ))` statement, a c-style `for ((…))` header, `let`, an
        // array subscript, an `if (( … ))` condition, and a `declare -i`
        // initializer. Both cyclomatic and cognitive list the alias
        // anyway; if a grammar bump starts emitting it, this assertion
        // fails loudly rather than the metric silently doubling.
        let src = "for ((i = a ? b : c; i < 10; i++)); do :; done\n\
                   let \"y = a ? b : c\"\n\
                   arr[$(( a ? b : c ))]=1\n\
                   if (( a ? b : c )); then :; fi\n\
                   declare -i z=$(( a ? b : c ))\n\
                   w=$(( a ? b : c ))\n\
                   (( v = a ? b : c ))\n";
        let parser = BashParser::new(
            src.as_bytes().to_vec(),
            &std::path::PathBuf::from("foo.sh"),
            None,
        );
        assert!(ast_has_kind_id(&parser, Bash::TernaryExpression as u16));
        assert!(!ast_has_kind_id(&parser, Bash::TernaryExpression2 as u16));
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_nested_arithmetic_ternary_counts_each_occurrence() {
        // Each ternary is its own decision point (#1268).
        check_metrics::<BashParser>(
            "#!/bin/bash
h() {
    local n=$(( a ? b : c ? d : e ))
}",
            "foo.sh",
            |metric| {
                // unit(1) + h(base 1 + two ternaries) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_simple_function() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    echo hello
}",
            "foo.sh",
            |metric| {
                // unit(1) + fn(base 1) = sum 2, max 1.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 1);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_for_loop() {
        check_metrics::<KotlinParser>(
            "fun sum(n: Int): Int {  // +2 (+1 unit)
             var s = 0
             for (i in 1..n) {  // +1
                 s += i
             }
             return s
         }",
            "foo.kt",
            |metric| {
                // unit(1) + fn(base 1 + for 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_while_loop() {
        check_metrics::<KotlinParser>(
            "fun countdown(n: Int): Int { // +2 (+1 unit)
             var i = n
             while (i > 0) { // +1
                 i--
             }
             return i
         }",
            "foo.kt",
            |metric| {
                // unit(1) + fn(base 1 + while 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_logical_operators() {
        check_metrics::<KotlinParser>(
            "fun check(a: Boolean, b: Boolean, c: Boolean): Boolean { // +2 (+1 unit)
             return a && b || c  // +1 &&, +1 ||
         }",
            "foo.kt",
            |metric| {
                // unit(1) + fn(base 1 + && 1 + || 1) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_elvis_operator_239() {
        // Regression for issue #239: Kotlin's Elvis operator `?:` is a
        // short-circuit nullish operator analogous to JS `??` and each
        // occurrence is a distinct decision point, mirroring `&&` /
        // `||`. `a ?: b ?: c` contributes +2 to the function's
        // cyclomatic complexity (base 1 + two `?:` = 3).
        check_metrics::<KotlinParser>(
            "fun pick(a: String?, b: String?, c: String): String { // +2 (+1 unit)
             return a ?: b ?: c  // +2 (two ?: short-circuits)
         }",
            "foo.kt",
            |metric| {
                // unit(1) + fn(base 1 + ?: 1 + ?: 1) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_safe_navigation_436() {
        // Issue #436: Kotlin's safe-navigation `?.` is a short-circuit
        // decision point, mirroring the JS/TS/C# treatment of `?.`
        // (#281). Each `?.` adds +1; the chain `a?.b?.c` adds +2.
        check_metrics::<KotlinParser>(
            "fun read(a: A?): String? { // +2 (+1 unit)
             return a?.b?.c  // +2 (two ?. short-circuits)
         }",
            "foo.kt",
            |metric| {
                // unit(1) + fn(base 1 + ?. 1 + ?. 1) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                // modified mirrors standard: each `?.` is both-metric.
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 3);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_for_loop() {
        check_metrics::<TypescriptParser>(
            "function sum(n: number): number { // +2 (+1 unit)
             let s = 0;
             for (let i = 0; i < n; i++) { // +1
                 s += i;
             }
             return s;
         }",
            "foo.ts",
            |metric| {
                // unit(1) + fn(base 1 + for 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_while_loop() {
        check_metrics::<TypescriptParser>(
            "function countdown(n: number): number { // +2 (+1 unit)
             let i = n;
             while (i > 0) { // +1
                 i--;
             }
             return i;
         }",
            "foo.ts",
            |metric| {
                // unit(1) + fn(base 1 + while 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_logical_operators() {
        check_metrics::<TypescriptParser>(
            "function check(a: boolean, b: boolean, c: boolean): boolean { // +2 (+1 unit)
             return a && b || c;  // +1 &&, +1 ||
         }",
            "foo.ts",
            |metric| {
                // unit(1) + fn(base 1 + && 1 + || 1) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_try_catch() {
        check_metrics::<TypescriptParser>(
            "function safe(x: number): number { // +2 (+1 unit)
             try {
                 return 1 / x;
             } catch (e) { // +1
                 return 0;
             }
         }",
            "foo.ts",
            |metric| {
                // unit(1) + fn(base 1 + catch 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_for_loop() {
        check_metrics::<TsxParser>(
            "function sum(n: number): number { // +2 (+1 unit)
             let s = 0;
             for (let i = 0; i < n; i++) { // +1
                 s += i;
             }
             return s;
         }",
            "foo.tsx",
            |metric| {
                // unit(1) + fn(base 1 + for 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_while_loop() {
        check_metrics::<TsxParser>(
            "function countdown(n: number): number { // +2 (+1 unit)
             let i = n;
             while (i > 0) { // +1
                 i--;
             }
             return i;
         }",
            "foo.tsx",
            |metric| {
                // unit(1) + fn(base 1 + while 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_logical_operators() {
        check_metrics::<TsxParser>(
            "function check(a: boolean, b: boolean, c: boolean): boolean { // +2 (+1 unit)
             return a && b || c;  // +1 &&, +1 ||
         }",
            "foo.tsx",
            |metric| {
                // unit(1) + fn(base 1 + && 1 + || 1) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_try_catch() {
        check_metrics::<TsxParser>(
            "function safe(x: number): number { // +2 (+1 unit)
             try {
                 return 1 / x;
             } catch (e) { // +1
                 return 0;
             }
         }",
            "foo.tsx",
            |metric| {
                // unit(1) + fn(base 1 + catch 1) = sum 3, max 2.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_switch() {
        check_metrics::<TsxParser>(
            "function describe(x: number): string { // +2 (+1 unit)
             switch (x) {
                 case 1: // +1
                     return 'one';
                 case 2: // +1
                     return 'two';
                 default:
                     return 'other';
             }
         }",
            "foo.tsx",
            |metric| {
                // unit(1) + fn(base 1 + 2 cases) = sum 4, max 3.
                // default does NOT add a branch.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    /// Modified CCN: TSX switch with 2 cases collapses to 1.
    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_switch_modified() {
        check_metrics::<TsxParser>(
            "function f(x: number): string {
                 switch (x) {
                     case 1: return 'one';
                     case 2: return 'two';
                     default: return 'other';
                 }
             }",
            "foo.tsx",
            |metric| {
                // standard: unit(1) + fn(1) + 2 cases = sum 4, max 3.
                // modified: unit(1) + fn(1) + switch(1) = sum 3, max 2.
                // default does NOT add a branch.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_1_level_nesting() {
        // Mirrors java_simple_class' if-inside-method shape:
        // unit (+1) + function (+1) + if (+1) + && (+1) = sum 4.
        check_metrics::<PhpParser>(
            "<?php
            function f(int $a, int $b): bool {
                if ($a > 0 && $b > 0) {
                    return true;
                }
                return false;
            }",
            "foo.php",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    // `case`/`cond`/`with` arms surface as `stab_clause` nodes and
    // contribute to standard CCN, mirroring the C-family `case:` arm
    // treatment — including its `default:` exclusion: the bare `_ ->`
    // catch-all is the construct's default arm and adds no decision
    // (issue #1272). The container Call (`case`) contributes once to
    // modified CCN, collapsing arms back to a single decision point.
    // Three func spaces (Unit + defmodule Class + def Function) each
    // seed one entry: standard = 3 entries + 2 counted stabs = 5;
    // modified = 3 entries + 1 case Call = 4.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_case_arms() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def classify(x) do\n    case x do\n      1 -> :one\n      2 -> :two\n      _ -> :other\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // A guarded wildcard (`_ when g ->`) is a real decision — the
    // guard can fail, so control can fall through — and must keep
    // counting, matching Rust's `_ if guard` rule (issue #1272).
    // standard = 3 entries + `1 ->` + `_ when x > 5 ->` + the guard
    // itself = 6 (only the final bare `_ ->` is excluded); modified =
    // 3 entries + case + the guard = 5. The guard is the #1454 arm: it
    // is a second way the arm can fail, and no container collapses it,
    // so it counts in both tiers where the arm counts only in standard.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_case_guarded_wildcard_counts() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def classify(x) do\n    case x do\n      1 -> :one\n      _ when x > 5 -> :big\n      _ -> :other\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 6);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 5);
            },
        );
    }

    // A named discard (`_x ->`) binds a value the body can read; only
    // the bare `_` is the default arm, matching Rust's bare-`_`-only
    // MatchArm rule (issue #1272). standard = 3 entries + `1 ->` +
    // `_x ->` = 5; modified = 3 entries + case Call = 4.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_case_named_discard_counts() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def classify(x) do\n    case x do\n      1 -> :one\n      _x -> :named\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // `true ->` under `case` is an ordinary boolean pattern, not a
    // designated default — the cond-only exclusion must not leak here
    // (issue #1272, grammar-dispatch §8: anchor the exclusion to the
    // owning construct). standard = 3 entries + `true ->` +
    // `false ->` = 5; modified = 3 entries + case Call = 4.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_case_true_pattern_counts() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    case x do\n      true -> :t\n      false -> :f\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // Each short-circuit boolean (`&&`, `||`, `and`, `or`) is one
    // decision point — Elixir does not expose `if`/`unless` as a
    // distinct kind_id, so this is the only operator-driven path the
    // metric can see.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_logical_operators() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x, y) do\n    x and y or (x && y) || x\n  end\nend\n",
            "foo.ex",
            |metric| {
                // 4 short-circuit ops + 3 entries (Unit, defmodule, def) = 7.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 7);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 7);
            },
        );
    }

    // `try`/`rescue`/`catch` is a multi-arm container Call: the `try`
    // Call contributes once to modified CCN, while each rescue/catch
    // arm's matched pattern (a `stab_clause`) contributes once to
    // standard CCN. This mirrors C-family `try`/`catch` semantics.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_try_rescue() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def safe do\n    try do\n      do_it()\n    rescue\n      ArgumentError -> :bad\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                // standard: 3 entries + 1 rescue stab = 4
                // modified: 3 entries + 1 try Call = 4
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // `if x do ... else ... end` surfaces as a `Call(target=if)`; the
    // metric inspects the source text of the call's target field to
    // identify it. Single-branch keyword Calls (`if`/`unless`/`for`/
    // `while`) contribute to both standard and modified CCN.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_if_else_counts() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    if x > 0 do\n      :pos\n    else\n      :neg\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                // 1 if Call + 3 entries (Unit, defmodule Class, def Function) = 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // `if x do ... end` without an `else` clause still surfaces as
    // `Call(target=if)` and is counted identically to the if/else
    // form — the `else` keyword is a do-block keyword argument, not
    // an extra `stab_clause`, so its presence does not change the
    // cyclomatic count.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_if_without_else_counts() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    if x > 0 do\n      :pos\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                // 1 if Call + 3 entries = 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // `unless x do ... end` is the negated `if`; it surfaces as
    // `Call(target=unless)` and is treated identically to `if`.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_unless_counts() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    unless x > 0 do\n      :nonpos\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // `for x <- list, do: ...` is Elixir's comprehension generator —
    // a `Call(target=for)`. Counts once for both standard and
    // modified, mirroring `if`/`unless`.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_for_comprehension_counts() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(xs) do\n    for x <- xs do\n      x * 2\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // `fn ... end` is its own function space (`get_space_kind` →
    // `Function`), so its cyclomatic gets its own `+1` entry path
    // alongside the Unit / defmodule Class / def Function entries.
    // The FIRST `stab_clause` is the closure's head/definition and does
    // NOT count (issue #776); only the 2nd+ clauses are pattern-dispatch
    // branches. The bare-`_` default-arm exclusion (issue #1272) does
    // NOT apply inside a `fn`: the head skip already grants the free
    // base path, so the trailing `_ ->` here is a real dispatch
    // decision — a two-clause fn must report the same one decision as
    // the identical two-arm `case`. The anon-fn itself is not a
    // `Call`, so it adds no modified-CCN container decision.
    // Standard = 4 entries (Unit, defmodule, def, anon-fn) + 1 counted
    // branch (`_ ->`) = 5; modified = 4 entries = 4.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_anonymous_fn_arms_count() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f do\n    multi = fn 0 -> :zero; _ -> :other end\n    multi.(0)\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // Three-clause anonymous fn ending in a catch-all: a multi-clause
    // `fn` is a dispatch like `case` — n clauses are n−1 decisions —
    // and its free base path is the head-clause skip (#776), so the
    // bare-`_` exclusion (issue #1272) must not stack on top of it:
    // when both applied, this fn contributed ZERO decisions while the
    // identical `case 0/1/_` contributed one per counted arm. The head
    // is skipped, and BOTH the `1 ->` clause and the final `_ ->`
    // count, matching the 2 decisions of a 3-arm `case` ending in
    // `_ ->` (2 counted arms there: the bare `_ ->` is free but the
    // container's arms 1 and 2 count). Standard = 4 entries (Unit,
    // defmodule, def, anon-fn) + 2 branches = 6; modified = 4.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_multi_clause_fn_catchall_composition() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f do\n    multi = fn 0 -> :zero; 1 -> :one; _ -> :other end\n    multi.(0)\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 6);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // A non-head `true ->` clause of an anonymous fn is an ordinary
    // dispatch branch — its parent is the `anonymous_function`, not a
    // `cond`'s `do_block`, so the cond-default exclusion must not fire
    // (issue #1272). Standard = 4 entries (Unit, defmodule, def,
    // anon-fn) + 1 branch (the `true ->` clause) = 5; modified = 4.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_fn_true_clause_counts() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f do\n    flag = fn false -> :f; true -> :t end\n    flag.(true)\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // Regression for issue #776: a single-clause anonymous function
    // (`fn x -> x end`) has zero decision points — its lone
    // `stab_clause` is the closure head, not a branch. The closure's
    // own function space must therefore report cyclomatic 1 (base
    // entry only), matching cognitive's treatment (`cognitive.rs`
    // `elixir_enum_reduce_is_zero`). Before the fix the head clause
    // added a spurious +1, reporting 2. Standard = 4 entries (Unit,
    // defmodule, def, anon-fn) + 0 branches = 4; modified = 4.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_single_clause_anonymous_fn_is_not_a_branch() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f do\n    id = fn x -> x end\n    id.(1)\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // A zero-arity multi-clause `fn` is the one shape whose clauses
    // carry an *empty* pattern list (`()`), so neither clause has a sole
    // pattern for the default-arm exclusion to inspect. The head clause
    // is still free (#776) and the second clause is still a real
    // dispatch decision — "no pattern" must not be mistaken for the bare
    // `_ ->` catch-all, which is only free under a non-`fn` container
    // anyway (#1272). Standard = 4 entries (Unit, defmodule, def,
    // anon-fn) + 1 branch = 5; modified = 4 entries, the `fn` itself
    // being no container Call.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_zero_arity_multi_clause_fn_counts_second_clause() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f do\n    both = fn () -> :a; () -> :b end\n    both.()\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
                // The anonymous fn's own space carries base 1 + the one
                // counted clause; every enclosing space stays at base 1.
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 1);
            },
        );
    }

    // `cond do ... end` is the standard Elixir multi-way conditional.
    // Each clause is a `stab_clause` (standard CCN), except the
    // idiomatic `true ->` final arm — the construct's designated
    // default, the analogue of `if`/`elif`/`else`'s free `else`
    // (issue #1272). The `cond` Call is a multi-arm container
    // (modified CCN, once).
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_cond_arms() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    cond do\n      x < 0 -> :neg\n      x == 0 -> :zero\n      true -> :pos\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                // standard: 3 entries + 2 counted stabs (`true ->` free) = 5
                // modified: 3 entries + 1 cond Call = 4
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // A `cond` with no `true ->` default counts every arm — the
    // exclusion targets only the designated-default clause, not the
    // container's last arm (issue #1272). standard = 3 entries +
    // 2 stabs = 5; modified = 3 entries + 1 cond Call = 4.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_cond_without_default_counts_all_arms() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    cond do\n      x > 10 -> :big\n      x > 5 -> :mid\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // The `cond` `true ->` exclusion is shape-based, not positional: a
    // NON-final unguarded `true ->` (which shadows every later arm) is
    // excluded exactly like the idiomatic final one. This is the
    // deliberate, Rust-convention-matching choice — Rust's bare-`_`
    // MatchArm exclusion is equally position-blind, so the sibling
    // family sets the precedent (issue #1272). standard = 3 entries +
    // 1 counted stab (`x > 5 ->`; the shadowing `true ->` is free)
    // = 4; modified = 3 entries + 1 cond Call = 4.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_cond_shadowing_true_arm_also_excluded() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    cond do\n      true -> :forced\n      x > 5 -> :b\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
            },
        );
    }

    // Nesting keeps each exclusion anchored to its own construct
    // (issue #1272, grammar-dispatch §8): the outer `cond`'s `true ->`
    // is free (cond default), the inner `case`'s `true ->` counts
    // (ordinary pattern — its container is the case, not the cond),
    // and the inner bare `_ ->` is free (case default).
    // standard: 3 entries + outer `x > 1 ->` + inner `true ->` = 5;
    // modified: 3 entries + cond Call + case Call = 5.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_nested_case_inside_cond_keeps_exclusions_scoped() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x, y) do\n    cond do\n      x > 1 ->\n        case y do\n          true -> :t\n          _ -> :o\n        end\n      true -> :d\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 5);
            },
        );
    }

    // `with` chains use `<-` arrows, which parse as `binary_operator`
    // nodes — NOT `stab_clause`s — and each is a decision in both tiers
    // (#1535). The fallthrough `else` branch, when present, contains
    // `stab_clause`s that count for standard, and collapses into one
    // modified decision.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_with_counts_arrow_clauses_and_else_arms() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    with {:ok, v} <- fetch(x),\n         {:ok, w} <- fetch(v) do\n      {:ok, w}\n    else\n      :error -> :nope\n      other -> {:bad, other}\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                // standard: 3 entries + 2 `<-` clauses + 2 else-block
                // stabs = 7 (#1535 added the `<-` clauses)
                // modified: 3 entries + 2 `<-` clauses + 1 else
                // dispatch = 6
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 7);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 6);
            },
        );
    }

    // A `with`'s `<-` clauses and a `for … reduce:`'s head clause
    // (#1535). Each row is one `def`, read as (cyclomatic, modified,
    // abc.conditions); the function's base path is the 1.
    //
    // Expected values, from the twins rather than the fix (measured,
    // `--no-config`, as cyclomatic / modified / ABC conditions):
    // - `w1`: one `<-` is one decision, Rust's
    //   `if let Ok(a) = g(x) { a }` — 2/2/1, and `g(x)?` is 2/2/0.
    // - `w2` / `w2d`: two `<-` are two, Rust's nested `if let` — 3/3/2.
    //   `w2d`'s `else _ -> 0` picks between nothing, so it is free in
    //   both tiers, as Rust's `else { 0 }` is.
    // - `w1e`: the `else {:error, e} ->` arm pays per clause as a
    //   `case` arm does, and its dispatch collapses into one modified
    //   decision: 1 + `<-` + arm = 3, and 3 modified. `w1n`'s named
    //   `e ->` binds, so it is no bare `_` and scores the same. `w1g`'s
    //   guarded `_ when x > 1 ->` is a decision with a guard on it:
    //   1 + `<-` + clause + guard = 4, and modified collapses only the
    //   clause — 4.
    // - `w2e`: 1 + two `<-` + two arms = 5; modified 1 + 2 + 1 = 4.
    // - `wg`: the guard is one more decision on the `<-`, Rust's
    //   `if let Ok(a) = g(x) && a > 0` — 3/3/2.
    // - `wb`: a bare match `b = …` in a `with` cannot fail over to the
    //   `else`, so it is no clause — 2/2/1, `w1`'s value.
    // - `wk` / `wke`: the keyword form scores as the block form does.
    // - `r1` / `rk1`: a single reduce clause always matches, so the
    //   reduce scores what `fp`, the `for` without one, does — 2/2/0.
    // - `r2` / `r2d`: two reduce clauses are one decision, n−1 as a
    //   multi-clause `fn` is (#776), the trailing `_ ->` included —
    //   3/2/1. `rk2` is `r2` in the keyword form.
    // - `fp` / `ff` / `fg` / `fb`: a `for` generator's `<-` is not a
    //   `with` clause, nor is a guard on it (`fg` scores as the bare
    //   filter `ff`), nor a bitstring generator's — each scores the
    //   `for`'s one decision, as before #1535.
    // - `c`: `case {:ok, a} / _`, the Rust `match` twin — 2/2/1.
    //
    // ABC conditions sit at `cyclomatic - 1` on every row but the
    // `for`s, whose loop decision ABC deliberately does not count.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_with_arrow_clauses_and_reduce_head_1535() {
        let src = "defmodule M do
  def w1(x) do
    with {:ok, a} <- g(x) do a end
  end
  def w2(x) do
    with {:ok, a} <- g(x), {:ok, b} <- h(a) do b end
  end
  def w2d(x) do
    with {:ok, a} <- g(x), {:ok, b} <- h(a) do b else _ -> 0 end
  end
  def w1e(x) do
    with {:ok, a} <- g(x) do a else {:error, e} -> e end
  end
  def w1n(x) do
    with {:ok, a} <- g(x) do a else e -> e end
  end
  def w1g(x) do
    with {:ok, a} <- g(x) do a else _ when x > 1 -> 0 end
  end
  def w2e(x) do
    with {:ok, a} <- g(x), {:ok, b} <- h(a) do
      b
    else
      {:error, e} -> e
      :nope -> 0
    end
  end
  def wg(x) do
    with {:ok, a} when is_integer(a) <- g(x) do a end
  end
  def wb(x) do
    with {:ok, a} <- g(x), b = a + 1 do b end
  end
  def wk(x), do: with({:ok, a} <- g(x), do: a, else: (_ -> 0))
  def wke(x), do: with({:ok, a} <- g(x), do: a, else: ({:error, e} -> e))
  def r1(xs) do
    for x <- xs, reduce: 0 do
      acc -> acc + x
    end
  end
  def rk1(xs), do: for(x <- xs, reduce: 0, do: (acc -> acc + x))
  def r2(xs) do
    for x <- xs, reduce: 0 do
      0 -> x
      acc -> acc + x
    end
  end
  def r2d(xs) do
    for x <- xs, reduce: 0 do
      0 -> x
      _ -> 1
    end
  end
  def rk2(xs), do: for(x <- xs, reduce: 0, do: (0 -> x; acc -> acc + x))
  def fp(xs), do: for(x <- xs, do: x)
  def ff(xs), do: for(x <- xs, x > 1, do: x)
  def fg(xs), do: for(x when x > 1 <- xs, do: x)
  def fb(s), do: for(<<c <- s>>, do: c)
  def c(x) do
    case g(x) do
      {:ok, a} -> a
      _ -> 0
    end
  end
end
";
        let expected: &[(&str, u64, u64, u64)] = &[
            ("w1", 2, 2, 1),
            ("w2", 3, 3, 2),
            ("w2d", 3, 3, 2),
            ("w1e", 3, 3, 2),
            ("w1n", 3, 3, 2),
            ("w1g", 4, 4, 3),
            ("w2e", 5, 4, 4),
            ("wg", 3, 3, 2),
            ("wb", 2, 2, 1),
            ("wk", 2, 2, 1),
            ("wke", 3, 3, 2),
            ("r1", 2, 2, 0),
            ("rk1", 2, 2, 0),
            ("r2", 3, 2, 1),
            ("r2d", 3, 2, 1),
            ("rk2", 3, 2, 1),
            ("fp", 2, 2, 0),
            ("ff", 2, 2, 1),
            ("fg", 2, 2, 1),
            ("fb", 2, 2, 0),
            ("c", 2, 2, 1),
        ];
        check_func_space_only::<ElixirParser, _>(
            src,
            "foo.ex",
            &[Metric::Cyclomatic, Metric::Abc],
            |space| {
                let module = &space.spaces[0];
                assert_eq!(module.spaces.len(), expected.len(), "fixture members");
                for &(name, cyclomatic, modified, conditions) in expected {
                    let f = child_space(module, name);
                    let measured = (
                        f.metrics.cyclomatic.cyclomatic(),
                        f.metrics.cyclomatic.cyclomatic_modified(),
                        f.metrics.abc.conditions(),
                    );
                    assert_eq!(measured, (cyclomatic, modified, conditions), "{name}");
                }
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_match_expression() {
        // Each `match_conditional_expression` arm (+1) but the default arm
        // does NOT add a branch (mirrors switch/case Java semantics).
        check_metrics::<PhpParser>(
            "<?php
            function color(string $c): int {
                return match ($c) {
                    'red' => 1,
                    'green' => 2,
                    'blue' => 3,
                    default => 0,
                };
            }",
            "foo.php",
            |metric| {
                // unit (+1) + function (+1) + 3 match arms (+3) = sum 5.
                // Default arm contributes 0.
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: PHP switch with 3 cases collapses to 1.
    #[cfg(feature = "php")]
    #[test]
    fn php_switch_modified() {
        check_metrics::<PhpParser>(
            "<?php
            function describe(int $n): string {
                switch ($n) {
                    case 1:
                        return 'one';
                    case 2:
                        return 'two';
                    case 3:
                        return 'three';
                    default:
                        return 'other';
                }
            }",
            "foo.php",
            |metric| {
                // standard: unit(1) + fn(1) + 3 cases = sum 5, max 4.
                // modified: unit(1) + fn(1) + switch(1) = sum 3, max 2.
                // default does NOT add a branch.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_null_coalescing() {
        // `??` and `??=` are each one short-circuit decision (#231).
        // Tree-sitter emits `??=` as the single token `QMARKQMARKEQ`, so it
        // is matched independently from the binary `??`.
        check_metrics::<PhpParser>(
            "<?php
            function pick($x, $y) {
                $a = $x ?? $y;
                $a ??= 0;
                return $a;
            }",
            "foo.php",
            |metric| {
                // unit (+1) + function (+1) + ?? (+1) + ??= (+1) = sum 4.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_nullsafe_operator_436() {
        // Issue #436: PHP's nullsafe operator `?->` is a short-circuit
        // decision point, mirroring the JS/TS/C# treatment of `?.`
        // (#281). The `QMARKDASHGT` token fires once per operator across
        // both property access (`$a?->b`) and method call (`$a?->c()`),
        // and once per link in a chain. Here: one access + one chained
        // call (`$a?->b?->c()`) = +2 for that statement.
        check_metrics::<PhpParser>(
            "<?php
            function read($a) {
                return $a?->b?->c();
            }",
            "foo.php",
            |metric| {
                // unit(1) + fn(base 1 + ?-> 1 + ?-> 1) = sum 4, max 3.
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                // modified mirrors standard: each `?->` is both-metric.
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 3);
            },
        );
    }

    /// Modified CCN: nested switches contribute one decision each, not one
    /// total — the outer container does not absorb the inner one.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_nested_switch_modified() {
        check_metrics::<CppParser>(
            "void f() {
                 switch (x) {
                     case 1:
                         switch (y) {
                             case 10: break;
                             case 20: break;
                         }
                         break;
                     case 2: break;
                 }
             }",
            "foo.c",
            |metric| {
                // standard: unit(1) + fn(1) + 4 cases  = 6
                // modified: unit(1) + fn(1) + 2 switches = 4
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    /// Modified CCN: nested Rust matches each contribute one container.
    /// Bare `_ =>` arms are skipped.
    #[cfg(feature = "rust")]
    #[test]
    fn rust_nested_match_modified() {
        check_metrics::<RustParser>(
            "fn f(x: u8) -> u8 {
                 match x {
                     1 => match x {
                         10 => 1,
                         20 => 2,
                         _ => 0,
                     },
                     _ => 0,
                 }
             }",
            "foo.rs",
            |metric| {
                // standard: unit(1) + fn(1) + 3 arms (1,10,20; both _ skipped) = 5
                // modified: unit(1) + fn(1) + 2 matches  = 4
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    /// Pin the empty-switch edge case: standard counts no arms (0) while
    /// modified still counts the container (+1) per Lizard's `-m`.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_empty_switch_modified() {
        check_metrics::<CppParser>("void f() { switch (x) {} }", "foo.c", |metric| {
            // standard: unit(1) + fn(1) + 0 cases    = 2
            // modified: unit(1) + fn(1) + 1 switch   = 3
            insta::assert_json_snapshot!(
                metric.cyclomatic,
                @r#"
            {
              "sum": 2,
              "value": 1,
              "average": 2.0,
              "min": 1,
              "max": 1,
              "modified": {
                "sum": 3,
                "value": 1,
                "average": 3.0,
                "min": 1,
                "max": 2
              }
            }
            "#
            );
        });
    }

    /// Two nested `for` loops contribute +1 each on top of the function and
    /// unit decisions.  No condition expressions, so `&&` / `||` do not fire.
    #[cfg(feature = "c")]
    #[test]
    fn c_nested_loops() {
        check_metrics::<CParser>(
            "void f() {
                 for (int i = 0; i < 10; ++i) {     // +1
                     for (int j = 0; j < 10; ++j) { // +1
                         g(i, j);
                     }
                 }
             }",
            "foo.c",
            |metric| {
                // standard: unit(1) + fn(1) + 2 for = 4
                // modified: identical (no switch container, no extra arms)
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 4);
                assert_eq!(s.cyclomatic_max(), 3);
                assert_eq!(s.cyclomatic_modified_sum(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    /// C++ `do { … } while (…)` contributes exactly +1 to both
    /// standard and modified CCN. The +1 comes from the `while`
    /// keyword token inside the do-statement (`Cpp::While`), which the
    /// C-family macro already counts. Adding the `DoStatement`
    /// statement node would double-count — see the macro doc comment
    /// and issue #284. This test pins the correct keyword-driven
    /// count.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_do_statement_counts_in_cyclomatic() {
        check_metrics::<CppParser>(
            "void f() {
                 int i = 0;
                 do {           // +1 (via inner `while` keyword)
                     ++i;
                 } while (i < 10);
             }",
            "foo.cpp",
            |metric| {
                // standard: unit(1) + fn(1) + do(1) = 3
                // modified: identical (no switch, no extra arms)
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 3);
                assert_eq!(s.cyclomatic_max(), 2);
                assert_eq!(s.cyclomatic_modified_sum(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 3,
                  "value": 1,
                  "average": 3.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// C++ range-based `for (auto x : xs)` contributes exactly +1 to
    /// both standard and modified CCN — the `for` keyword token
    /// (`Cpp::For`) fires inside the `ForRangeLoop` node just like
    /// inside a classic `ForStatement`. Pinning this prevents
    /// reintroducing the double-count from issue #284's incorrect fix
    /// proposal.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_for_range_loop_counts_in_cyclomatic() {
        check_metrics::<CppParser>(
            "void f(std::vector<int> xs) {
                 for (auto x : xs) {   // +1 (via `for` keyword)
                     g(x);
                 }
             }",
            "foo.cpp",
            |metric| {
                // standard: unit(1) + fn(1) + for-range(1) = 3
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 3);
                assert_eq!(s.cyclomatic_max(), 2);
                assert_eq!(s.cyclomatic_modified_sum(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 3,
                  "value": 1,
                  "average": 3.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// `(source, twin, token, count, decisions)`: `source` carries
    /// `count` of the short-circuit `token` (an index into the kind
    /// array the test passes), and `twin` is the same source with that
    /// token respelled as one that never scores. `source` must score
    /// exactly `decisions` more than `twin`, so the expected value comes
    /// from the twin rather than from the gate under test (#1525).
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    const CPP_SHORT_CIRCUIT_ROWS: [(&str, &str, usize, usize, u64); 38] = [
        // Reference declarators, one per production that spells `&&`.
        ("void f(int&& x) {}", "void f(int& x) {}", 0, 1, 0),
        ("void f(int&&) {}", "void f(int&) {}", 0, 1, 0),
        (
            "template<class... T> void f(T&&... a) {}",
            "template<class... T> void f(T&... a) {}",
            0,
            1,
            0,
        ),
        ("struct S { int&& m; };", "struct S { int& m; };", 0, 1, 0),
        ("typedef int&& R;", "typedef int& R;", 0, 1, 0),
        ("T&& f() { return g(); }", "T& f() { return g(); }", 0, 1, 0),
        (
            "void f() { auto&& y = z; }",
            "void f() { auto& y = z; }",
            0,
            1,
            0,
        ),
        // Ref-qualifier.
        (
            "struct S { void g() && {} };",
            "struct S { void g() & {} };",
            0,
            1,
            0,
        ),
        // Overload names, in all four spellings.
        ("bool operator&&(S, S);", "bool operator+(S, S);", 0, 1, 0),
        ("bool operator||(S, S);", "bool operator+(S, S);", 1, 1, 0),
        ("bool operator and(S, S);", "bool operator+(S, S);", 2, 1, 0),
        ("bool operator or(S, S);", "bool operator+(S, S);", 3, 1, 0),
        // Requires-clause constraints: compile-time, no runtime branch.
        (
            "template<class T> requires A<T> && B<T> void f() {}",
            "template<class T> requires A<T> void f() {}",
            0,
            1,
            0,
        ),
        (
            "template<class T> requires A<T> || B<T> void f() {}",
            "template<class T> requires A<T> void f() {}",
            1,
            1,
            0,
        ),
        (
            "template<class T> requires A<T> and B<T> void f() {}",
            "template<class T> requires A<T> void f() {}",
            2,
            1,
            0,
        ),
        (
            "template<class T> requires A<T> or B<T> void f() {}",
            "template<class T> requires A<T> void f() {}",
            3,
            1,
            0,
        ),
        (
            "template<class T> void f() requires A<T> && B<T> {}",
            "template<class T> void f() requires A<T> {}",
            0,
            1,
            0,
        ),
        // Parenthesised, the same constraints parse as ordinary
        // expressions, nested, negated or folded; a requires-expression's
        // requirements are never evaluated, and a nested requirement is
        // another clause. None branches, a lambda written in one included:
        // C++ lambdas open no space of their own (#1533).
        (
            "template<class T> requires (A<T> && B<T>) void f() {}",
            "template<class T> requires (A<T>) void f() {}",
            0,
            1,
            0,
        ),
        (
            "template<class T> requires (A<T> && B<T>) && C<T> void f() {}",
            "template<class T> requires (A<T>) and C<T> void f() {}",
            0,
            2,
            0,
        ),
        (
            "template<class T> void f() requires (A<T> || (B<T> && C<T>)) {}",
            "template<class T> void f() requires (A<T> || (B<T>)) {}",
            0,
            1,
            0,
        ),
        (
            "template<class T> requires (!(A<T> && B<T>)) void f() {}",
            "template<class T> requires (!(A<T> & B<T>)) void f() {}",
            0,
            1,
            0,
        ),
        (
            "template<class... T> requires (... && A<T>) void f() {}",
            "template<class... T> requires (A<T>) void f() {}",
            0,
            1,
            0,
        ),
        (
            "template<class T> requires requires(T a) { a && a; } void f() {}",
            "template<class T> requires requires(T a) { a & a; } void f() {}",
            0,
            1,
            0,
        ),
        (
            "template<class T> concept C = requires(T a) { requires (A<T> && B<T>); a || a; };",
            "template<class T> concept C = requires(T a) { requires (A<T> & B<T>); a | a; };",
            0,
            1,
            0,
        ),
        (
            "template<class T> requires ([] { return X<T> && Y<T>; }()) void f() {}",
            "template<class T> requires ([] { return X<T> & Y<T>; }()) void f() {}",
            0,
            1,
            0,
        ),
        // The clause ends where it ends: the body after it still counts,
        // whichever side of the declarator the clause is written on, and
        // when it starts on the clause's last byte.
        (
            "template<class T> bool f(int a) requires (A<T> && B<T>){ return a && a; }",
            "template<class T> bool f(int a) requires (A<T> & B<T>){ return a & a; }",
            0,
            2,
            1,
        ),
        (
            "template<class T> requires (A<T> && B<T>) bool f(int a) { return a && a; }",
            "template<class T> requires (A<T> & B<T>) bool f(int a) { return a & a; }",
            0,
            2,
            1,
        ),
        // Applied operators: one decision each.
        (
            "bool f(int a, int b) { return a && b; }",
            "bool f(int a, int b) { return a & b; }",
            0,
            1,
            1,
        ),
        (
            "bool f(int a, int b) { return a || b; }",
            "bool f(int a, int b) { return a | b; }",
            1,
            1,
            1,
        ),
        (
            "bool f(int a, int b) { return a and b; }",
            "bool f(int a, int b) { return a & b; }",
            2,
            1,
            1,
        ),
        (
            "bool f(int a, int b) { return a or b; }",
            "bool f(int a, int b) { return a | b; }",
            3,
            1,
            1,
        ),
        (
            "template<class... T> bool f(T... a) { return (... && a); }",
            "template<class... T> bool f(T... a) { return (... & a); }",
            0,
            1,
            1,
        ),
        // A binary fold spells its one operator twice.
        (
            "template<class... T> bool f(T... a) { return (0 || ... || a); }",
            "template<class... T> bool f(T... a) { return (0 | ... | a); }",
            1,
            2,
            1,
        ),
        ("#if A && B\n#endif", "#if A & B\n#endif", 0, 1, 1),
        // Any other compile-time `binary_expression` still counts, as
        // `if constexpr` does: `static_assert` and a concept body.
        // An operator written right against a requires-expression's
        // closing brace starts on its end byte and lies outside it.
        (
            "void f() { static_assert(requires { a; }&& x); }",
            "void f() { static_assert(requires { a; }& x); }",
            0,
            1,
            1,
        ),
        (
            "void f() { static_assert(A && B); }",
            "void f() { static_assert(A & B); }",
            0,
            1,
            1,
        ),
        (
            "template<class T> concept C = A<T> && B<T>;",
            "template<class T> concept C = A<T> & B<T>;",
            0,
            1,
            1,
        ),
        // An rvalue-reference parameter beside an applied operator.
        (
            "auto l = [](int&& x) { return x && y; };",
            "auto l = [](int& x) { return x & y; };",
            0,
            2,
            1,
        ),
    ];

    /// `[standard, modified]` cyclomatic sums of `src`'s root space.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    fn cyclomatic_sums<P: MetricSuite>(src: &str) -> [u64; 2] {
        let out = std::cell::Cell::new([0; 2]);
        check_func_space_only::<P, _>(src, "foo.cpp", &[Metric::Cyclomatic], |space| {
            let s = &space.metrics.cyclomatic;
            out.set([s.cyclomatic_sum(), s.cyclomatic_modified_sum()]);
        });
        out.get()
    }

    /// `kinds` is `[&&, ||, and, or]` in the grammar under test.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    fn assert_cpp_short_circuit_counts_only_where_applied<P: MetricSuite>(kinds: [u16; 4]) {
        for (source, twin, token, count, decisions) in CPP_SHORT_CIRCUIT_ROWS {
            assert_fixture_spells::<P>(source, "foo.cpp", &[(kinds[token], count, source)]);
            assert_fixture_spells::<P>(twin, "foo.cpp", &[(kinds[token], 0, twin)]);
            let [twin_standard, twin_modified] = cyclomatic_sums::<P>(twin);
            assert_eq!(
                cyclomatic_sums::<P>(source),
                [twin_standard + decisions, twin_modified + decisions],
                "`{source}` against its twin `{twin}`"
            );
        }
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_short_circuit_counts_only_where_applied() {
        assert_cpp_short_circuit_counts_only_where_applied::<CppParser>([
            Cpp::AMPAMP as u16,
            Cpp::PIPEPIPE as u16,
            Cpp::And as u16,
            Cpp::Or as u16,
        ]);
    }

    // Mozcpp owns no file extension, so this is the only coverage its
    // gated arm has.
    #[cfg(feature = "mozcpp")]
    #[test]
    fn mozcpp_short_circuit_counts_only_where_applied() {
        assert_cpp_short_circuit_counts_only_where_applied::<MozcppParser>([
            Mozcpp::AMPAMP as u16,
            Mozcpp::PIPEPIPE as u16,
            Mozcpp::And as u16,
            Mozcpp::Or as u16,
        ]);
    }

    /// Decision kinds through the dedicated `LANG::C` grammar (#721):
    /// `if`, `for`, `while`, `case`, and the `&&` short-circuit each
    /// add +1; `switch` adds only to the modified count. C has no
    /// `catch`, so the hand-written `Cyclomatic for CCode` impl omits
    /// the exception arm the C++ macro carries.
    #[cfg(feature = "c")]
    #[test]
    fn c_grammar_decision_kinds_count_in_cyclomatic() {
        check_metrics::<CParser>(
            "int f(int a, int b) {
                 if (a && b) {          // +1 if, +1 &&
                     return 1;
                 }
                 for (int i = 0; i < a; ++i) {  // +1 for
                     b += i;
                 }
                 switch (b) {           // +1 modified only
                     case 0: return 0;  // +1 case
                     default: return b;
                 }
             }",
            "foo.c",
            |metric| {
                let s = &metric.cyclomatic;
                // standard: unit(1) + fn(1) + if(1) + &&(1) + for(1) + case(1) = 6
                assert_eq!(s.cyclomatic_sum(), 6);
                // modified: `case` adds to standard only and `switch` to
                // modified only, so they balance — base(2) + if + && + for
                // + switch(1) = 6.
                assert_eq!(s.cyclomatic_modified_sum(), 6);
            },
        );
    }

    /// `?:` ternary is matched by `Cpp::ConditionalExpression` in the
    /// C-family macro and contributes +1 standard *and* +1 modified.
    /// Two nested ternaries in one expression therefore add 2 to each.
    #[cfg(feature = "c")]
    #[test]
    fn c_ternary_chain() {
        check_metrics::<CParser>(
            "int f(int a, int b, int c) {
                 return a > 0 ? a : (b > 0 ? b : c); // +2 ternaries (?: each)
             }",
            "foo.c",
            |metric| {
                // standard: unit(1) + fn(1) + 2 ?: = 4
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 4);
                assert_eq!(s.cyclomatic_max(), 3);
                assert_eq!(s.cyclomatic_modified_sum(), 4);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    /// Short-circuit `&&` / `||` chains each contribute +1 — every binary
    /// operator token in the chain is a separate decision (Lizard parity).
    #[cfg(feature = "c")]
    #[test]
    fn c_short_circuit_chain() {
        check_metrics::<CParser>(
            "int f(int a, int b, int c, int d) {
                 if (a && b || c && d) {            // 3 logical ops + 1 if = 4
                     return 1;
                 }
                 return 0;
             }",
            "foo.c",
            |metric| {
                // standard: unit(1) + fn(1) + if(1) + && (2) + || (1) = 6
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 6);
                assert_eq!(s.cyclomatic_max(), 5);
                assert_eq!(s.cyclomatic_modified_sum(), 6);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 6,
                    "value": 1,
                    "average": 6.0,
                    "min": 1,
                    "max": 5
                  }
                }
                "#
                );
            },
        );
    }

    /// Switch with intentional fall-through: every `case` adds +1 standard
    /// regardless of whether the arm `break`s.  Modified collapses all three
    /// arms into one switch container.
    #[cfg(feature = "c")]
    #[test]
    fn c_switch_fallthrough() {
        check_metrics::<CParser>(
            "int f(int x) {
                 int r = 0;
                 switch (x) {
                     case 1:                // +1
                     case 2:                // +1
                         r = 10;
                         break;
                     case 3:                // +1
                         r = 20;
                         break;
                 }
                 return r;
             }",
            "foo.c",
            |metric| {
                // standard: unit(1) + fn(1) + 3 cases = 5
                // modified: unit(1) + fn(1) + 1 switch container = 3
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 5);
                assert_eq!(s.cyclomatic_modified_sum(), 3);
                assert!(s.cyclomatic_modified_sum() < s.cyclomatic_sum());
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// `goto` is not a recognised decision keyword in the C-family macro
    /// (only `If | For | While | Catch | ConditionalExpression | && | ||`
    /// add complexity, plus `Case` / `SwitchStatement`).  The label and the
    /// `goto` jump are control-flow, but the metric deliberately mirrors
    /// Lizard, which also does not count `goto`.  This test pins that
    /// decision so a future change that adds `Cpp::GotoStatement` to the
    /// macro fires here first.
    #[cfg(feature = "c")]
    #[test]
    fn c_goto_not_counted() {
        check_metrics::<CParser>(
            "int f(int n) {
                 int i = 0;
             retry:
                 if (i < n) {     // +1
                     ++i;
                     goto retry;  // ignored
                 }
                 return i;
             }",
            "foo.c",
            |metric| {
                // standard: unit(1) + fn(1) + if(1) = 3
                // goto/label add nothing.
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_sum(), 3);
                assert_eq!(s.cyclomatic_modified_sum(), 3);
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 3,
                  "value": 1,
                  "average": 3.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Direct accessor coverage: assert the modified-CCN getters return
    /// the values we expect from a known fixture, bypassing the JSON
    /// serializer.  Modified must never exceed standard for non-degenerate
    /// inputs (a switch with at least one arm).
    #[cfg(feature = "rust")]
    #[test]
    fn cyclomatic_modified_accessors() {
        check_metrics::<RustParser>(
            "fn f(x: u8) -> u8 {
                 match x {
                     1 => 1,
                     2 => 2,
                     _ => 0,
                 }
             }",
            "foo.rs",
            |metric| {
                // standard sum: unit(1) + fn(1 + 2 arms, _ skipped) = 4
                // modified sum: unit(1) + fn(1 + 1 MatchExpr)       = 3
                let s = &metric.cyclomatic;
                assert_eq!(s.cyclomatic_modified_sum(), 3);
                assert_eq!(s.cyclomatic_modified_min(), 1);
                assert_eq!(s.cyclomatic_modified_max(), 2);
                // #512: divisor is the single function space, not the two
                // total spaces (unit + fn), so 3 / 1 = 3.0 (was 3 / 2 = 1.5).
                assert_eq!(s.cyclomatic_modified_average(), 3.0);
                assert!(s.cyclomatic_modified_sum() <= s.cyclomatic_sum());
            },
        );
    }

    /// Bare `_ =>` wildcard is not counted (matches C-family `default:`).
    #[cfg(feature = "rust")]
    #[test]
    fn rust_wildcard_only_match() {
        check_metrics::<RustParser>(
            "fn f(x: u8) -> &'static str {
                 match x {
                     _ => \"fallback\",
                 }
             }",
            "foo.rs",
            |metric| {
                // standard: unit(1) + fn(1) + 0 arms (bare wildcard skipped) = 2
                // modified: unit(1) + fn(1) + MatchExpr(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 2,
                  "value": 1,
                  "average": 2.0,
                  "min": 1,
                  "max": 1,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Wildcard arm plus explicit arms: only explicit arms count.
    #[cfg(feature = "rust")]
    #[test]
    fn rust_wildcard_plus_explicit_arms() {
        check_metrics::<RustParser>(
            "fn f(x: u8) -> &'static str {
                 match x {
                     1 => \"one\",
                     2 => \"two\",
                     3 => \"three\",
                     _ => \"other\",
                 }
             }",
            "foo.rs",
            |metric| {
                // standard: unit(1) + fn(1) + 3 arms (1,2,3) = 5
                // modified: unit(1) + fn(1) + MatchExpr(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// `Some(_)` is NOT a bare wildcard — still counts.
    #[cfg(feature = "rust")]
    #[test]
    fn rust_some_wildcard_still_counts() {
        check_metrics::<RustParser>(
            "fn f(x: Option<u8>) -> u8 {
                 match x {
                     Some(_) => 1,
                     None => 0,
                 }
             }",
            "foo.rs",
            |metric| {
                // standard: unit(1) + fn(1) + 2 arms (Some(_), None) = 4
                // modified: unit(1) + fn(1) + MatchExpr(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Tuple pattern `(_, x)` is NOT a bare wildcard — still counts.
    #[cfg(feature = "rust")]
    #[test]
    fn rust_tuple_wildcard_still_counts() {
        check_metrics::<RustParser>(
            "fn f(x: (u8, u8)) -> u8 {
                 match x {
                     (0, y) => y,
                     (_, y) => y + 1,
                 }
             }",
            "foo.rs",
            |metric| {
                // standard: unit(1) + fn(1) + 2 arms = 4
                // modified: unit(1) + fn(1) + MatchExpr(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// `_ if guard` is NOT a bare wildcard — still counts.
    /// The `if` keyword inside the guard also contributes +1 standard/modified.
    #[cfg(feature = "rust")]
    #[test]
    fn rust_guarded_wildcard_still_counts() {
        check_metrics::<RustParser>(
            "fn f(x: u8) -> &'static str {
                 match x {
                     1 => \"one\",
                     _ if x > 100 => \"big\",
                     _ => \"other\",
                 }
             }",
            "foo.rs",
            |metric| {
                // standard: unit(1) + fn(1 + arm(1) + guarded_arm(1) + if_kw(1)) = 5
                // modified: unit(1) + fn(1 + MatchExpr(1) + if_kw(1)) = 4
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 4,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    // A `let`-`else` binds or diverges: one decision (#1542). Each row is
    // one `fn`, read as (cyclomatic, modified, abc.conditions).
    //
    // Expected values come from the twins, not the fix (measured,
    // `--no-config`): `il` (`if let`) and `m` (`match` with a bare `_`)
    // both score 2/2/1, so `le` must as well. `ctrl` is the same body
    // without the `else`, at 1/1/0. `le2` pays once per `let`-`else`, 3/3/2.
    // `ie` pins that the shared `else` token of an `if … else` still pays
    // nothing extra (2/2, with ABC's slot for `x` and the `else`). `lp`
    // nests one in a `for`: 1 + `for` + `let`-`else` = 3, where ABC counts
    // only the `else`, because it does not score loops. `cl`'s closure
    // opens its own space, which pays the decision itself.
    #[cfg(feature = "rust")]
    #[test]
    fn rust_let_else_is_one_decision_1542() {
        let src = "fn le(x: i32) -> i32 {
    let Ok(a) = g(x) else { return 0 };
    a
}
fn ctrl(x: i32) -> i32 {
    let a = g(x);
    a
}
fn il(x: i32) -> i32 {
    if let Ok(a) = g(x) { return a; }
    0
}
fn m(x: i32) -> i32 {
    match g(x) { Ok(a) => a, _ => 0 }
}
fn le2(x: i32) -> i32 {
    let Ok(a) = g(x) else { return 0 };
    let Some(b) = h(a) else { return 1 };
    b
}
fn ie(x: bool) -> i32 {
    if x { 1 } else { 0 }
}
fn lp(xs: &[Option<i32>]) {
    for y in xs {
        let Some(a) = y else { continue };
        k(a);
    }
}
fn cl() {
    let c = |y: Option<i32>| {
        let Some(a) = y else { return 0 };
        a
    };
    k(c);
}
";
        let expected: &[(&str, u64, u64, u64)] = &[
            ("le", 2, 2, 1),
            ("ctrl", 1, 1, 0),
            ("il", 2, 2, 1),
            ("m", 2, 2, 1),
            ("le2", 3, 3, 2),
            ("ie", 2, 2, 2),
            ("lp", 3, 3, 1),
            ("cl", 1, 1, 0),
        ];
        check_func_space_only::<RustParser, _>(
            src,
            "foo.rs",
            &[Metric::Cyclomatic, Metric::Abc],
            |space| {
                assert_eq!(space.spaces.len(), expected.len(), "fixture members");
                for &(name, cyclomatic, modified, conditions) in expected {
                    let f = child_space(&space, name);
                    let measured = (
                        f.metrics.cyclomatic.cyclomatic(),
                        f.metrics.cyclomatic.cyclomatic_modified(),
                        f.metrics.abc.conditions(),
                    );
                    assert_eq!(measured, (cyclomatic, modified, conditions), "{name}");
                }
                let closure = child_space(&space, "cl");
                assert_eq!(closure.spaces.len(), 1, "cl's closure space");
                let closure = &closure.spaces[0].metrics;
                assert_eq!(
                    (
                        closure.cyclomatic.cyclomatic(),
                        closure.cyclomatic.cyclomatic_modified(),
                        closure.abc.conditions(),
                    ),
                    (2, 2, 1),
                    "cl's closure"
                );
            },
        );
    }

    /// Regression #107: empty case…esac has no arms, so standard adds 0 and
    /// modified adds 1 (the container).
    #[cfg(feature = "bash")]
    #[test]
    fn bash_case_empty() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    case $1 in
    esac
}",
            "foo.sh",
            |metric| {
                // standard: unit(1) + fn(1) + 0 arms = 2
                // modified: unit(1) + fn(1) + case_stmt(1) = 3
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 2,
                  "value": 1,
                  "average": 2.0,
                  "min": 1,
                  "max": 1,
                  "modified": {
                    "sum": 3,
                    "value": 1,
                    "average": 3.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#
                );
            },
        );
    }

    /// Regression #107: nested case…esac — each container contributes to
    /// modified independently, and each arm contributes to standard.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_nested_case() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    case $1 in
        a)
            case $2 in
                x) echo ax ;;
                y) echo ay ;;
            esac
            ;;
        b) echo b ;;
    esac
}",
            "foo.sh",
            |metric| {
                // standard: unit(1) + fn(1) + outer arms(a,b = 2) + inner arms(x,y = 2) = 6
                // modified: unit(1) + fn(1) + 2 case_stmts = 4
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 6,
                  "value": 1,
                  "average": 6.0,
                  "min": 1,
                  "max": 5,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    /// Nested matches with wildcards: only bare `_` skipped at each level.
    #[cfg(feature = "rust")]
    #[test]
    fn rust_nested_match_with_wildcards() {
        check_metrics::<RustParser>(
            "fn f(x: u8, y: u8) -> &'static str {
                 match x {
                     1 => match y {
                         1 => \"one-one\",
                         _ => \"one-other\",
                     },
                     _ => \"other\",
                 }
             }",
            "foo.rs",
            |metric| {
                // standard: unit(1) + fn(1) + outer arm 1(+1) + inner arm 1(+1)
                //           + outer bare _(0) + inner bare _(0) = 4
                // modified: unit(1) + fn(1) + 2 MatchExpr(+2) = 4
                insta::assert_json_snapshot!(
                    metric.cyclomatic,
                    @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_nested_branches() {
        // expected: unit(1) + method(1 + `if` + `while`) = 1 + 3 = 4
        // standard CCN.
        check_metrics::<RubyParser>(
            "def foo(a)\n  if a > 0\n    while a > 0\n      a -= 1\n    end\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_case_when_arms() {
        // Each `when` arm adds standard CCN; the `case` container is
        // counted ONCE in modified CCN.
        // expected: standard = unit(1) + method(1 + 3 when) = 5;
        // modified = unit(1) + method(1 + 1 case) = 3.
        check_metrics::<RubyParser>(
            "def foo(x)\n  case x\n  when 1 then 'one'\n  when 2 then 'two'\n  when 3 then 'three'\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_case_match_default_only_arm_not_counted() {
        // Regression for #977: a `case … in` whose only arm is the bare
        // wildcard `in _` (no guard) is a default-only match and must add
        // NO standard decision — mirroring Rust's bare-`_` `MatchArm` and
        // Python's `case _:` filters. The `case_match` container still
        // contributes one modified decision.
        // expected per function: standard = 1 (base) + 0 = 1;
        // modified = 1 (base) + 1 (case_match) = 2.
        check_metrics::<RubyParser>(
            "def f(x)\n  case x\n  in _ then :default\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 1);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 2);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_case_match_in_arms_and_guard_counted() {
        // Regression for #977: a non-wildcard `in 1` arm and a guarded
        // wildcard `in _ if x > 0` arm each add one standard decision,
        // while the trailing bare `in _` default arm adds none. The
        // `case_match` container stays a modified-only decision, but the
        // guard itself is a decision in both tiers (#1454): nothing
        // collapses it the way the container collapses its arms.
        // expected per function: standard = 1 (base) + `in 1` + `in _ if`
        // + the `if` guard = 4; modified = 1 (base) + 1 (case_match) +
        // the guard = 3.
        check_metrics::<RubyParser>(
            "def f(x)\n  case x\n  in 1 then :one\n  in _ if x > 0 then :positive\n  in _ then :default\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 3);
            },
        );
    }

    /// Cross-language parity for default-arm filtering (#977): a
    /// match/switch whose single arm is the bare wildcard must score the
    /// same per-function cyclomatic across Ruby `case … in`, Rust `match`,
    /// and Python `match`. Each language's catch-all arm is its
    /// `default:`-equivalent and adds no standard decision, so every
    /// function is just its base 1. Per-language snapshot suites pin each
    /// history but cannot catch the cross-language disagreement this
    /// guards (lesson 11; #106 was exactly a wildcard-counting drift).
    #[cfg(all(feature = "python", feature = "ruby", feature = "rust"))]
    #[test]
    fn cyclomatic_bare_wildcard_default_arm_cross_language() {
        check_metrics::<RubyParser>(
            "def f(x)\n  case x\n  in _ then :default\n  end\nend\n",
            "foo.rb",
            |m| assert_eq!(m.cyclomatic.cyclomatic_max(), 1, "ruby"),
        );
        check_metrics::<RustParser>(
            "fn f(x: i32) -> i32 {\n    match x {\n        _ => 0,\n    }\n}\n",
            "foo.rs",
            |m| assert_eq!(m.cyclomatic.cyclomatic_max(), 1, "rust"),
        );
        check_metrics::<PythonParser>(
            "def f(x):\n    match x:\n        case _:\n            return 0\n",
            "foo.py",
            |m| assert_eq!(m.cyclomatic.cyclomatic_max(), 1, "python"),
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_ternary_conditional() {
        // Ruby's `cond ? a : b` parses as `Conditional` and counts as a
        // branch in both standard and modified CCN.
        // expected: standard = unit(1) + method(1 + 1) = 3.
        check_metrics::<RubyParser>(
            "def foo(x)\n  x.positive? ? :pos : :nonpos\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_and_or_keywords() {
        // Word-form `and` / `or` are distinct grammar kinds from
        // `&&` / `||` and must each contribute one decision point.
        // expected: standard = unit(1) + method(1 + and + or) = 4.
        check_metrics::<RubyParser>(
            "def foo(a, b, c)\n  a and b or c\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
            },
        );
    }

    /// Cross-language parity for cyclomatic: an `if/else if/else` chain
    /// of three arms must produce the same per-function (max-space)
    /// cyclomatic score across Ruby, Rust, and Java. Per-language
    /// snapshot tests pin each language's history but cannot detect
    /// drift on the same logical construct — lesson 11
    /// (`docs/development/lessons_learned.md`) catalogues real
    /// incidents (#106 Rust-vs-C-family wildcard counting; #107 Bash
    /// double-counting case containers) that survived per-language
    /// suites for years. `cyclomatic_max()` is the function-level
    /// cyclomatic and is independent of unit/class space stacking, so
    /// the comparison is meaningful across languages with different
    /// space hierarchies.
    ///
    /// Expected per function: 1 (base) + 1 (`if`) + 1 (`else if`) = 3.
    /// The `else` arm is unconditional and does not contribute. Each
    /// language asserts the literal 3.0 in its own closure so a future
    /// drift in any single language fails THIS test (and only this
    /// test), making cross-language disagreement visible at a glance.
    #[cfg(all(feature = "java", feature = "ruby", feature = "rust"))]
    #[test]
    fn cyclomatic_if_elseif_else_chain_cross_language() {
        check_metrics::<RubyParser>(
            "def classify(x)\n  if x > 0\n    :pos\n  elsif x < 0\n    :neg\n  else\n    :zero\n  end\nend\n",
            "foo.rb",
            |m| {
                assert_eq!(m.cyclomatic.cyclomatic_max(), 3, "ruby");
            },
        );
        check_metrics::<RustParser>(
            "fn classify(x: i32) -> &'static str {\n    if x > 0 { \"pos\" } else if x < 0 { \"neg\" } else { \"zero\" }\n}\n",
            "foo.rs",
            |m| {
                assert_eq!(m.cyclomatic.cyclomatic_max(), 3, "rust");
            },
        );
        check_metrics::<JavaParser>(
            "class C {\n    String classify(int x) {\n        if (x > 0) return \"pos\";\n        else if (x < 0) return \"neg\";\n        else return \"zero\";\n    }\n}\n",
            "Foo.java",
            |m| {
                assert_eq!(m.cyclomatic.cyclomatic_max(), 3, "java");
            },
        );
    }

    /// Parity gate for the `impl_cyclomatic_java_like!` macro (#300):
    /// every decision kind shared by Java and Groovy must produce the
    /// same per-function cyclomatic score for a common decision-rich
    /// method body. Dropping a kind from the macro body (e.g.,
    /// removing `For` or `TernaryExpression`) would fail BOTH language
    /// assertions; dropping a kind from only one invocation would fail
    /// only that language's assertion.
    ///
    /// The body intentionally exercises every shared kind:
    /// `If`, `For`, `While`, `Catch`, `TernaryExpression`, `AMPAMP`,
    /// `PIPEPIPE`, plus a `switch` with two `Case` arms (one is the
    /// default and contributes nothing under standard CCN). Expected
    /// per-function: 1 (base) + if + for + while + catch + ternary +
    /// && + || + 2 cases = 10 (standard).
    ///
    /// Modified CCN is asserted in parallel: the multi-kind arm
    /// bumps both counters, and `Switch` (one keyword token per
    /// switch construct) replaces the standard CCN's two `Case`
    /// arms. Expected modified per-function: 1 (base) + if + for +
    /// while + catch + ternary + && + || + switch = 9. Without the
    /// modified assertion a mutation that drops
    /// `stats.cyclomatic_modified += 1.` from any shared arm (or
    /// drops the `Switch` arm entirely) would pass.
    #[cfg(all(feature = "groovy", feature = "java"))]
    #[test]
    fn cyclomatic_java_groovy_parity_300() {
        #[cfg(any(feature = "groovy", feature = "java"))]
        const JAVA_SRC: &str = "class C {\n\
            int decide(int x, int y, int[] xs) {\n\
                int r = 0;\n\
                if (x > 0 && y > 0) r = 1;\n\
                for (int i = 0; i < 3; i++) r++;\n\
                while (x > 0) { x--; r++; }\n\
                try { r += xs[0]; } catch (Exception e) { r = -1; }\n\
                r = (x > 0 || y < 0) ? r : -r;\n\
                switch (x) { case 1: r++; break; case 2: r--; break; default: break; }\n\
                return r;\n\
            }\n\
        }\n";
        #[cfg(any(feature = "groovy", feature = "java"))]
        const GROOVY_SRC: &str = "class C {\n\
            int decide(int x, int y, int[] xs) {\n\
                int r = 0\n\
                if (x > 0 && y > 0) r = 1\n\
                for (int i = 0; i < 3; i++) r++\n\
                while (x > 0) { x--; r++ }\n\
                try { r += xs[0] } catch (Exception e) { r = -1 }\n\
                r = (x > 0 || y < 0) ? r : -r\n\
                switch (x) { case 1: r++; break; case 2: r--; break; default: break }\n\
                return r\n\
            }\n\
        }\n";
        check_metrics::<JavaParser>(JAVA_SRC, "Foo.java", |m| {
            assert_eq!(m.cyclomatic.cyclomatic_max(), 10, "java parity");
            assert_eq!(
                m.cyclomatic.cyclomatic_modified_max(),
                9,
                "java modified parity"
            );
        });
        check_metrics::<GroovyParser>(GROOVY_SRC, "foo.groovy", |m| {
            assert_eq!(m.cyclomatic.cyclomatic_max(), 10, "groovy parity");
            assert_eq!(
                m.cyclomatic.cyclomatic_modified_max(),
                9,
                "groovy modified parity"
            );
        });
    }

    /// Groovy-only delta in `impl_cyclomatic_java_like!`: the `Assert`
    /// extra-kind invocation must keep Groovy's `assert` branching at
    /// +1 while Java does not count anything for an identical-looking
    /// construct (Java has no `assert`-as-branch token; its `assert`
    /// statement is grammar-distinct and not in this macro's arm).
    /// Dropping `[Assert]` from the Groovy invocation would fail this
    /// test.
    #[cfg(feature = "groovy")]
    #[test]
    fn cyclomatic_groovy_assert_arm_300() {
        check_metrics::<GroovyParser>("void check(int x) { assert x > 0 }", "foo.groovy", |m| {
            // unit(1) + fn(1) + assert(1) = 3
            assert_eq!(m.cyclomatic.cyclomatic_sum(), 3, "groovy assert sum");
            assert_eq!(m.cyclomatic.cyclomatic_max(), 2, "groovy assert max");
            // Assert contributes to BOTH standard and modified CCN, so the
            // fn-level modified score is also base(1) + assert(1) = 2.
            // Without this assertion, a mutation that dropped
            // `stats.cyclomatic_modified += 1.` from the multi-kind arm
            // would pass.
            assert_eq!(
                m.cyclomatic.cyclomatic_modified_max(),
                2,
                "groovy assert modified max"
            );
        });
    }

    /// Regression for issue #246: Groovy's Elvis operator `?:` is a
    /// short-circuit nullish operator that introduces a branch — each
    /// occurrence in a chain adds +1 to cyclomatic complexity. The
    /// dekobon Groovy grammar models Elvis as a distinct
    /// `elvis_expression` node with a real `QMARKCOLON` token, so the
    /// `impl_cyclomatic_java_like!(GroovyCode, Groovy, [Assert,
    /// QMARKCOLON])` invocation picks it up directly.
    #[cfg(feature = "groovy")]
    #[test]
    fn cyclomatic_groovy_elvis_chain_246() {
        check_metrics::<GroovyParser>(
            "def pick(a, b, c) { return a ?: b ?: c }",
            "foo.groovy",
            |m| {
                // unit(1) + fn(1) + two `?:` short-circuits(2) = 4
                assert_eq!(m.cyclomatic.cyclomatic_sum(), 4, "groovy elvis sum");
                assert_eq!(m.cyclomatic.cyclomatic_max(), 3, "groovy elvis max");
                assert_eq!(
                    m.cyclomatic.cyclomatic_modified_max(),
                    3,
                    "groovy elvis modified max"
                );
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_rescue_modifier() {
        // Postfix `x rescue y` parses as a `RescueModifier` node that
        // wraps the recovery clause. Both wrapper and clause fire the
        // cyclomatic branch arm; the method body therefore contributes
        // +2 to its space.
        // expected: standard = unit(1) + method(1 + 1) = 3.
        check_metrics::<RubyParser>(
            "def foo\n  parse(x) rescue nil\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                insta::assert_json_snapshot!(metric.cyclomatic);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_safe_navigation_cyclomatic() {
        // Issue #452: Ruby's safe-navigation `&.` (AMPDOT) is a
        // short-circuit decision point per link, mirroring the
        // Kotlin/PHP/JS/C# treatment of `?.` (#281). The chain
        // `a&.b&.c` adds +2 to both standard and modified CCN.
        check_metrics::<RubyParser>("def read(a); a&.b&.c; end\n", "foo.rb", |metric| {
            // unit(1) + method(base 1 + &. 1 + &. 1) = sum 4, max 3.
            let s = &metric.cyclomatic;
            assert_eq!(s.cyclomatic_sum(), 4);
            assert_eq!(s.cyclomatic_max(), 3);
            assert_eq!(s.cyclomatic_modified_sum(), 4);
            assert_eq!(s.cyclomatic_modified_max(), 3);
        });
    }

    /// Nested control flow inside a `when` handler (the iRules floor case,
    /// mirroring `rust_1_level_nesting`). unit(1) + handler(base 1 + while 1
    /// + if 1 = 3) = sum 4, max 3.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_1_level_nesting() {
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST {
    while { $x > 0 } {
        if { $x > 10 } {
            set x [expr { $x - 1 }]
        }
    }
}
",
            "foo.irule",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    /// iRules `switch` is a dedicated node: each non-`default` arm is one
    /// standard decision; the whole `switch` is one modified decision.
    /// standard: unit(1) + handler(base 1 + 2 arms) = 4; modified:
    /// unit(1) + handler(base 1 + switch 1) = 3. The `default` arm is free.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_switch() {
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST {
    switch [HTTP::host] {
        a { pool pool_a }
        b { pool pool_b }
        default { pool pool_d }
    }
}
",
            "foo.irule",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_max(), 2);
            },
        );
    }

    /// The keyword logical operators `and` / `or` are decision points just
    /// like `&&` / `||` (iRules-specific — Tcl's grammar has no keyword
    /// forms). unit(1) + handler(base 1 + if 1 + and 1 + or 1 = 4) = 5.
    /// Guards edge case #3 / the keyword-operator arms in the impl.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_and_or_keywords() {
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST {
    if { $a and $b or $c } {
        log local0. \"hit\"
    }
}
",
            "foo.irule",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 5);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 4);
            },
        );
    }

    /// String comparison operators (`contains`, `eq`, `matches`, …) are
    /// operators, NOT branches. Two of them appear here, joined by one `||`;
    /// only the `if` and the `||` are decisions: unit(1) + handler(base 1 +
    /// if 1 + `||` 1 = 3) = 4. The two string operators add 0. Guards edge
    /// case #4: if each string operator were wrongly counted as a branch the
    /// sum would be 6, so the divergence (4 vs 6) is unambiguous — it cannot
    /// be confused with the `if`/`||` simply being miscounted.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_string_ops_not_branches() {
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST {
    if { [HTTP::uri] contains \"admin\" || [HTTP::host] eq \"x\" } {
        log local0. \"hit\"
    }
}
",
            "foo.irule",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 4);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 3);
            },
        );
    }

    /// A ternary `? :` in an `expr` is one decision; the bare `>` comparison
    /// is not. unit(1) + handler(base 1 + ternary 1 = 2) = 3.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_ternary() {
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST {
    set y [expr { $x > 0 ? 1 : 0 }]
}
",
            "foo.irule",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
            },
        );
    }

    /// `dict for` iterates and is a loop decision; the non-looping
    /// `dict update` / `dict with` are excluded by the impl.
    /// unit(1) + handler(base 1 + dict_for 1 = 2) = 3.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_dict_for_loop() {
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST {
    dict for { k v } $d {
        log local0. $k
    }
}
",
            "foo.irule",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_modified_sum(), 3);
                assert_eq!(metric.cyclomatic.cyclomatic_max(), 2);
            },
        );
    }

    /// Objective-C floor: an `if` nested inside a `for` inside a
    /// `method_definition` held by an `@implementation`. The
    /// `@implementation` opens a Class space (+1). Standard CCN =
    /// unit(1) + class(1) + method(1) + for(1) + if(1) = 5.
    #[cfg(feature = "objc")]
    #[test]
    fn objc_nested_control() {
        check_metrics::<ObjcParser>(
            "@implementation Foo
- (void)bar:(NSArray *)arr {
    for (int i = 0; i < 10; ++i) {
        if (i > 5) {
            [self use:i];
        }
    }
}
@end
",
            "foo.m",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum() as u32, 5);
                insta::assert_json_snapshot!(metric.cyclomatic, @r#"
                {
                  "sum": 5,
                  "value": 1,
                  "average": 5.0,
                  "min": 1,
                  "max": 3,
                  "modified": {
                    "sum": 5,
                    "value": 1,
                    "average": 5.0,
                    "min": 1,
                    "max": 3
                  }
                }
                "#);
            },
        );
    }

    /// Objective-C `@try { } @catch { }`: the `catch_clause` node adds
    /// one decision point. Standard CCN = unit(1) + class(1) + method(1)
    /// + catch(1) = 4.
    #[cfg(feature = "objc")]
    #[test]
    fn objc_try_catch() {
        check_metrics::<ObjcParser>(
            "@implementation Foo
- (void)bar {
    @try {
        [self doWork];
    } @catch (NSException *e) {
        [self log:e];
    }
}
@end
",
            "foo.m",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum() as u32, 4);
                insta::assert_json_snapshot!(metric.cyclomatic, @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#);
            },
        );
    }

    /// Objective-C fast enumeration `for (id x in arr)` folds into a
    /// `for_statement` whose `for` keyword fires once, exactly like a
    /// classic `for`. Standard CCN = unit(1) + class(1) + method(1) +
    /// for(1) = 4.
    #[cfg(feature = "objc")]
    #[test]
    fn objc_fast_enumeration() {
        check_metrics::<ObjcParser>(
            "@implementation Foo
- (void)bar:(NSArray *)arr {
    for (id x in arr) {
        [self use:x];
    }
}
@end
",
            "foo.m",
            |metric| {
                assert_eq!(metric.cyclomatic.cyclomatic_sum() as u32, 4);
                insta::assert_json_snapshot!(metric.cyclomatic, @r#"
                {
                  "sum": 4,
                  "value": 1,
                  "average": 4.0,
                  "min": 1,
                  "max": 2,
                  "modified": {
                    "sum": 4,
                    "value": 1,
                    "average": 4.0,
                    "min": 1,
                    "max": 2
                  }
                }
                "#);
            },
        );
    }
}