big_code_analysis/metrics/

abc.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::enum_glob_use,
    clippy::too_many_lines,
    clippy::wildcard_imports
)]
// 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::*;

mod bash;
mod c;
mod cpp;
mod csharp;
mod elixir;
mod go;
mod groovy;
mod irules;
mod java;
mod js_family;
mod kotlin;
mod lua;
mod mozcpp;
mod objc;
mod perl;
mod php;
mod python;
mod ruby;
mod rust;
#[cfg(test)]
mod slot_pays_tests;
mod tcl;

/// The `ABC` metric.
///
/// The `ABC` metric measures the size of a source code by counting
/// the number of Assignments (`A`), Branches (`B`) and Conditions (`C`).
/// The metric defines an ABC score as a vector of three elements (`<A,B,C>`).
/// The ABC score can be represented by its individual components (`A`, `B` and `C`)
/// or by the magnitude of the vector (`|<A,B,C>| = sqrt(A^2 + B^2 + C^2)`).
///
/// Official paper and definition:
///
/// Fitzpatrick, Jerry (1997). "Applying the ABC metric to C, C++ and Java". C++ Report.
///
/// <https://www.softwarerenovation.com/Articles.aspx>
///
/// # Cross-language `&&` / `||` policy
///
/// Per Fitzpatrick's conditional-operator rule (Rule 5 in Figure 2
/// for C and Figure 4 for Java; Rule 7 in Figure 3 for C++), only
/// comparison operators (`==`, `!=`, `<=`, `>=`, `<`, `>`) and a
/// paper-defined keyword set (`else`, `case`, `default`, `?`, plus
/// `try` / `catch` for C++ and Java) contribute to the condition
/// count. Per-language `impl Abc` blocks narrow this set where
/// appropriate — e.g., C++/Rust/Go/Python exclude `default` since
/// it falls through unconditionally (matching the Rust `_ =>` and
/// Java `default:` precedent). The short-
/// circuit logical operators `&&` and `||` (and per-language
/// equivalents — Python's `and` / `or`, Lua's `and` / `or`, Tcl's
/// `&&` / `||`, Perl's `&&` / `||` / `//` / `and` / `or`)
/// are deliberately **not** counted on their own. The paper's
/// worked Listing 2 annotates `(am >= 0 && am <= 0xF) ? '/' : 'C'`
/// as `accc` — three conditions for `>=`, `<=`, `?`, zero for
/// `&&`.
///
/// Fitzpatrick's Rule 7 (Figure 3, C++) / Rule 9 (Figure 4, Java) —
/// "Add one to the condition count for each unary conditional
/// expression" — instead counts each non-comparison operand of a
/// `&&` / `||` chain once. The paper's worked example for this
/// rule is `if (x || y) printf("test failure\n");`, annotated:
/// "there are two unary conditions since both `x` and `y` are
/// tested as conditional expressions" (so `||` contributes zero,
/// `x` contributes one, `y` contributes one, and `printf(...)`
/// contributes one branch). The walker machinery for this —
/// modelled on the former `java_count_unary_conditions` /
/// `java_inspect_container` — is present today for Java, Groovy,
/// C#, Rust, Go, JavaScript, TypeScript, TSX, Mozjs, PHP, C++,
/// Python, Perl, Lua, Tcl, iRules, Kotlin, Ruby, and Elixir. So
/// `if (a && b)` reports 2 conditions across this set, matching
/// the paper. Bash is the lone exception: its `&&` / `||` are
/// command-list separators rather than boolean-expression operands
/// with named leaf operands, so Fitzpatrick's Rule 9 does not map
/// onto its grammar and the walker is deliberately not wired.
///
/// This policy is paper-faithful and deviates from RuboCop's
/// `Metrics/AbcSize` (which counts `and` / `or` as conditions
/// directly) while matching `StepicOrg/abcmeter` and
/// `eoinnoble/python-abc`. The book's *ABC counting rules*
/// section reproduces the rule tables, a per-language deviation
/// table, and worked examples — see the chapter at
/// <https://dekobon.github.io/big-code-analysis/metrics.html#abc>.
///
/// # Cross-language empty-`for`-condition policy
///
/// `for (;;)` — and every other spelling that omits the test slot
/// (`for (init; ; update)`, Go's bare `for {}`) — counts **zero**
/// conditions. Nothing in Fitzpatrick's condition rules attributes a
/// count to a `for` keyword: they count conditional operators and
/// unary conditions that are *present*, and an omitted test is not a
/// decision. Most languages get this for free: `*_walk_for_statement`
/// asks `for_statement` for its `condition` field and an empty header
/// has none. Two do not, and neither needs a special case either —
/// the JS family fills the slot with an `empty_statement`, which is
/// not a boolean terminal and not a paren / `!` wrapper, so it falls
/// through; and Go, whose `for_statement` exposes no `condition` field
/// at all, locates the header slot structurally and finds only the
/// body. Before #1276 Java and Groovy alone disagreed, counting the
/// `;` or `)` that landed in a positional child slot as a
/// vacuously-true condition.
///
/// See issue #395 for the Phase-1 cross-language policy
/// alignment, #403 for the Phase-2 unary-conditional walker
/// fan-out, #404 for the Phase-3 book documentation, #557
/// for the Kotlin / Ruby / Elixir walker wiring, and #1276 for the
/// `for`-header condition slot.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct Stats {
    pub(super) assignments: f64,
    assignments_sum: f64,
    assignments_min: f64,
    assignments_max: f64,
    pub(super) branches: f64,
    branches_sum: f64,
    branches_min: f64,
    branches_max: f64,
    pub(super) conditions: f64,
    conditions_sum: f64,
    conditions_min: f64,
    conditions_max: f64,
    space_count: usize,
    constraint: ConstraintReach,
}

impl Default for Stats {
    fn default() -> Self {
        Self {
            assignments: 0.,
            assignments_sum: 0.,
            assignments_min: f64::MAX,
            assignments_max: 0.,
            branches: 0.,
            branches_sum: 0.,
            branches_min: f64::MAX,
            branches_max: 0.,
            conditions: 0.,
            conditions_sum: 0.,
            conditions_min: f64::MAX,
            conditions_max: 0.,
            space_count: 1,
            constraint: ConstraintReach::default(),
        }
    }
}

impl fmt::Display for Stats {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "assignments: {}, branches: {}, conditions: {}, magnitude: {}, \
            assignments_average: {}, branches_average: {}, conditions_average: {}, \
            assignments_min: {}, assignments_max: {}, \
            branches_min: {}, branches_max: {}, \
            conditions_min: {}, conditions_max: {}",
            self.assignments_sum(),
            self.branches_sum(),
            self.conditions_sum(),
            self.magnitude_sum(),
            self.assignments_average(),
            self.branches_average(),
            self.conditions_average(),
            self.assignments_min(),
            self.assignments_max(),
            self.branches_min(),
            self.branches_max(),
            self.conditions_min(),
            self.conditions_max()
        )
    }
}

impl Stats {
    /// Merges a second `Abc` metric into the first one.
    pub fn merge(&mut self, other: &Stats) {
        // Calculates minimum and maximum values
        self.assignments_min = self.assignments_min.min(other.assignments_min);
        self.assignments_max = self.assignments_max.max(other.assignments_max);
        self.branches_min = self.branches_min.min(other.branches_min);
        self.branches_max = self.branches_max.max(other.branches_max);
        self.conditions_min = self.conditions_min.min(other.conditions_min);
        self.conditions_max = self.conditions_max.max(other.conditions_max);

        self.assignments_sum += other.assignments_sum;
        self.branches_sum += other.branches_sum;
        self.conditions_sum += other.conditions_sum;

        self.space_count += other.space_count;
    }

    /// Returns the `Abc` assignments metric value.
    #[must_use]
    pub fn assignments(&self) -> u64 {
        self.assignments as u64
    }

    /// Returns the `Abc` assignments sum metric value.
    #[must_use]
    pub fn assignments_sum(&self) -> u64 {
        self.assignments_sum as u64
    }

    /// Returns the `Abc` assignments average value.
    ///
    /// This value is computed dividing the `Abc`
    /// assignments value for the number of spaces.
    #[must_use]
    pub fn assignments_average(&self) -> f64 {
        crate::metrics::average(self.assignments_sum() as f64, self.space_count)
    }

    /// Returns the `Abc` assignments minimum value.
    ///
    /// Collapses the `f64::MAX` sentinel that `Stats::default()` plants
    /// into `assignments_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 assignments_min(&self) -> u64 {
        if self.assignments_min == f64::MAX {
            0
        } else {
            self.assignments_min as u64
        }
    }

    /// Returns the `Abc` assignments maximum value.
    #[must_use]
    pub fn assignments_max(&self) -> u64 {
        self.assignments_max as u64
    }

    /// Returns the `Abc` branches metric value.
    #[must_use]
    pub fn branches(&self) -> u64 {
        self.branches as u64
    }

    /// Returns the `Abc` branches sum metric value.
    #[must_use]
    pub fn branches_sum(&self) -> u64 {
        self.branches_sum as u64
    }

    /// Returns the `Abc` branches average value.
    ///
    /// This value is computed dividing the `Abc`
    /// branches value for the number of spaces.
    #[must_use]
    pub fn branches_average(&self) -> f64 {
        crate::metrics::average(self.branches_sum() as f64, self.space_count)
    }

    /// Returns the `Abc` branches minimum value.
    ///
    /// Same `f64::MAX` sentinel collapse as `assignments_min`.
    #[allow(clippy::float_cmp)]
    #[must_use]
    pub fn branches_min(&self) -> u64 {
        if self.branches_min == f64::MAX {
            0
        } else {
            self.branches_min as u64
        }
    }

    /// Returns the `Abc` branches maximum value.
    #[must_use]
    pub fn branches_max(&self) -> u64 {
        self.branches_max as u64
    }

    /// Returns the `Abc` conditions metric value.
    #[must_use]
    pub fn conditions(&self) -> u64 {
        self.conditions as u64
    }

    /// Returns the `Abc` conditions sum metric value.
    #[must_use]
    pub fn conditions_sum(&self) -> u64 {
        self.conditions_sum as u64
    }

    /// Returns the `Abc` conditions average value.
    ///
    /// This value is computed dividing the `Abc`
    /// conditions value for the number of spaces.
    #[must_use]
    pub fn conditions_average(&self) -> f64 {
        crate::metrics::average(self.conditions_sum() as f64, self.space_count)
    }

    /// Returns the `Abc` conditions minimum value.
    ///
    /// Same `f64::MAX` sentinel collapse as `assignments_min`.
    #[allow(clippy::float_cmp)]
    #[must_use]
    pub fn conditions_min(&self) -> u64 {
        if self.conditions_min == f64::MAX {
            0
        } else {
            self.conditions_min as u64
        }
    }

    /// Returns the `Abc` conditions maximum value.
    #[must_use]
    pub fn conditions_max(&self) -> u64 {
        self.conditions_max as u64
    }

    /// Returns the `Abc` magnitude metric value.
    #[must_use]
    pub fn magnitude(&self) -> f64 {
        (self.assignments.powi(2) + self.branches.powi(2) + self.conditions.powi(2)).sqrt()
    }

    /// Returns the `Abc` magnitude sum metric value.
    #[must_use]
    pub fn magnitude_sum(&self) -> f64 {
        (self.assignments_sum.powi(2) + self.branches_sum.powi(2) + self.conditions_sum.powi(2))
            .sqrt()
    }

    #[inline]
    pub(crate) fn compute_sum(&mut self) {
        self.assignments_sum += self.assignments;
        self.branches_sum += self.branches;
        self.conditions_sum += self.conditions;
    }

    #[inline]
    pub(crate) fn compute_minmax(&mut self) {
        self.assignments_min = self.assignments_min.min(self.assignments);
        self.assignments_max = self.assignments_max.max(self.assignments);
        self.branches_min = self.branches_min.min(self.branches);
        self.branches_max = self.branches_max.max(self.branches);
        self.conditions_min = self.conditions_min.min(self.conditions);
        self.conditions_max = self.conditions_max.max(self.conditions);
        self.compute_sum();
    }
}

#[doc(hidden)]
/// Per-language computation of the ABC metric.
pub(crate) trait Abc
where
    Self: Checker,
{
    /// Walk `node` and update `stats` with this metric for the language
    /// implementing the trait.
    ///
    /// `code` is the source bytes underlying the parsed tree. Most
    /// languages ignore it: assignments, branches, and conditions all
    /// surface as distinct grammar productions and a `kind_id()` match
    /// is enough. Elixir is the exception — `case` / `cond` / `if` /
    /// `with` / guard `when` arms surface as `Call` nodes whose keyword
    /// target lives only in the source text. Matching the `Cyclomatic`
    /// / `Halstead` / `Exit` / `Cognitive` pattern keeps the signature
    /// uniform.
    ///
    /// `ancestors` is the chain the walker descended through. Nearly
    /// every language classifies some token by what encloses it: `<`
    /// and `>` are comparisons only under a binary expression (a type
    /// -argument list otherwise), and `&&` / `||` reach their operands
    /// through the enclosing chain node. Reaching that parent with
    /// [`Node::parent`] costs `O(depth)` per node (#1096). The
    /// condition-slot walkers take *their* parent as an argument
    /// instead, because the caller descended from it.
    fn compute<'a>(
        node: &Node<'a>,
        code: &'a [u8],
        ancestors: Ancestors<'a, '_>,
        stats: &mut Stats,
    );
}

// Shared Phase-2B helper (issue #403): walk every named child of an
// expression-list-style wrapper (Go's `expression_list`, Lua's
// `expression_list`) and route each through a language-specific
// classifier. Used for `return value1, value2, ...` arms where the
// values live one level below the return statement under a list
// wrapper. The classifier receives only named children so that
// `,` / `;` / `(` / `)` tokens never reach it, plus `list` itself as
// the child's parent — the container classifiers seed their
// boolean-context flag from the parent kind, and reaching it with
// `Node::parent` would cost `O(depth)` per node (#1096).
pub(super) fn for_each_named_child(
    list: &Node,
    conditions: &mut f64,
    f: fn(&Node, &Node, &mut f64),
) {
    let mut cursor = list.cursor();
    if cursor.goto_first_child() {
        loop {
            let child = cursor.node();
            if child.is_named() {
                f(&child, list, conditions);
            }
            if !cursor.goto_next_sibling() {
                break;
            }
        }
    }
}

// The operand a single-operand wrapper holds — `(…)`, a negation, a
// `return` — read as its first named child that is not a tree-sitter
// `extra`. A positional `child(1)` read assumes nothing sits between the
// opening token and the operand, and a comment can sit anywhere: `(/*c*/
// b)` handed the comment to the peel, which declined it, and the
// condition scored zero (#1455). `is_named` alone is not enough either,
// because extras are named.
pub(super) fn wrapped_operand<'a>(node: &Node<'a>) -> Option<Node<'a>> {
    node.children().find(is_operand)
}

// The last operand of `node`, by the same rule as `wrapped_operand`: for
// a wrapper that evaluates to its final element (a Perl list in scalar
// context, a Ruby statement sequence) and for a slot that follows an
// unnamed one (a C# declarator's initialiser after its name).
pub(super) fn last_operand<'a>(node: &Node<'a>) -> Option<Node<'a>> {
    node.children().filter(is_operand).last()
}

// Whether `child` can occupy an operand slot: named, and not an `extra`.
// The `extra` flag is read off the tree-sitter node because the `Node`
// wrapper exposes no accessor for it.
pub(super) fn is_operand(child: &Node) -> bool {
    child.is_named() && !child.as_tree_sitter().is_extra()
}

// One step of a language's value peel: the operand a wrapper evaluates
// to — `(…)`, a negation, an assignment's value, a type cast — and
// whether that wrapper itself proves the operand boolean (only a
// negation does). `None` for anything that is not a wrapper.
pub(super) type PeelStep<'a> = fn(&Node<'a>) -> Option<(Node<'a>, bool)>;

// Every wrapper `step` descends, peeled: the operand they evaluate to,
// and whether any layer proved it boolean.
pub(super) fn peel<'a>(node: &Node<'a>, step: PeelStep<'a>) -> (Node<'a>, bool) {
    let mut node = *node;
    let mut proves_boolean = false;
    while let Some((operand, proves)) = step(&node) {
        proves_boolean |= proves;
        node = operand;
    }
    (node, proves_boolean)
}

// Scores one boolean slot — an `if` / `while` predicate, a ternary
// condition, a guard, an operand of an `&&` / `||` chain — as
// Fitzpatrick's "unary conditional expression" (Rule 6 / 7 / 9): one
// condition, unless another arm already charged the same decision.
// `scores_itself` says whether the peeled predicate is a comparison,
// chain, ternary or other construct some arm of the language's
// `compute` already counts, and must agree with those arms exactly: a
// kind listed here and counted nowhere leaves its slot at zero, and one
// counted there but missing here pays twice.
//
// The slots once paid only for an occupant that peeled down to a fixed
// list of terminal kinds, so every kind missing from the list — `-x`,
// `x + 1`, `this`, `*p`, a lambda — scored 0 against a cyclomatic
// decision of 1 (#1520, #1526). Asking whether the decision is already
// paid for covers every kind the grammar can put in the slot, including
// ones a future grammar adds. Each language supplies only its peel step
// and `scores_itself`, so the rule has this one home (lesson 59).
pub(super) fn count_boolean_slot<'a>(
    slot: &Node<'a>,
    step: PeelStep<'a>,
    scores_itself: fn(&Node<'a>) -> bool,
    conditions: &mut f64,
) {
    if !scores_itself(&peel(slot, step).0) {
        *conditions += 1.;
    }
}

// The same rule for an operand outside a boolean slot — a call
// argument, a `return` value, a ternary branch. Those are type-free, so
// the operand is a slot only when the peel proves it boolean through a
// negation layer: `f(!x)` scores one, `f(x)` and `f(-x)` none. A
// negation is a slot whatever it negates (`!this`, `!-x`), exactly as
// Ruby's negated ternary branch is (#1529).
pub(super) fn count_negated_operand<'a>(
    operand: &Node<'a>,
    step: PeelStep<'a>,
    scores_itself: fn(&Node<'a>) -> bool,
    conditions: &mut f64,
) {
    let (node, proves_boolean) = peel(operand, step);
    if proves_boolean && !scores_itself(&node) {
        *conditions += 1.;
    }
}

// A language's scorer for one operand: its `count_boolean_slot` or
// `count_negated_operand` wrapper.
pub(super) type OperandScorer = fn(&Node, &mut f64);

// Fitzpatrick Rule 9 for a chain whose grammar names its two operands
// `left` and `right`: each is scored by `score`. Read by field rather
// than as every operand child, so a comment beside the operator — a
// named child too — does not pay. The caller owns the gate deciding
// that `chain` is a chain at all.
pub(super) fn count_field_operands(chain: &Node, score: OperandScorer, conditions: &mut f64) {
    for field in ["left", "right"] {
        if let Some(operand) = chain.child_by_field_name(field) {
            score(&operand, conditions);
        }
    }
}

// Each operand child of `list` — an argument list, a `return` value
// list, a chain whose grammar names no operand field — scored by
// `score`. `is_operand` keeps punctuation and comments out.
pub(super) fn count_each_operand(list: &Node, score: OperandScorer, conditions: &mut f64) {
    for operand in list.children().filter(is_operand) {
        score(&operand, conditions);
    }
}

// Default no-op `Abc` impls. Audited in #188; the matrix below
// records the rationale for every entry so the no-op default is a
// deliberate choice, not scaffolding leftover.
//
// Real defaults (the language has no construct ABC measures, so the
// metric is genuinely 0):
//   - PreprocCode, CcommentCode: no executable code (comments /
//     preprocessor lines only).
implement_metric_trait!(Abc, PreprocCode, CcommentCode);

#[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;
    use crate::test_support::{
        assert_fixture_spells, ast_has_kind_id, check_func_space_only_shim,
        check_metrics_only_shim, child_space, metrics_verbatim,
    };
    // Hand-written, not derived. A trait is used through its methods, so
    // nothing in a test body names `ParserTrait` and
    // `check-test-lang-gates.py` derives no gate for an import at all,
    // so an ungated one stays compiled into builds that never call
    // `<Lang>Parser::new`. These seven are the languages that do; a new
    // `XParser::new` test in this module needs its feature added here,
    // and the leg that lacks it says so as an unused import.
    #[cfg(any(
        feature = "csharp",
        feature = "groovy",
        feature = "kotlin",
        feature = "php",
        feature = "ruby",
        feature = "rust",
        feature = "typescript",
    ))]
    use crate::traits::ParserTrait;

    use super::*;

    check_metrics_only_shim!(check_metrics, Abc);
    // Every `check_func_space` caller in this module is an ABC-versus-
    // cyclomatic parity test (`abc.conditions() == cyclomatic() - 1` on
    // the same space), so the func-space shim carries Cyclomatic too.
    check_func_space_only_shim!(check_func_space, Abc, Cyclomatic);

    /// `abc.conditions_sum()` of `src` under a walk restricted to ABC
    /// and the metrics it resolves, for the cross-language parity tests
    /// that compare one construct across sibling grammars.
    /// `check_metrics` expands to a plain `fn` and so cannot close over
    /// a reference value; this can. Restricted rather than
    /// `MetricsOptions::default()` per `metrics_verbatim`'s own doc
    /// (#1127).
    #[cfg(any(
        feature = "c",
        feature = "cpp",
        feature = "csharp",
        feature = "go",
        feature = "java",
        feature = "javascript",
        feature = "mozcpp",
        feature = "mozjs",
        feature = "objc",
        feature = "perl",
        feature = "typescript",
    ))]
    fn abc_conditions(lang: LANG, src: &str) -> u64 {
        metrics_verbatim(
            lang,
            src.as_bytes(),
            MetricsOptions::default().with_only(&[crate::Metric::Abc]),
        )
        .abc
        .conditions_sum()
    }

    // Recurse to the innermost function space and assert the invariant
    // named above there. `conditions()` is that one space's own count,
    // so it pairs with `cyclomatic()` and never `cyclomatic_sum()`,
    // which folds in a base of 1 per nested space.
    #[cfg(any(
        feature = "cpp",
        feature = "csharp",
        feature = "groovy",
        feature = "java",
        feature = "perl",
        feature = "php",
        feature = "typescript",
    ))]
    fn assert_deepest_conditions_match_cyclomatic(space: &crate::FuncSpace, expected: u64) {
        let mut deepest = space;
        while let Some(child) = deepest.spaces.last() {
            deepest = child;
        }
        let decisions = deepest.metrics.cyclomatic.cyclomatic() - 1;
        assert_eq!(decisions, expected);
        assert_eq!(deepest.metrics.abc.conditions(), decisions);
    }

    // The sibling form of the helper above, for a fixture whose point is
    // that several *different* spellings of one construct agree. The
    // deepest-space walk cannot serve those: it follows `spaces.last()`
    // and so inspects exactly one member, which is the shape #1383's
    // over-count hid behind — a merged root total cannot tell a
    // relational method scoring 2 from the constant control scoring 2.
    #[cfg(any(feature = "csharp", feature = "elixir"))]
    fn assert_every_member_scores(
        container: &crate::FuncSpace,
        members: usize,
        expected: u64,
        why: &str,
    ) {
        // The count is a parameter rather than a `!is_empty()` check so
        // a caller cannot omit it: without it a fixture that lost every
        // member but one still satisfies "every member scores N".
        assert_eq!(
            container.spaces.len(),
            members,
            "member count changed — the fixture moved, not the metric"
        );
        for member in &container.spaces {
            let name = member.name.as_deref().unwrap_or("?");
            assert_eq!(member.metrics.abc.conditions(), expected, "{name}: {why}");
            assert_eq!(
                member.metrics.abc.conditions(),
                member.metrics.cyclomatic.cyclomatic() - 1,
                "{name}: §8 parity with the cyclomatic decision count"
            );
        }
    }

    // The second sibling, for a fixture whose point is that a construct
    // moves a member *off* the value its unguarded control scores.
    // `assert_every_member_scores` cannot serve those: it takes one
    // expected value for the whole container, and every #1422 guard
    // fixture deliberately pairs guarded members with an unguarded
    // control one lower — which is the comparison the test exists to
    // make. Both tiers per member, because a guard is a decision in each
    // and a fix that moved only one of them would satisfy neither claim
    // on its own, and because a member may legitimately sit *above* its
    // decision count — an `else` arm, or a comparison nested inside
    // another comparison, is an ABC condition with no cyclomatic
    // decision behind it (#1421).
    #[cfg(any(
        feature = "csharp",
        feature = "elixir",
        feature = "go",
        feature = "groovy",
        feature = "java",
        feature = "kotlin",
        feature = "perl",
        feature = "python",
        feature = "ruby",
        feature = "rust",
    ))]
    #[track_caller]
    fn assert_members_score(container: &crate::FuncSpace, expected: &[(&str, u64, u64)]) {
        assert_eq!(
            container.spaces.len(),
            expected.len(),
            "member count changed — the fixture moved, not the metric"
        );
        for (name, conditions, cyclomatic) in expected {
            let member = child_space(container, name);
            assert_eq!(
                member.metrics.abc.conditions(),
                *conditions,
                "{name}: abc.conditions"
            );
            assert_eq!(
                member.metrics.cyclomatic.cyclomatic(),
                *cyclomatic,
                "{name}: cyclomatic"
            );
        }
    }

    /// Regression for #227: a `Stats::default()` that never sees an
    /// observation must not leak the `f64::MAX` sentinel for
    /// `assignments_min`, `branches_min`, or `conditions_min`. All
    /// three getters collapse the sentinel to `0.0` so JSON never
    /// emits `1.7976931e308`.
    #[test]
    fn abc_empty_file_min_is_zero() {
        let stats = Stats::default();
        assert_eq!(stats.assignments_min(), 0);
        assert_eq!(stats.branches_min(), 0);
        assert_eq!(stats.conditions_min(), 0);
    }

    // The `EQ` arm of `java_count_token_assignment`: a plain `=` counts
    // unless `java_eq_initializes_final_binding` finds it initialising a
    // `final` binding, whether the declaration is a local or a field.
    #[cfg(feature = "java")]
    #[test]
    fn java_eq_arm_counts_outside_final_declarations() {
        check_metrics::<JavaParser>(
            "class A { void m() { int x = 0; x = 1; x = 2; x = 3; } }",
            "foo.java",
            |metric| {
                // `int x = 0;` is not `final`, so it counts like each
                // `x = N;` that follows.
                assert_eq!(metric.abc.assignments_sum(), 4);
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_eq_arm_skips_final_initializers() {
        check_metrics::<JavaParser>(
            "class A {
                final int X = 1;
                @Deprecated private final int Y = 2;
                void m() { final int Z = 3; }
            }",
            "foo.java",
            |metric| {
                // All three `=` tokens are `final` initializers — the
                // second behind an annotation and an access modifier in
                // the same `modifiers` node — so assignments are 0
                // across all spaces.
                assert_eq!(metric.abc.assignments_sum(), 0);
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_final_initializer_does_not_suppress_the_assignments_inside_it() {
        // The sentinel stack the structural predicate replaced stayed
        // live from `final` to the next `;`, so every `=` nested in the
        // initializer — a lambda body's, an array initializer's — was
        // suppressed with the declarator's own. Java lambdas open no
        // space, so nothing else separated them. Each row names the
        // pre-fix value.
        let cases = [
            ("void m() { final Runnable r = () -> { x = 1; }; }", 1, 0),
            (
                "void m() { final Runnable r = () -> { x = 1; y = 2; }; }",
                2,
                1,
            ),
            ("void m() { final Runnable r = () -> x = 1; }", 1, 0),
            ("void m() { final int[] a = { x = 1 }; }", 1, 0),
            ("private final Runnable f = () -> { x = 1; };", 1, 0),
            // The `;` that closed the leak is the reference: the same
            // body after a `final` local counts as it always did.
            ("void m() { final int q = 1; x = 1; }", 1, 1),
        ];
        let mut ran = 0;
        for (body, expected, before) in cases {
            let src = format!("class K {{ int x, y; {body} }}\n");
            let assignments = metrics_verbatim(
                LANG::Java,
                src.as_bytes(),
                MetricsOptions::default().with_only(&[crate::Metric::Abc]),
            )
            .abc
            .assignments_sum();
            assert_eq!(assignments, expected, "`{body}` (pre-fix {before})");
            ran += 1;
        }
        assert_eq!(ran, cases.len());
        assert!(cases.iter().any(|&(_, now, before)| now != before));
    }

    // Constant declarations are not counted as assignments
    #[cfg(feature = "java")]
    #[test]
    fn java_constant_declarations() {
        check_metrics::<JavaParser>(
            "class A {
                private final int X1 = 0, Y1 = 0;
                public final float PI = 3.14f;
                final static String HELLO = \"Hello,\";
                protected String world = \" world!\";   // +1a
                public float e = 2.718f;                // +1a
                private int x2 = 1, y2 = 2;             // +2a

                void m() {
                    final int Z1 = 0, Z2 = 0, Z3 = 0;
                    final float T = 0.0f;
                    int z1 = 1, z2 = 2, z3 = 3;         // +3a
                    float t = 60.0f;                    // +1a
                }
            }",
            "foo.java",
            |metric| {
                // magnitude: sqrt(64 + 0 + 0) = sqrt(64)
                // space count: 3 (1 unit, 1 class and 1 method)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 8,
                  "branches": 0,
                  "conditions": 0,
                  "magnitude": 8.0,
                  "value": 0.0,
                  "assignments_average": 2.6666666666666665,
                  "branches_average": 0.0,
                  "conditions_average": 0.0,
                  "assignments_min": 0,
                  "assignments_max": 4,
                  "branches_min": 0,
                  "branches_max": 0,
                  "conditions_min": 0,
                  "conditions_max": 0
                }
                "#
                );
            },
        );
    }

    // "In computer science, conditionals (that is, conditional statements, conditional expressions
    // and conditional constructs,) are programming language commands for handling decisions."
    // Source: https://en.wikipedia.org/wiki/Conditional_(computer_programming)
    // According to this definition, boolean expressions that are evaluated to make a decision are considered as conditions
    // Variables, method invocations and true or false values used inside
    // variable declarations and assignment expressions are not counted as conditions
    #[cfg(feature = "java")]
    #[test]
    fn java_declarations_with_conditions() {
        check_metrics::<JavaParser>(
            "
            boolean a = (1 > 2);            // +1a +1c
            boolean b = 3 > 4;              // +1a +1c
            boolean c = (1 > 2) && 3 > 4;   // +1a +2c
            boolean d = b && (x > 5) || c;  // +1a +3c
            boolean e = !d;                 // +1a +1c
            boolean f = ((!false));         // +1a +1c
            boolean g = !(!(true));         // +1a +1c
            boolean h = true;               // +1a
            boolean i = (false);            // +1a
            boolean j = (((((true)))));     // +1a
            boolean k = (((((m())))));      // +1a +1b
            boolean l = (((((!m())))));     // +1a +1b +1c
            boolean m = (!(!((m()))));      // +1a +1b +1c
            List<String> n = null;          // +1a (< and > used for generic types are not counted as conditions)
            ",
            "foo.java",
          |metric| {
                // magnitude: sqrt(196 + 9 + 144) = sqrt(349)
                // space count: 1 (1 unit)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 14,
                  "branches": 3,
                  "conditions": 12,
                  "magnitude": 18.681541692269406,
                  "value": 18.681541692269406,
                  "assignments_average": 14.0,
                  "branches_average": 3.0,
                  "conditions_average": 12.0,
                  "assignments_min": 14,
                  "assignments_max": 14,
                  "branches_min": 3,
                  "branches_max": 3,
                  "conditions_min": 12,
                  "conditions_max": 12
                }
                "#
                );
            },
        );
    }

    // Conditions can be found in assignment expressions
    #[cfg(feature = "java")]
    #[test]
    fn java_assignments_with_conditions() {
        check_metrics::<JavaParser>(
            "
            a = 2 < 1;                  // +1a +1c
            b = (4 >= 3) && 2 <= 1;     // +1a +2c
            c = a || (x != 10) && b;    // +1a +3c
            d = !false;                 // +1a +1c
            e = (!false);               // +1a +1c
            f = !(false);               // +1a +1c
            g = (!(((true))));          // +1a +1c
            h = ((true));               // +1a
            i = !m();                   // +1a +1b +1c
            j = !((m()));               // +1a +1b +1c
            k = (!(m()));               // +1a +1b +1c
            l = ((!(m())));             // +1a +1b +1c
            m = !B.<Integer>m(2);       // +1a +1b +1c
            n = !((B.<Integer>m(4)));   // +1a +1b +1c
            ",
            "foo.java",
            |metric| {
                // magnitude: sqrt(196 + 36 + 256) = sqrt(488)
                // space count: 1 (1 unit)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 14,
                  "branches": 6,
                  "conditions": 16,
                  "magnitude": 22.090722034374522,
                  "value": 22.090722034374522,
                  "assignments_average": 14.0,
                  "branches_average": 6.0,
                  "conditions_average": 16.0,
                  "assignments_min": 14,
                  "assignments_max": 14,
                  "branches_min": 6,
                  "branches_max": 6,
                  "conditions_min": 16,
                  "conditions_max": 16
                }
                "#
                );
            },
        );
    }

    // Conditions can be found in method arguments
    #[cfg(feature = "java")]
    #[test]
    fn java_methods_arguments_with_conditions() {
        check_metrics::<JavaParser>(
            "
            m1(a);                                  // +1b
            m2(a, b);                               // +1b
            m3(true, (false), (((true))));          // +1b
            m3(m1(false), m1(true), m1(false));     // +4b
            m1(!a);                                 // +1b +1c
            m2((((a))), (!b));                      // +1b +1c
            m3(!(a), b, !!!c);                      // +1b +2c
            m3(a, !b, m2(!a, !m2(!b, !m1(!c))));    // +4b +6c
            ",
            "foo.java",
            |metric| {
                // magnitude: sqrt(196 + 36 + 256) = sqrt(488)
                // space count: 1 (1 unit)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 14,
                  "conditions": 10,
                  "magnitude": 17.204650534085253,
                  "value": 17.204650534085253,
                  "assignments_average": 0.0,
                  "branches_average": 14.0,
                  "conditions_average": 10.0,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 14,
                  "branches_max": 14,
                  "conditions_min": 10,
                  "conditions_max": 10
                }
                "#
                );
            },
        );
    }

    // "A unary conditional expression is an implicit condition that uses no relational operators."
    // Source: Fitzpatrick, Jerry (1997). "Applying the ABC metric to C, C++ and Java". C++ Report.
    // https://www.softwarerenovation.com/Articles.aspx (page 5)
    #[cfg(feature = "java")]
    #[test]
    fn java_if_single_conditions() {
        check_metrics::<JavaParser>(
            "
            if ( a < 0 ) {}             // +1c
            if ( ((a != 0)) ) {}        // +1c
            if ( !(a > 0) ) {}          // +1c
            if ( !(((a == 0))) ) {}     // +1c
            if ( b.m1() ) {}            // +1b +1c
            if ( !b.m1() ) {}           // +1b +1c
            if ( !!b.m2() ) {}          // +1b +1c
            if ( (!(b.m1())) ) {}       // +1b +1c
            if ( (!(!b.m1())) ) {}      // +1b +1c
            if ( ((b.m2())) ) {}        // +1b +1c
            if ( ((b.m().m1())) ) {}    // +2b +1c
            if ( c ) {}                 // +1c
            if ( !c ) {}                // +1c
            if ( !!!!!!!!!!c ) {}       // +1c
            if ( (((c))) ) {}           // +1c
            if ( (((!c))) ) {}          // +1c
            if ( ((!(c))) ) {}          // +1c
            if ( true ) {}              // +1c
            if ( !true ) {}             // +1c
            if ( ((false)) ) {}         // +1c
            if ( !(!(false)) ) {}       // +1c
            if ( !!!false ) {}          // +1c
            ",
            "foo.java",
            |metric| {
                // magnitude: sqrt(0 + 64 + 484) = sqrt(548)
                // space count: 1 (1 unit)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 8,
                  "conditions": 22,
                  "magnitude": 23.40939982143925,
                  "value": 23.40939982143925,
                  "assignments_average": 0.0,
                  "branches_average": 8.0,
                  "conditions_average": 22.0,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 8,
                  "branches_max": 8,
                  "conditions_min": 22,
                  "conditions_max": 22
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_if_multiple_conditions() {
        check_metrics::<JavaParser>(
            "
            if ( a || b || c || d ) {}              // +4c
            if ( a || b && c && d ) {}              // +4c
            if ( x < y && a == b ) {}               // +2c
            if ( ((z < (x + y))) ) {}               // +1c
            if ( a || ((((b))) && c) ) {}           // +3c
            if ( a && ((((a == b))) && c) ) {}      // +3c
            if ( a || ((((a == b))) || ((c))) ) {}  // +3c
            if ( x < y && B.m() ) {}                // +1b +2c
            if ( x < y && !(((B.m()))) ) {}         // +1b +2c
            if ( !(x < y) && !B.m() ) {}            // +1b +2c
            if ( !!!(!!!(a)) && B.m() ||            // +1b +2c
                 !B.m() && (((x > 4))) ) {}         // +1b +2c
            ",
            "foo.java",
            |metric| {
                // magnitude: sqrt(0 + 25 + 900) = sqrt(925)
                // space count: 1 (1 unit)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 5,
                  "conditions": 30,
                  "magnitude": 30.4138126514911,
                  "value": 30.4138126514911,
                  "assignments_average": 0.0,
                  "branches_average": 5.0,
                  "conditions_average": 30.0,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 5,
                  "branches_max": 5,
                  "conditions_min": 30,
                  "conditions_max": 30
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_while_and_do_while_conditions() {
        check_metrics::<JavaParser>(
            "
            while ( (!(!(!(a)))) ) {}                   // +1c
            while ( b || 1 > 2 ) {}                     // +2c
            while ( x.m() && (((c))) ) {}               // +1b +2c
            do {} while ( !!!(((!!!a))) );              // +1c
            do {} while ( a || (b && c) );              // +3c
            do {} while ( !x.m() && 1 > 2 || !true );   // +1b +3c
            ",
            "foo.java",
            |metric| {
                // magnitude: sqrt(0 + 4 + 144) = sqrt(148)
                // space count: 1 (1 unit)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 2,
                  "conditions": 12,
                  "magnitude": 12.165525060596439,
                  "value": 12.165525060596439,
                  "assignments_average": 0.0,
                  "branches_average": 2.0,
                  "conditions_average": 12.0,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 2,
                  "branches_max": 2,
                  "conditions_min": 12,
                  "conditions_max": 12
                }
                "#
                );
            },
        );
    }

    // GMetrics, a Groovy source code analyzer, provides the following definition of unary conditional expression:
    // "These are cases where a single variable/field/value is treated as a boolean value.
    // Examples include `if (x)` and `return !ready`."
    // According to this definition, unary conditional expressions are counted also in function return values.
    // Source: https://dx42.github.io/gmetrics/metrics/AbcMetric.html
    // Examples: https://github.com/dx42/gmetrics/blob/master/src/test/groovy/org/gmetrics/metric/abc/AbcMetric_MethodTest.groovy
    #[cfg(feature = "java")]
    #[test]
    fn java_return_with_conditions() {
        check_metrics::<JavaParser>(
            "class A {
                boolean m1() {
                    return !(z >= 0);       // +1c
                }
                boolean m2() {
                    return (((!x)));        // +1c
                }
                boolean m3() {
                    return x && y;          // +2c
                }
                boolean m4() {
                    return y || (z < 0);    // +2c
                }
                boolean m5() {
                    return x || y ?         // +3c (two unary conditions and one ?)
                        true : false;
                }
            }",
            "foo.java",
            |metric| {
                // magnitude: sqrt(0 + 0 + 81) = sqrt(81)
                // space count: 7 (1 unit, 1 class and 5 methods)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 0,
                  "conditions": 9,
                  "magnitude": 9.0,
                  "value": 0.0,
                  "assignments_average": 0.0,
                  "branches_average": 0.0,
                  "conditions_average": 1.2857142857142858,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 0,
                  "branches_max": 0,
                  "conditions_min": 0,
                  "conditions_max": 3
                }
                "#
                );
            },
        );
    }

    // Variables, method invocations, and true or false values
    // inside return statements are not counted as conditions
    #[cfg(feature = "java")]
    #[test]
    fn java_return_without_conditions() {
        check_metrics::<JavaParser>(
            "class A {
                boolean m1() {
                    return x;
                }
                boolean m2() {
                    return (x);
                }
                boolean m3() {
                    return y.m();   // +1b
                }
                boolean m4() {
                    return false;
                }
                void m5() {
                    return;
                }
            }",
            "foo.java",
            |metric| {
                // magnitude: sqrt(0 + 1 + 0) = sqrt(1)
                // space count: 7 (1 unit, 1 class and 5 methods)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 1,
                  "conditions": 0,
                  "magnitude": 1.0,
                  "value": 0.0,
                  "assignments_average": 0.0,
                  "branches_average": 0.14285714285714285,
                  "conditions_average": 0.0,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 0,
                  "branches_max": 1,
                  "conditions_min": 0,
                  "conditions_max": 0
                }
                "#
                );
            },
        );
    }

    // Variables, method invocations, and true or false values
    // in lambda expression return values are not counted as conditions
    #[cfg(feature = "java")]
    #[test]
    fn java_lambda_expressions_return_with_conditions() {
        check_metrics::<JavaParser>(
            "
            Predicate<Boolean> p1 = a -> a;                         // +1a
            Predicate<Boolean> p2 = b -> true;                      // +1a
            Predicate<Boolean> p3 = c -> m();                       // +1a
            Predicate<Integer> p4 = d -> d > 10;                    // +1a +1c
            Predicate<Boolean> p5 = (e) -> !e;                      // +1a +1c
            Predicate<Boolean> p6 = (f) -> !((!f));                 // +1a +1c
            Predicate<Boolean> p7 = (g) -> !g && true;              // +1a +2c
            BiPredicate<Boolean, Boolean> bp1 = (h, i) -> !h && !i; // +1a +2c
            BiPredicate<Boolean, Boolean> bp2 = (j, k) -> {
                return j || k;                                      // +1a +2c
            };
            ",
            "foo.java",
            |metric| {
                // magnitude: sqrt(81 + 1 + 81) = sqrt(163)
                // space count: 1 (1 unit)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 9,
                  "branches": 1,
                  "conditions": 9,
                  "magnitude": 12.767145334803704,
                  "value": 12.767145334803704,
                  "assignments_average": 9.0,
                  "branches_average": 1.0,
                  "conditions_average": 9.0,
                  "assignments_min": 9,
                  "assignments_max": 9,
                  "branches_min": 1,
                  "branches_max": 1,
                  "conditions_min": 9,
                  "conditions_max": 9
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_for_with_variable_declaration() {
        check_metrics::<JavaParser>(
            "
            for ( int i1 = 0; !(!(!(!a))); i1++ ) {}                // +2a +1c
            for ( int i2 = 0; !B.m(); i2++ ) {}                     // +2a +1b +1c
            for ( int i3 = 0; a || false; i3++ ) {}                 // +2a +2c
            for ( int i4 = 0; a && B.m() ? true : false; i4++ ) {}  // +2a +1b +3c
            for ( int i5 = 0; true; i5++ ) {}                       // +2a +1c
            ",
            "foo.java",
            |metric| {
                // magnitude: sqrt(100 + 4 + 64) = sqrt(168)
                // space count: 1 (1 unit)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 10,
                  "branches": 2,
                  "conditions": 8,
                  "magnitude": 12.96148139681572,
                  "value": 12.96148139681572,
                  "assignments_average": 10.0,
                  "branches_average": 2.0,
                  "conditions_average": 8.0,
                  "assignments_min": 10,
                  "assignments_max": 10,
                  "branches_min": 2,
                  "branches_max": 2,
                  "conditions_min": 8,
                  "conditions_max": 8
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_for_without_variable_declaration() {
        check_metrics::<JavaParser>(
            "class A{
                void m1() {
                    for (i = 0; x < y; i++) {}          // +2a +1c
                    for (i = 0; ((x < y)); i++) {}      // +2a +1c
                    for (i = 0; !(!(x < y)); i++) {}    // +2a +1c
                    for (i = 0; true; i++) {}           // +2a +1c
                }
                void m2() {
                    for ( ; true; ) {}  // +1c
                }
                void m3() {
                    for ( ; ; ) {}      // +0c — no condition to count (#1276)
                }
            }",
            "foo.java",
            |metric| {
                // magnitude: sqrt(64 + 0 + 25) = sqrt(89)
                // space count: 5 (1 unit, 1 class and 3 methods)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 8,
                  "branches": 0,
                  "conditions": 5,
                  "magnitude": 9.433981132056603,
                  "value": 0.0,
                  "assignments_average": 1.6,
                  "branches_average": 0.0,
                  "conditions_average": 1.0,
                  "assignments_min": 0,
                  "assignments_max": 8,
                  "branches_min": 0,
                  "branches_max": 0,
                  "conditions_min": 0,
                  "conditions_max": 4
                }
                "#
                );
            },
        );
    }

    // Issue #1276 changed Java's answer here. `java_walk_for_statement`
    // used to read child(3), fall through to child(4) when that was the
    // `;` an expression initializer leaves behind, and count a `;` or
    // `)` landing there as a vacuously-true condition — so `for (;;)`
    // scored one. Nothing in Fitzpatrick's C dimension attributes a
    // condition to a `for` keyword; it counts conditional operators and
    // unary conditions that are present. Java and Groovy were the only
    // two impls disagreeing, and the field-addressed walker now reports
    // zero the way the C family, the JS family, PHP, C# and Go all do.
    #[cfg(feature = "java")]
    #[test]
    fn java_empty_for_condition_counts_nothing() {
        check_metrics::<JavaParser>(
            "class A { void m() { for (;;) { break; } } }",
            "foo.java",
            |metric| assert_eq!(metric.abc.conditions_sum(), 0),
        );
        // The other empty spelling, and the one the old cascade
        // actually mis-scored: with an **expression** initializer the
        // children are `for ( init ; ; update )`, so child(3) was the
        // separating `;` and child(4) the empty condition's `;`, which
        // the vacuous-true arm counted. The `for (int i = 0; ; i++)`
        // spelling scored 0 both before and after — Java's
        // `local_variable_declaration` swallows its own `;`, putting the
        // update expression at child(4), where it matched no arm — so it
        // would be a vacuous regression test and is deliberately not
        // used here.
        check_metrics::<JavaParser>(
            "class A { void m() { int i; for (i = 0; ; i++) { break; } } }",
            "foo.java",
            |metric| assert_eq!(metric.abc.conditions_sum(), 0),
        );
    }

    // The second defect the positional cascade carried: tree-sitter
    // counts comments among a node's children, so a comment anywhere in
    // the header shifted every index and the condition went unread —
    // the same failure #1181 removed from `java_walk_ternary`. Reading
    // the `condition` field cannot shift.
    #[cfg(feature = "java")]
    #[test]
    fn java_for_condition_survives_a_header_comment() {
        check_metrics::<JavaParser>(
            "class A { void m(boolean a) { for (; /* n */ a; ) { break; } } }",
            "foo.java",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
        // Unchanged control: the same loop without the comment. Both
        // spellings must agree, which is the property the positional
        // form broke.
        check_metrics::<JavaParser>(
            "class A { void m(boolean a) { for (; a; ) { break; } } }",
            "foo.java",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
    }

    // Variables, method invocations, and true or false values
    // in ternary expression return values are not counted as conditions
    #[cfg(feature = "java")]
    #[test]
    fn java_ternary_conditions() {
        check_metrics::<JavaParser>(
            "
            a = true;                                   // +1a
            b = a ? true : false;                       // +1a +2c
            c = ((((a)))) ? !false : !b;                // +1a +4c
            d = !this.m() ? !!a : (false);              // +1a +1b +3c
            e = !(a) && b ? ((c)) : !d;                 // +1a +4c
            if ( this.m() ? a : !this.m() ) {}          // +2b +3c
            if ( x > 0 ? !(false) : this.m() ) {}       // +1b +3c
            if ( x > 0 && x != 3 ? !(a) : (!(b)) ) {}   // +5c
            ",
            "foo.java",
            |metric| {
                // magnitude: sqrt(25 + 16 + 576) = sqrt(617)
                //  space count: 1 (1 unit)
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 5,
                  "branches": 4,
                  "conditions": 24,
                  "magnitude": 24.839484696748443,
                  "value": 24.839484696748443,
                  "assignments_average": 5.0,
                  "branches_average": 4.0,
                  "conditions_average": 24.0,
                  "assignments_min": 5,
                  "assignments_max": 5,
                  "branches_min": 4,
                  "branches_max": 4,
                  "conditions_min": 24,
                  "conditions_max": 24
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_assignments_only() {
        check_metrics::<BashParser>(
            "f() {
                 a=1
                 b=2
                 c+=3
             }",
            "foo.sh",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 3,
                  "branches": 0,
                  "conditions": 0,
                  "magnitude": 3.0,
                  "value": 0.0,
                  "assignments_average": 1.5,
                  "branches_average": 0.0,
                  "conditions_average": 0.0,
                  "assignments_min": 0,
                  "assignments_max": 3,
                  "branches_min": 0,
                  "branches_max": 0,
                  "conditions_min": 0,
                  "conditions_max": 0
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_commands_only() {
        check_metrics::<BashParser>(
            "f() {
                 echo a
                 ls
             }",
            "foo.sh",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 2,
                  "conditions": 0,
                  "magnitude": 2.0,
                  "value": 0.0,
                  "assignments_average": 0.0,
                  "branches_average": 1.0,
                  "conditions_average": 0.0,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 0,
                  "branches_max": 2,
                  "conditions_min": 0,
                  "conditions_max": 0
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_control_flow_counts_conditions() {
        // Regression for #696: Bash control-flow branches are ABC
        // conditions (a Bash predicate is a command, so the branch keyword
        // is the only condition signal). Each mirrors a cyclomatic decision.
        //
        // expected: 4 conditions — `if` (1) + `elif` (1) + `while` (1) +
        // the non-wildcard case arm `a)` (1). The bare-`*)` wildcard arm is
        // the Bash analogue of `default:` and is excluded, exactly as the
        // cyclomatic standard count excludes it. No comparison / test
        // operators appear, so every condition here is control-flow.
        check_metrics::<BashParser>(
            "f() {
                 if cmd; then
                     echo a
                 elif other; then
                     echo b
                 fi
                 while running; do
                     echo c
                 done
                 case \"$x\" in
                     a) echo d ;;
                     *) echo e ;;
                 esac
             }",
            "foo.sh",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_conditions_mix() {
        // Exercises every condition path: `==` and `!=` inside `[[ ]]`,
        // arithmetic `<` inside `(( ))`, and the prefix `-z` test operator
        // inside `[ ]`. Each `if` body's `echo` contributes a branch.
        //
        // expected: 8 conditions — each of the four `if`s contributes one
        // for the control-flow branch (#696) plus one for its comparison /
        // test operator (`==`, `!=`, `<`, `-z`). 4 branches (one `echo`
        // each). magnitude = sqrt(4² + 8²) = sqrt(80).
        check_metrics::<BashParser>(
            "f() {
                 if [[ \"$a\" == \"$b\" ]]; then
                     echo eq
                 fi
                 if [[ \"$x\" != \"$y\" ]]; then
                     echo ne
                 fi
                 if (( $a < $b )); then
                     echo lt
                 fi
                 if [ -z \"$x\" ]; then
                     echo empty
                 fi
             }",
            "foo.sh",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 8);
                assert_eq!(metric.abc.branches_sum(), 4);
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 4,
                  "conditions": 8,
                  "magnitude": 8.94427190999916,
                  "value": 0.0,
                  "assignments_average": 0.0,
                  "branches_average": 2.0,
                  "conditions_average": 4.0,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 0,
                  "branches_max": 4,
                  "conditions_min": 0,
                  "conditions_max": 8
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_redirection_is_not_a_condition() {
        // `>` and `<` spell an I/O redirection as well as a comparison, and
        // the grammar parents the redirection under `file_redirect` rather
        // than `binary_expression`. Ungated, every redirect in a script
        // scored a condition: this fixture measured 2 before the parent
        // gate — the Bash instance of #1280's positive-parent polarity.
        // expected: 0 conditions — no test, no `if`, no comparison.
        check_metrics::<BashParser>(
            "f() {\n  echo hi > out.txt\n  read x < in.txt\n}\n",
            "foo.sh",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                // The two `echo` / `read` commands still count as branches,
                // so the zero above is the gate firing rather than the walk
                // skipping the function body.
                assert_eq!(metric.abc.branches_sum(), 2);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_comparison_inside_an_arithmetic_or_test_context_is_a_condition() {
        // The positive control for the gate above: the same tokens under a
        // `binary_expression` are real comparisons in both the `[[ … ]]`
        // test form and the `(( … ))` arithmetic form, and still count.
        // expected: 4 — one `if` control-flow condition and one `>` per
        // function.
        check_metrics::<BashParser>(
            "f() {\n  if [[ $a > $b ]]; then :; fi\n}\ng() {\n  if (( a > b )); then :; fi\n}\n",
            "foo.sh",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_arithmetic_ternary_is_a_condition() {
        // The ABC half of #1268. Cyclomatic and cognitive both count Bash's
        // only ternary form; ABC did not, so the identical construct scored
        // 1 here against the C family's 2.
        // expected: 2 — the `>` comparison and the ternary itself, matching
        // `int m = a > b ? a : b;` in C.
        check_metrics::<BashParser>(
            "f() {\n  local m=$(( a > b ? a : b ))\n}\n",
            "foo.sh",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_magnitude() {
        // Combined assignments + branches + conditions. The single `if`
        // contributes two conditions (the control-flow branch, #696, plus
        // the `==` operator), so magnitude = sqrt(2² + 1² + 2²) = sqrt(9).
        check_metrics::<BashParser>(
            "f() {
                 a=1
                 b=2
                 if [[ \"$a\" == \"$b\" ]]; then
                     echo eq
                 fi
             }",
            "foo.sh",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 2,
                  "branches": 1,
                  "conditions": 2,
                  "magnitude": 3.0,
                  "value": 0.0,
                  "assignments_average": 1.0,
                  "branches_average": 0.5,
                  "conditions_average": 1.0,
                  "assignments_min": 0,
                  "assignments_max": 2,
                  "branches_min": 0,
                  "branches_max": 1,
                  "conditions_min": 0,
                  "conditions_max": 2
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_malformed_parenthesized_no_panic() {
        check_metrics::<JavaParser>("class A { void m() { if (( }) }", "foo.java", |metric| {
            // tree-sitter emits ERROR nodes for this malformed source, so no
            // IfStatement, branch, or condition is recognised — all counts are 0.
            // Primary goal: the unwrap-free path does not panic.
            assert_eq!(metric.abc.assignments(), 0);
            assert_eq!(metric.abc.branches(), 0);
            assert_eq!(metric.abc.conditions(), 0);
            assert_eq!(metric.abc.magnitude(), 0.0);
        });
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_bool_returning_terminal_kinds_count() {
        // Companion to `csharp_bool_returning_terminal_kinds_count`
        // (issue #372 / lesson #19). Java's grammar wraps every
        // if/while/do condition in `parenthesized_expression`, so
        // the gap lived in the former `java_inspect_container`'s
        // terminal-arm recognizer: `FieldAccess` (`cfg.flag`), `CastExpression`
        // (`(boolean)v`), `ArrayAccess` (`flags[0]`), and
        // `InstanceofExpression` (`x instanceof Foo`) were never
        // counted. Java has no `await` or `is_pattern` analogues,
        // so the C# fix's five-kind set collapses to four here.
        //
        // `instanceof` has since moved out of the terminal set to an
        // unconditional arm (#1461), so it no longer depends on the
        // slot to be counted. The total is unchanged, which is the
        // point of that change rather than an accident of it.
        //
        // expected: 4 conditions (one per `if`), 0 assignments,
        // 0 branches (no invocations).
        check_metrics::<JavaParser>(
            "class Cfg { boolean flag; }
            class A {
                void m(Object v, boolean[] flags, Cfg cfg) {
                    if (cfg.flag) { }
                    if ((boolean) v) { }
                    if (v instanceof Cfg) { }
                    if (flags[0]) { }
                }
            }",
            "foo.java",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
            },
        );
    }

    // Issue #1274: a generic *declaration* is type syntax, not a
    // decision. `java_count_token_condition` denied only
    // `type_arguments`, so `class Gen<T>` and `<U> U ident(U x)` — both
    // `type_parameters` — each scored two conditions. The fix counts
    // `<` / `>` only under `binary_expression`, the polarity C / C++ /
    // Rust / Go already use; a `grammar.json` sweep proves the token is
    // emitted from exactly three productions, so the two shapes agree on
    // every well-formed input.
    //
    // One fixture per production the arm must ignore: the class-level
    // `type_parameters` (`Gen<T …>`), its `extends` bound's nested
    // `type_arguments` (`Comparable<T>`), the method-level
    // `type_parameters` (`<U>`), and a nested generic
    // (`Map<String, List<T>>`) whose two closing `>` lex as separate
    // tokens under separate `type_arguments`. Pre-fix this file scored
    // 4 conditions — two per `type_parameters` bracket pair; expected 0,
    // the file contains no conditional construct at all.
    #[cfg(feature = "java")]
    #[test]
    fn java_generic_declarations_are_not_conditions() {
        check_metrics::<JavaParser>(
            "class Gen<T extends Comparable<T>> {
                <U> U ident(U x) { return x; }
                List<T> pick(Map<String, List<T>> m) { return m.get(\"k\"); }
            }",
            "foo.java",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                // Non-vacuity guard: 0 is also what an unparsed file
                // scores, so pin a value only a walked body can produce
                // — the `m.get("k")` invocation.
                assert_eq!(metric.abc.branches_sum(), 1);
            },
        );
    }

    // Second half of #1274, same premise and same match: a wildcard type
    // argument's `?` is type syntax, not a ternary. tree-sitter-java emits
    // a bare `?` from exactly two productions — `ternary_expression` and
    // `wildcard` — so the `QMARK` arm carries the same allowlist gate the
    // `<` / `>` arm does.
    //
    // The body carries a real ternary over a real comparison so the
    // expected total is 2, not 0. Asserting 0 on a wildcard-only fixture
    // would have been vacuous — an unparsable file scores 0 too, so the
    // test could not tell "the wildcard was ignored" from "the fixture
    // stopped being recognised". Each failure mode now lands on its own
    // number: 4 if the wildcard `?` counts again (the pre-fix value), 3
    // if the gate is aimed at `Wildcard` instead, 1 if it swallows the
    // genuine ternary, 0 if parsing breaks. Two wildcards against one
    // ternary is deliberate — with one of each, aiming the gate at the
    // wrong one of the two productions still totals 2 and the test
    // cannot see the difference.
    #[cfg(feature = "java")]
    #[test]
    fn java_generic_wildcard_is_not_a_condition() {
        check_metrics::<JavaParser>(
            "class A {
                int m(List<? extends Number> xs, Map<String, ? extends Number> ys,
                      int a, int b) { return a < b ? 1 : 2; }
            }",
            "foo.java",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // The other half of #1274: narrowing the `<` / `>` arm must not
    // swallow real comparisons. `List<String>` in the signature keeps a
    // generic in scope so the fixture proves both directions at once,
    // and the assertion is the grammar-dispatch §8 pin — on the
    // method's own space the ABC condition count must equal the
    // cyclomatic decision count (`cyclomatic()` minus the per-space
    // base of 1). Both are 2, one per `if`.
    #[cfg(feature = "java")]
    #[test]
    fn java_comparison_operators_still_count_alongside_generics() {
        check_func_space::<JavaParser, _>(
            "class A {
                int m(List<String> xs, int a, int b) {
                    if (a < b) { return 1; }
                    if (a > b) { return 2; }
                    return 0;
                }
            }",
            "foo.java",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 2),
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_constructor_delegation_is_a_branch() {
        // Regression for #1279: `super(…)` / `this(…)` parse as
        // `explicit_constructor_invocation`, not `method_invocation`, so
        // each scored zero branches while Groovy scored one for identical
        // source. Both constructors delegate, and neither body contains any
        // other call.
        // expected: 2 branches — one delegation each.
        check_metrics::<JavaParser>(
            "class Sub extends Base {
                Sub() { super(1); }
                Sub(int a) { this(); }
            }",
            "foo.java",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_constructor_delegation_does_not_double_count_arguments() {
        // The delegation node does not wrap a `method_invocation` for the
        // call itself, so `super(f())` is exactly two branches — the
        // delegation and the argument call — not three (#1279).
        // expected: 2 branches.
        check_metrics::<JavaParser>(
            "class Sub extends Base {
                Sub() { super(f()); }
            }",
            "foo.java",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_constructor_initializer_is_a_branch() {
        // C# spells the same delegation as a `constructor_initializer`
        // (`: base(…)` / `: this(…)`), which likewise scored zero (#1279).
        // expected: 2 branches — one initializer each, no other calls.
        check_metrics::<CsharpParser>(
            "class Sub : Base {
                Sub() : base(1) { }
                Sub(int a) : this() { }
            }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_primary_constructor_base_call_is_a_branch() {
        // The C# 12 primary-constructor superclass call invokes the base
        // constructor exactly as the `: base(…)` above it does, and scored
        // zero until #1406 — the C# sibling of Kotlin's #1384.
        //
        // tree-sitter-c-sharp 0.23.5 spells the `record` and `class`
        // families differently, so per `.claude/rules/grammar-dispatch.md`
        // §11 they are two independent paths and each needs its own
        // fixture: the record form nests the arguments under a
        // `primary_constructor_base_type`, the class form hangs them
        // straight off the `base_list`. A record-only fixture says nothing
        // about the class arm, and vice versa.
        //
        // `S` and `R3` are the negatives: a base type with no argument
        // list is not a call, and neither spelling emits an
        // `argument_list` for it.
        let src = "class Sub(int x) : Base(x) { }
                   record R1(int x) : Base(x);
                   record class R2(int x) : Base(x);
                   class G<T>(int x) : GBase<T>(x) where T : class { }
                   class Multi(int x) : Base(x), IBase { }
                   struct S(int x) : IBase { }
                   record R3(int x) : Base;";
        // Anchors every spelling against a fixture edit: with presence
        // checks only, deleting `(x)` from the class form leaves the
        // record form satisfying the arm and this test green. The last
        // two counts anchor the declarations that would otherwise decay
        // into duplicates of `Sub` — `Multi` owns the fixture's only
        // comma (`Base(x), IBase`) and `G` its only type argument list
        // (`GBase<T>`), so trimming either back fails here by name.
        assert_csharp_fixture_spells(
            src,
            &[
                (
                    Csharp::PrimaryConstructorBaseType as u16,
                    2,
                    "`record` base calls",
                ),
                (Csharp::ArgumentList as u16, 5, "base-call argument lists"),
                (Csharp::BaseList2 as u16, 7, "base lists"),
                // The §2 drift marker for the arm's other half. Both ids
                // render to `"base_list"`; at this pin every declaration
                // family above emits 252 and none emits 246, so
                // `BaseList` is defensive and this zero says so. A
                // grammar bump that starts emitting it fails here rather
                // than silently changing which arm does the work.
                (Csharp::BaseList as u16, 0, "unaliased `base_list` nodes"),
                (Csharp::COMMA as u16, 1, "`Multi`'s trailing interface"),
                (Csharp::TypeArgumentList as u16, 1, "`G`'s generic base"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            for name in ["Sub", "R1", "R2", "G", "Multi"] {
                assert_eq!(
                    child_space(&space, name).metrics.abc.branches(),
                    1,
                    "{name}: the primary-constructor base call is one branch"
                );
            }
            for name in ["S", "R3"] {
                assert_eq!(
                    child_space(&space, name).metrics.abc.branches(),
                    0,
                    "{name}: a base type with no argument list is not a call"
                );
            }
        });
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_base_list_gate_excludes_other_argument_lists() {
        // The `base_list` parent gate on the `ArgumentList` arm is
        // load-bearing, not decoration: ungated it bills a branch for the
        // argument list of every call and allocation in the file, on top
        // of the `InvocationExpression` / `ObjectCreationExpression` the
        // arm already counts — doubling both (#1406).
        //
        // The fixture pairs one real base call with the four other
        // argument-carrying productions C# spells nearby: an attribute
        // (`attribute_argument_list`), an invocation, an object creation,
        // and an indexer (`bracketed_argument_list`) alongside a generic
        // (`type_argument_list`). Those last three are distinct kind ids
        // rather than `argument_list`, so they pin the §1 neighbour set
        // as much as the gate.
        let src = "[System.Obsolete(\"why\")]
                   class A(int x) : Base(x) {
                       void M(int y) { Helper(y); }
                       object N() { return new Foo(1); }
                       int P(System.Collections.Generic.List<int> l, int i) { return l[i]; }
                   }";
        assert_csharp_fixture_spells(
            src,
            &[
                (
                    Csharp::AttributeArgumentList as u16,
                    1,
                    "attribute argument lists",
                ),
                (
                    Csharp::BracketedArgumentList as u16,
                    1,
                    "bracketed argument lists",
                ),
                (Csharp::TypeArgumentList as u16, 1, "type argument lists"),
                (Csharp::ArgumentList as u16, 3, "argument lists"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            let class = child_space(&space, "A");
            assert_eq!(
                class.metrics.abc.branches(),
                1,
                "`: Base(x)` alone — the attribute's arguments are not a call"
            );
            // The controls. 2 apiece would mean the gate let the
            // argument list through beside the call that owns it.
            assert_eq!(
                child_space(class, "M").metrics.abc.branches(),
                1,
                "`Helper(y)` is one branch, not one per argument list"
            );
            assert_eq!(
                child_space(class, "N").metrics.abc.branches(),
                1,
                "`new Foo(1)` is one branch, not one per argument list"
            );
            // `P` carries the indexer and the generic deliberately, but
            // gets no assertion: `bracketed_argument_list` and
            // `type_argument_list` are distinct kind ids, so `P` reads 0
            // with the gate, without it, and without this change
            // altogether. The census above is what actually pins them —
            // an assertion here would read as coverage it cannot provide.
        });
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_base_call_and_constructor_initializer_do_not_double_count() {
        // A class can spell *both* delegations at once: the primary
        // constructor's `: Base(x)` and a secondary constructor's
        // `: this(a)`. They are separate nodes in separate spaces, so the
        // file scores 2 — one each. 3 would mean the #1406 arm also fired
        // on something `ConstructorInitializer` already owned; 1 would
        // mean one of the two stopped counting.
        //
        // Java has the equivalent guard
        // (`java_constructor_delegation_does_not_double_count_arguments`);
        // C# now has two delegation spellings and this is the pairing
        // test for them.
        let src = "class Both(int x) : Base(x) {
                       public Both(int a, int b) : this(a) { }
                   }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::ConstructorInitializer as u16, 1, "`: this(a)`"),
                (Csharp::BaseList2 as u16, 1, "the primary-constructor base"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            let class = child_space(&space, "Both");
            assert_eq!(
                class.metrics.abc.branches(),
                1,
                "the class space owns `: Base(x)` and nothing else"
            );
            assert_eq!(
                child_space(class, "Both").metrics.abc.branches(),
                1,
                "the secondary constructor owns `: this(a)` and nothing else"
            );
        });
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_constructor_delegation_is_a_branch() {
        // Kotlin's secondary-constructor delegation is a
        // `constructor_delegation_call`, a distinct production from
        // `CallExpression`, so it scored zero for the same reason (#1279).
        // expected: 1 branch — the `: super(x)` delegation.
        check_metrics::<KotlinParser>(
            "class Sub : Base {
                constructor(x: Int) : super(x) { }
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 1);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_primary_constructor_superclass_call_is_a_branch() {
        // Kotlin's *primary*-constructor superclass call is a
        // `constructor_invocation` under a `delegation_specifier` — a third
        // production, distinct from both `CallExpression` and the
        // `ConstructorDelegationCall` #1279 added, so it scored zero while
        // the secondary form beside it scored one (#1384). An object
        // expression's superclass call uses the same production.
        //
        // `class Plain : Marker` is the negative case: a delegation
        // specifier with no argument list is a plain `user_type`, so it
        // must stay at zero. Broadening the arm to bare
        // `DelegationSpecifier` fails here at `branches_sum` (5 against
        // 3), though not on `Plain`'s account alone: `class Classic :
        // Base` below is argument-less too, so deleting `Plain` still
        // leaves the broadening failing, at 4. What `Plain` buys is the
        // case stated outright rather than riding on the contrast fixture,
        // and since the per-space assertions below name it, trimming it
        // from the fixture fails in `child_space` instead of passing
        // silently as it did while this test read only the sum.
        //
        // `class Classic` carries the secondary spelling of the same call
        // alongside, which is what makes the per-space assertions below a
        // contrast rather than a census: a class header's superclass call
        // sits in `delegation_specifiers`, outside every member, so no
        // function space encloses it and the branch is the **class**
        // space's, while `constructor(x: Int) : super(x)` opens a function
        // space and takes the branch with it. `branches_sum` cannot see the
        // difference — the file totals 3 either way — so a codebase moving
        // to primary constructors shifts per-function `branches_max` /
        // `branches_average` and per-space `abc` thresholds without any
        // behaviour change. That is deliberate (there is no function to
        // attribute the call to), and C# has the identical split, pinned by
        // `csharp_base_call_and_constructor_initializer_do_not_double_count`
        // (#1456).
        //
        // expected: 3 branches — `Base(1, 2)`, `Base(3)` and `super(x)`.
        // Nothing else in the fixture is a call, so deleting any one
        // construction from the fixture moves both the total and the space
        // it belongs to.
        check_func_space::<KotlinParser, _>(
            "class Sub : Base(1, 2) { }
             class Plain : Marker { }
             fun make(): Any = object : Base(3) { }
             class Classic : Base {
                 constructor(x: Int) : super(x) { }
             }",
            "foo.kt",
            |space| {
                assert_eq!(space.metrics.abc.branches_sum(), 3);
                assert_eq!(
                    child_space(&space, "Sub").metrics.abc.branches(),
                    1,
                    "the primary-constructor superclass call is the class space's"
                );
                assert_eq!(
                    child_space(&space, "Plain").metrics.abc.branches(),
                    0,
                    "a delegation specifier with no argument list is not a call"
                );
                // The object expression is its own Class space (#463), so
                // `make` holds nothing of its own — the same attribution
                // one level down.
                let make = child_space(&space, "make");
                assert_eq!(
                    make.metrics.abc.branches(),
                    0,
                    "`make` owns no branch; `object : Base(3)` is its own space"
                );
                assert_eq!(
                    child_space(make, "<anonymous>").metrics.abc.branches(),
                    1,
                    "the object expression's superclass call is that space's"
                );
                // The contrast. `Classic` spells the same call through a
                // secondary constructor, which *does* open a function
                // space, so the class owns nothing.
                let classic = child_space(&space, "Classic");
                assert_eq!(
                    classic.metrics.abc.branches(),
                    0,
                    "a secondary constructor's `: super(x)` is not the class's"
                );
                assert_eq!(
                    child_space(classic, "<anonymous>").metrics.abc.branches(),
                    1,
                    "it belongs to the constructor's own function space"
                );
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_annotation_arguments_are_not_a_branch() {
        // The parent gate on that arm is load-bearing, not decoration:
        // tree-sitter-kotlin-ng spells an annotation's argument list with
        // the *same* `constructor_invocation` production — `@Mark("a")`
        // parses as `annotation > constructor_invocation` and
        // `@file:Suppress(…)` as `file_annotation > constructor_invocation`.
        // Ungated, every argument-carrying annotation in a Kotlin file
        // would bill a branch, and annotations are everywhere (#1384).
        //
        // The fixture pairs three annotation spellings — file-level,
        // class-level and use-site-targeted — with one real superclass
        // call, so the total discriminates in both directions: 1 with the
        // gate, 4 without it, 0 without the arm at all.
        //
        // A correctly-excluded annotation contributes to no ABC axis, so
        // `branches_sum()` alone cannot notice the annotations being
        // trimmed out of the fixture — measured: dropping any of the three
        // leaves this test green, and with all three gone, removing the
        // production gate fails nothing. The node census below is the
        // anchor: it pins that the fixture really does hand the arm four
        // `constructor_invocation` nodes for it to score 1 out of, and
        // that the `file_annotation` parent — the spelling a denylist of
        // `Annotation` alone would have missed — is among them.
        //
        // expected: 1 branch — `Base(1)` only.
        let src = r#"@file:Suppress("unused")
             @Mark("a")
             class Ann : Base(1) {
                 @get:Mark("b")
                 val v: Int = 0
             }"#;
        let parser = KotlinParser::new(
            src.as_bytes().to_vec(),
            &std::path::PathBuf::from("foo.kt"),
            None,
        );
        assert_eq!(
            parser
                .root()
                .preorder()
                .filter(|n| n.kind_id() == Kotlin::ConstructorInvocation as u16)
                .count(),
            4,
            "fixture must keep three annotations plus the superclass call"
        );
        assert!(ast_has_kind_id(&parser, Kotlin::FileAnnotation as u16));

        check_metrics::<KotlinParser>(src, "foo.kt", |metric| {
            assert_eq!(metric.abc.branches_sum(), 1);
        });
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_constructor_delegation_is_a_branch() {
        // Groovy already counted this shape before #1279; the assertion
        // pins the JVM-family parity the Java and Kotlin fixes restore.
        // expected: 1 branch — the `super(1)` delegation.
        check_metrics::<GroovyParser>(
            "class Sub extends Base {
                Sub() { super(1) }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 1);
            },
        );
    }

    // The three tests below are one fix seen from three grammars (#1407):
    // an enum constant carrying constructor arguments is an object
    // construction and scored zero in every JVM-family language, which
    // #1279 and #1384 left behind because both looked at superclass
    // delegation only.
    //
    // Each fixture pairs an argument-carrying constant with a bare one in
    // the *same* enum, because that is the only shape that shows the gate
    // working: a fixture of only `A(1)` scores the same whether the arm is
    // gated on the argument list or matches every constant
    // (`.claude/rules/grammar-dispatch.md` §6). Each also carries a
    // constant whose argument is itself a call, which must score 2 rather
    // than 1 (§5).
    //
    // `branches_sum()` alone cannot notice the bare constant being trimmed
    // out — it contributes to no axis — so every fixture is anchored on a
    // node census that fails by name when a spelling is edited away
    // (`.claude/rules/testing.md`, "Perturb the fixture as well as the
    // production line"). The two are coupled in one helper for the same
    // reason `assert_kotlin_class_members` couples its pair: a branch
    // total added without the census reads as coverage and is not.

    #[cfg(any(feature = "groovy", feature = "java", feature = "kotlin"))]
    fn assert_enum_branches<P: MetricSuite>(
        src: &str,
        path: &str,
        kinds: &[(u16, usize, &str)],
        branches: u64,
    ) {
        assert_fixture_spells::<P>(src, path, kinds);
        check_func_space::<P, _>(src, path, |space| {
            assert_eq!(space.metrics.abc.branches_sum(), branches);
        });
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_enum_constant_with_arguments_is_a_branch() {
        // `@SuppressWarnings("x") B` is the discriminating case for the
        // gate's *kind*, not just its presence: the annotation carries an
        // argument list of its own, so an arm gated on "has some argument
        // list anywhere below" would score it. It cannot satisfy this one
        // twice over — `annotation_argument_list` is a distinct kind id
        // from `argument_list`, and it hangs off the constant's `modifiers`
        // child rather than the constant itself. Both verified with `bca
        // dump`.
        //
        // expected: 4 branches — `A(1)`, `K(2)`, `D(…)`, and the `f()`
        // inside `D`'s argument list. `B` scores 0.
        let src = "class Outer {
                static int f() { return 1; }
                enum E {
                    A(1),
                    @SuppressWarnings(\"x\") B,
                    K(2),
                    D(f());
                    E(int v) {}
                }
            }";
        assert_enum_branches::<JavaParser>(
            src,
            "foo.java",
            &[
                (Java::EnumConstant as u16, 4, "enum constants"),
                (Java::ArgumentList as u16, 4, "argument lists"),
                (
                    Java::AnnotationArgumentList as u16,
                    1,
                    "`@SuppressWarnings`'s argument list",
                ),
                (Java::MethodInvocation as u16, 1, "`D`'s nested `f()` call"),
            ],
            4,
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_enum_entry_with_arguments_is_a_branch() {
        // Kotlin needs a defaulted primary-constructor parameter to spell
        // both cases in one enum: `enum class E(val v: Int)` obliges every
        // entry to pass an argument, so `= 0` is what lets the bare `B`
        // sit beside `A(1)`. `enum class P` covers the other shape the gate
        // has to leave alone — an enum with no constructor at all, whose
        // entries can never carry an argument list.
        //
        // expected: 3 branches — `A(1)`, `C(…)`, and the `g()` inside `C`'s
        // argument list. `B`, `X` and `Y` score 0.
        let src = "fun g(): Int = 1
             enum class E(val v: Int = 0) { A(1), B, C(g()) }
             enum class P { X, Y }";
        assert_enum_branches::<KotlinParser>(
            src,
            "foo.kt",
            &[
                (Kotlin::EnumEntry as u16, 5, "enum entries"),
                (Kotlin::ValueArguments as u16, 3, "argument lists"),
                (Kotlin::CallExpression as u16, 1, "`C`'s nested `g()` call"),
            ],
            3,
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_enum_constant_with_arguments_is_a_branch() {
        // Groovy's enum has no annotated-constant case to cover: the
        // dekobon grammar cannot parse `@Deprecated A(1)` inside an enum
        // body and recovers into `ERROR` nodes, emitting no `enum_constant`
        // at all. The remaining two cases are the ones that matter.
        //
        // expected: 3 branches — `A(1)`, `D(…)`, and the `Outer.f()` inside
        // `D`'s argument list. `B` scores 0.
        let src = "class Outer { static int f() { 1 } }
             enum E { A(1), B, D(Outer.f()) }";
        assert_enum_branches::<GroovyParser>(
            src,
            "foo.groovy",
            &[
                (Groovy::EnumConstant as u16, 3, "enum constants"),
                (Groovy::ArgumentList as u16, 3, "argument lists"),
                (
                    Groovy::MethodInvocation as u16,
                    1,
                    "`D`'s nested `Outer.f()` call",
                ),
            ],
            3,
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_no_abc() {
        // Comment-only file has no executable code → all-zero ABC.
        check_metrics::<GroovyParser>(
            "// just a comment, no executable code",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_single_assignment() {
        // `int x = 1` is a local-variable declaration whose `=` counts
        // as one assignment (matches Java's semantics).
        check_metrics::<GroovyParser>("int x = 1", "foo.groovy", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 1);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
        });
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_assignments() {
        check_metrics::<GroovyParser>(
            "void f() {
                int a = 1
                int b = 2
                a = 3
                b = 4
                a += 1
                b -= 1
            }",
            "foo.groovy",
            |metric| {
                // Six `=` tokens total. The two `Final`-less local
                // var-decls (`int a = 1`, `int b = 2`) and the two
                // bare assignments (`a = 3`, `b = 4`) each contribute
                // one assignment via the `EQ` arm; the `+=` / `-=`
                // each contribute one via the compound-assign arm.
                assert_eq!(metric.abc.assignments_sum(), 6);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_branches() {
        check_metrics::<GroovyParser>(
            "void f() {
                doStuff()
                helper.invoke()
                new Worker()
            }",
            "foo.groovy",
            |metric| {
                // 2 method invocations + 1 object creation = 3 branches
                assert_eq!(metric.abc.branches_sum(), 3);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_conditions_in_if() {
        check_metrics::<GroovyParser>(
            "void f(int a) {
                if (a == 0) { println(a) }
                if (a >= 1) { println(a) }
                if (a != 2) { println(a) }
            }",
            "foo.groovy",
            |metric| {
                // Three relational ops = 3 conditions
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_branches_with_juxt_call() {
        // Groovy's parens-less call form `println foo` must be counted
        // as a branch (`JuxtFunctionCall`).
        check_metrics::<GroovyParser>(
            "void f() {
                println 'hi'
                println 'bye'
            }",
            "foo.groovy",
            |metric| {
                // 2 juxt calls = 2 branches.
                assert_eq!(metric.abc.branches_sum(), 2);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_try_catch_conditions() {
        // Each `try` and `catch` keyword token contributes +1 to
        // conditions (mirrors Java).
        check_metrics::<GroovyParser>(
            "void f() {
                try {
                    risky()
                } catch (Exception e) {
                    handle(e)
                }
            }",
            "foo.groovy",
            |metric| {
                // try + catch = 2 conditions
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_ternary_conditions() {
        check_metrics::<GroovyParser>(
            "void f(int x) {
                def y = x > 0 ? 1 : 2
            }",
            "foo.groovy",
            |metric| {
                // QMARK alone is +1 condition, plus the `>` condition = 2.
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_constant_excluded_from_assignments() {
        // `final` declarations are not counted as assignments
        // (mirrors Java's `Final` handling).
        check_metrics::<GroovyParser>(
            "class A {
                final int CONST = 42
                int field = 0
            }",
            "foo.groovy",
            |metric| {
                // The `=` on `final int CONST = 42` is a constant
                // initialiser (skipped). Only `field = 0` counts.
                assert_eq!(metric.abc.assignments_sum(), 1);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_malformed_parenthesized_no_panic() {
        // Regression: malformed Groovy input must not panic the ABC
        // walker; the `spaces.rs` Unit fallback (lesson 9) covers
        // structural recovery. amaanq's grammar treats `def x = (((`
        // as a `local_variable_declaration` whose initialiser is the
        // first opening paren — the `=` still fires the assignment
        // arm.
        check_metrics::<GroovyParser>("def x = (((", "foo.groovy", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 1);
        });
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_bool_returning_terminal_kinds_count() {
        // Companion to `csharp_bool_returning_terminal_kinds_count`
        // (issue #372 / lesson #19). The dekobon Groovy grammar
        // shares Java's wrapping conventions for `FieldAccess` and
        // `InstanceofExpression`, but it splits casts into two
        // distinct kinds — `cast_expression` for the Groovy-idiomatic
        // `v as Boolean` and `parenthesized_type_cast` for the
        // Java-style `(boolean) v`. The grammar has no `await` or
        // `array_access` analogues, so the C# fix's five-kind set
        // collapses to four here (with the cast slot doubled).
        //
        // `instanceof` has since moved out of the terminal set to an
        // unconditional arm (#1461), so it no longer depends on the
        // slot to be counted. The total is unchanged, which is the
        // point of that change rather than an accident of it.
        //
        // expected: 4 conditions (one per `if`), 0 assignments,
        // 0 branches (no invocations).
        check_metrics::<GroovyParser>(
            "class Cfg { boolean flag }
            class A {
                void m(Object v, Cfg cfg) {
                    if (cfg.flag) { }
                    if ((boolean) v) { }
                    if (v as Boolean) { }
                    if (v instanceof Cfg) { }
                }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
            },
        );
    }

    // Groovy half of #1274 — see `java_generic_declarations_are_not_conditions`.
    // The class-level `type_parameters` and its bound's nested
    // `type_arguments` mirror the Java fixture; pre-fix this file scored
    // 2 conditions, expected 0.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_generic_declarations_are_not_conditions() {
        check_metrics::<GroovyParser>(
            "class Gen<T extends Comparable<T>> {
                List<T> pick(Map<String, List<T>> m) { m.get(\"k\") }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                // Non-vacuity guard — see the Java counterpart.
                assert_eq!(metric.abc.branches_sum(), 1);
            },
        );
    }

    // Groovy counterpart of `java_generic_wildcard_is_not_a_condition`,
    // including its choice of a non-zero expected total and its
    // two-wildcards-one-ternary shape; the dekobon grammar emits the
    // same `wildcard` node. Pre-fix: 4.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_generic_wildcard_is_not_a_condition() {
        check_metrics::<GroovyParser>(
            "class A {
                int m(List<? extends Number> xs, Map<String, ? extends Number> ys,
                      int a, int b) { a < b ? 1 : 2 }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // A generic *method* gets its own fixture because the dekobon
    // grammar gives it its own production: `def <U> U ident(U x)` emits
    // `method_type_parameters`, not the `type_parameters` the class form
    // above uses. It is the fourth and last production from which that
    // grammar emits a bare `<` / `>` (the others being
    // `binary_expression`, `type_arguments` and `type_parameters`), and
    // the one a denylist extended only with `TypeParameters` — the fix
    // this issue's own plan proposed — would still miss. Revert-verified
    // in both directions: under that denylist this test still fails
    // while `groovy_generic_declarations_are_not_conditions` passes.
    //
    // The body carries a ternary over a comparison for the same
    // non-vacuity reason as the wildcard tests: expected 2, pre-fix 4
    // (the `<U>` bracket pair), 0 if the fixture stops parsing.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_method_type_parameters_are_not_conditions() {
        check_metrics::<GroovyParser>(
            "class A {
                def <U> U ident(U x, int a, int b) { a < b ? x : null }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // Groovy counterpart of
    // `java_comparison_operators_still_count_alongside_generics`: the
    // narrowed arm keeps counting real comparisons, pinned against the
    // cyclomatic decision count on the method's own space (§8).
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_elvis_counts_one_condition_per_token() {
        // `a ?: c` is a short-circuit decision Groovy cyclomatic already
        // counts and the Kotlin ABC arm counts for its identical token;
        // Groovy's arm listed neither `?:` nor its `elvis_expression`, so
        // a method whose only branching is elvis chains reported
        // cyclomatic > 1 with zero conditions. One per token, so the
        // grammar-dispatch §8 invariant holds on the chain:
        // `conditions() == cyclomatic() - 1`.
        check_func_space::<GroovyParser, _>(
            "class K { def f(a, c) { return a ?: c } }",
            "foo.groovy",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 1),
        );
        check_func_space::<GroovyParser, _>(
            "class K { def g(a, b, c) { return a ?: b ?: c } }",
            "foo.groovy",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 2),
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_comparison_operators_still_count_alongside_generics() {
        check_func_space::<GroovyParser, _>(
            "class A {
                int m(List<String> xs, int a, int b) {
                    if (a < b) { return 1 }
                    if (a > b) { return 2 }
                    return 0
                }
            }",
            "foo.groovy",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 2),
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_if_multiple_conditions() {
        // Mirrors `java_if_multiple_conditions`: `&&` / `||` chains
        // and parenthesised unary forms each contribute one
        // condition per primitive comparison; the inspect-container
        // pass picks up the unary `!a` / `!b` arguments inside the
        // `BinaryExpression` and counts them too.
        check_metrics::<GroovyParser>(
            "void f(boolean a, boolean b, boolean c) {
                if (a || b || c) { println(a) }
                if (a && b && c) { println(a) }
                if (!a && !b) { println(a) }
            }",
            "foo.groovy",
            |metric| {
                // Conditions counted via the AMPAMP/PIPEPIPE arms
                // (one count per identifier in the chain — three
                // for `||`, three for `&&`, two for the unary chain)
                // = 8.
                assert_eq!(metric.abc.conditions_sum(), 8);
                // Three `println a` juxt calls — each is a branch.
                assert_eq!(metric.abc.branches_sum(), 3);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_while_and_do_while_conditions() {
        // Covers the WhileStatement and DoStatement arms in
        // `impl Abc for GroovyCode`. Each `while` / `do-while` has
        // its condition scored through `groovy_count_condition`.
        check_metrics::<GroovyParser>(
            "void f(boolean a, boolean b) {
                while (a) {
                    a = false
                }
                do {
                    b = !b
                } while (b)
            }",
            "foo.groovy",
            |metric| {
                // `while(a)` + `while(b)` each contribute one condition;
                // the unary `!b` on the do body's right-hand side adds
                // one more via the assignment-arm inspection = 3.
                assert_eq!(metric.abc.conditions_sum(), 3);
                // Two assignments to existing variables (`a = false`,
                // `b = !b`).
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_if_while_boolean_literal_condition() {
        // Regression for the Groovy half of #371-class bugs: the
        // dekobon tree-sitter-groovy grammar wraps a bare
        // `true` / `false` literal used as the condition of
        // `if` / `while` / `do` / `?:` in a `boolean_literal` node
        // (`Groovy::BooleanLiteral`, kind_id 270), not the leaf
        // `True` / `False` keyword tokens. `groovy_count_condition`
        // must therefore match `BooleanLiteral` (the wrapper).
        // Without that, every literal-condition statement silently
        // scored 0 conditions. Mirror of
        // `csharp_if_while_boolean_literal_condition`.
        check_metrics::<GroovyParser>(
            "void m() {
                if (true) { println 'a' }
                if (false) { println 'b' }
                while (true) { break }
                int t = true ? 1 : 0
            }",
            "foo.groovy",
            |metric| {
                // Four literal-condition statements contribute 4
                // `BooleanLiteral` conditions (if / if / while /
                // ternary), plus the ternary's `?` token adds one
                // more via `groovy_count_token_condition` → 5
                // total. The `println` calls contribute 2 branches
                // (the `while` body's `break` is not a branch).
                // The `int t = …` initializer contributes 1
                // assignment.
                assert_eq!(metric.abc.conditions_sum(), 5);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.assignments_sum(), 1);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_return_unary_boolean_literal() {
        // Companion to `groovy_if_while_boolean_literal_condition`:
        // a `!true` / `!false` operand inside a `return` statement
        // routes through `groovy_count_negated`. The `!` proves
        // boolean context, and a `BooleanLiteral` does not score
        // itself (`groovy_condition_scores_itself`), so the
        // negated operand pays one condition.
        check_metrics::<GroovyParser>(
            "boolean f() {
                return !true
            }
            boolean g() {
                return !false
            }",
            "foo.groovy",
            |metric| {
                // Each `return !X` walks into `groovy_count_negated`
                // with a UnaryExpression wrapping a `BANG` +
                // BooleanLiteral. The peel through `!` proves boolean
                // context (a `return` is not a slot), then the
                // BooleanLiteral operand contributes one condition.
                // Two `return !X` → 2 conditions, no branches, no
                // assignments.
                assert_eq!(metric.abc.conditions_sum(), 2);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.assignments_sum(), 0);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_short_circuit_with_boolean_literal_operand() {
        // Companion to `groovy_if_while_boolean_literal_condition`:
        // a bare `true` / `false` operand of `&&` / `||` is a
        // chain-operand slot scored through `groovy_count_condition`.
        // A `BooleanLiteral` does not score itself, so the slot pays
        // for it; otherwise the operand would silently score zero.
        check_metrics::<GroovyParser>(
            "void m(boolean x) {
                if (x && true) { println 'a' }
                if (false || x) { println 'b' }
            }",
            "foo.groovy",
            |metric| {
                // `&&` and `||` themselves are NOT in
                // `groovy_count_token_condition`'s match list —
                // they route through
                // `groovy_walk_for_conditions::AMPAMP|PIPEPIPE`,
                // which scores each operand of the parent
                // BinaryExpression through `groovy_count_condition`.
                // An operand pays one condition unless it scores
                // itself. For `x && true`: Identifier x
                // (+1) + BooleanLiteral true (+1) = 2. For
                // `false || x`: BooleanLiteral false (+1) +
                // Identifier x (+1) = 2. Total 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.assignments_sum(), 0);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_methods_arguments_with_conditions() {
        // Mirror of `java_methods_arguments_with_conditions`: a
        // unary `!x` inside an argument list must count both the
        // method invocation as a branch AND the unary as a
        // condition. The `ArgumentList | ArgumentList2` arm in
        // `impl Abc for GroovyCode` is what exercises this.
        check_metrics::<GroovyParser>(
            "void f(boolean a, boolean b, boolean c) {
                m1(a)
                m1(!a)
                m2(!a, !b)
            }",
            "foo.groovy",
            |metric| {
                // 3 method invocations (m1, m1, m2) — each fires the
                // branches arm.
                assert_eq!(metric.abc.branches_sum(), 3);
                // Three `!` unaries — `m1(!a)` and the two args of
                // `m2(!a, !b)` — each contribute one condition via
                // the ArgumentList inspection.
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_return_with_conditions() {
        // Mirror of `java_return_with_conditions`: a parenthesised
        // or unary expression inside `return` flows through the
        // `ReturnStatement` arm to `groovy_count_negated`.
        check_metrics::<GroovyParser>(
            "boolean f(boolean a) {
                return (a)
            }
            boolean g(boolean a) {
                return !a
            }",
            "foo.groovy",
            |metric| {
                // Only one of the two return forms surfaces a
                // condition: `return !a` hits the UnaryExpression
                // path and adds one; `return (a)` reaches
                // `groovy_count_negated` but no `!` proves the inner
                // identifier `a` boolean, so no condition is added.
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_for_with_variable_declaration() {
        // Classical `for (int i = 0; cond; i++)` form. The init
        // slot's `int i = 0` is suppressed from assignments by the
        // `LocalVariableDeclaration` push/pop dance; the `i++` in
        // the update slot contributes one assignment via the
        // `PLUSPLUS` arm. The condition `i < 10` flows through the
        // `ForStatement` arm.
        check_metrics::<GroovyParser>(
            "void f() {
                for (int i = 0; i < 10; i++) {
                    println(i)
                }
            }",
            "foo.groovy",
            |metric| {
                // `int i = 0` fires the EQ arm + `i++` fires the
                // PLUSPLUS arm = 2 assignments.
                assert_eq!(metric.abc.assignments_sum(), 2);
                // `i < 10` is one condition (the LT arm).
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    /// The existing `for` test uses `i < 10`, which the `LT` token arm
    /// counts on its own — `groovy_walk_for_statement` never
    /// contributes there, so it stayed uncovered. A bare-identifier
    /// condition has no comparison token, so the count can only come
    /// from the walker.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_for_with_bare_identifier_condition() {
        check_metrics::<GroovyParser>(
            "void f(boolean go) {
                for (int i = 0; go; i++) {
                    println(i)
                }
            }",
            "foo.groovy",
            |metric| {
                // `go` is the whole condition and counts once.
                assert_eq!(metric.abc.conditions_sum(), 1);
                // `int i = 0` (EQ) + `i++` (PLUSPLUS) = 2, as in
                // `groovy_for_with_variable_declaration`.
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    /// The same slot with the initialiser hoisted out of the header.
    /// Under the pre-#1276 positional cascade this was a distinct code
    /// path — the condition moved from child(4) to child(3) — and the
    /// pair is kept as a shape guard now that the walker reads the
    /// `condition` field and cannot see the difference.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_for_with_empty_initializer_counts_the_condition() {
        check_metrics::<GroovyParser>(
            "void f(boolean go) {
                int i = 0
                for (; go; i++) {
                    println(i)
                }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                // `int i = 0` (EQ) + `i++` (PLUSPLUS), as above — the
                // initialiser just moved out of the loop header.
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    /// Issue #1276 changed Groovy's answer here, exactly as it changed
    /// Java's: the positional cascade counted a `;` / `)` landing at
    /// child(4) as a vacuously-true condition, so `for (;;)` scored
    /// one. An omitted test is not a decision, and every other impl
    /// scores it zero. See `java_empty_for_condition_counts_nothing`.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_empty_for_condition_counts_nothing() {
        check_metrics::<GroovyParser>("void f() { for (;;) { break } }", "foo.groovy", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 0);
        });
        // The second spelling that moved. Unlike Java's, Groovy's
        // `local_variable_declaration` does not swallow its `;`, so the
        // old cascade found `;` at child(3) and `;` at child(4) here
        // too, and counted one.
        check_metrics::<GroovyParser>(
            "void f() { for (int i = 0; ; i++) { break } }",
            "foo.groovy",
            |metric| assert_eq!(metric.abc.conditions_sum(), 0),
        );
    }

    /// The cascade's other defect, shared with Java: a comment in the
    /// header shifted every child index, so the condition went unread.
    /// Reading the `condition` field cannot shift.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_for_condition_survives_a_header_comment() {
        check_metrics::<GroovyParser>(
            "void f(boolean go) { for (; /* n */ go; ) { break } }",
            "foo.groovy",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
        // Unchanged control: the same loop without the comment.
        check_metrics::<GroovyParser>(
            "void f(boolean go) { for (; go; ) { break } }",
            "foo.groovy",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
    }

    /// C#'s `csharp_walk_for_statement` reads the loop condition off
    /// the named `condition` field and scores a parenthesised or
    /// `!`-prefixed one through `csharp_count_condition`. Every other
    /// C# `for` test uses a comparison (`i < n`), which the `LT` token
    /// arm counts without entering the walker.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_for_with_negated_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(bool done) {
                    for (int i = 0; !done; i++) { System.Console.WriteLine(i); }
                }
            }",
            "foo.cs",
            |metric| {
                // `!done` unwraps to the `done` terminal: one condition,
                // and no comparison token to double-count it.
                assert_eq!(metric.abc.conditions_sum(), 1);
                // `int i = 0` + `i++`.
                assert_eq!(metric.abc.assignments_sum(), 2);
                assert_eq!(metric.abc.branches_sum(), 1);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_eq_arm_counts_outside_final_declarations() {
        // Bare reassignment of an already-declared variable: the `=`
        // belongs to no `final` declaration, so it counts. Mirrors
        // `java_eq_arm_counts_outside_final_declarations`.
        check_metrics::<GroovyParser>(
            "void f(int x) {
                x = 42
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_final_field_initializer_does_not_suppress_the_closure_body() {
        // The Groovy spelling of
        // `java_final_initializer_does_not_suppress_the_assignments_inside_it`:
        // a `final` field's closure body opens no space, and the sentinel
        // stack suppressed its `x = 1` with the declarator's own `=`.
        check_metrics::<GroovyParser>(
            "class K {
                int x
                final Closure c = { x = 1 }
                Closure d = { x = 2 }
                final int q = 3
            }",
            "foo.groovy",
            |metric| {
                // `x = 1`, `d = {…}`, `x = 2`; the two `final`
                // initializers are suppressed. Pre-fix: 2.
                assert_eq!(metric.abc.assignments_sum(), 3);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_final_local_is_an_error_at_the_pinned_grammar() {
        // `groovy_eq_initializes_final_binding` lists
        // `local_variable_declaration` for symmetry with Java, but at
        // dekobon-tree-sitter-groovy 0.2.2 a `final` local never
        // reaches it: the parser emits an `ERROR` node for the
        // declaration, with or without a terminator, so both of its `=`
        // tokens count. This pins the grammar limitation so a bump that
        // starts parsing the local shows up here rather than as a silent
        // change in what the predicate suppresses.
        let source = b"class K { int x; def m() { final int a = 0; x = 1 } }";
        let parser = GroovyParser::new(
            source.to_vec(),
            &std::path::PathBuf::from("foo.groovy"),
            None,
        );
        assert!(
            ast_has_kind_id(&parser, u16::MAX),
            "a `final` local should still parse to an ERROR node; if the grammar \
             now accepts it, re-derive the local half of the predicate",
        );
        check_metrics::<GroovyParser>(
            "class K { int x; def m() { final int a = 0; x = 1 } }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_const_initializer_shapes() {
        // `csharp_eq_initializes_const_binding` reads the `const`
        // through the `modifier` node one hop above the
        // `variable_declaration`, for a local and a field alike, behind
        // other modifiers; `readonly` is not `const` and its initializer
        // counts. A lambda's body opens its own space in C#, so unlike
        // Java there was never a nested `=` to leak — the row pins that
        // the structural rule keeps the count the sentinel gave.
        check_metrics::<CsharpParser>(
            "class K {
                int x;
                private const int Q = 1;
                public static readonly int R = 2;
                void M() { const int q = 3; System.Action a = () => { x = 4; }; }
            }",
            "foo.cs",
            |metric| {
                // `R = 2`, `a = () => …`, `x = 4`.
                assert_eq!(metric.abc.assignments_sum(), 3);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_constant_declarations() {
        check_metrics::<CsharpParser>(
            "class A {
                private const int X1 = 0, Y1 = 0;
                public const float PI = 3.14f;
                const string HELLO = \"Hello,\";
                protected string world = \" world!\";
                public float e = 2.718f;
                private int x2 = 1, y2 = 2;
                void M() {
                    const int Z1 = 0, Z2 = 0, Z3 = 0;
                    const float T = 0.0f;
                    int z1 = 1, z2 = 2, z3 = 3;
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_declarations_with_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                bool a = (1 == 2);
                bool b = (1 < 2);
                bool c = !true;
                bool d = !false;
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_assignments_with_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                void M() {
                    int a = 0;
                    a += 1;
                    a -= 2;
                    a *= 3;
                    a /= 4;
                    a %= 5;
                    a++;
                    a--;
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_methods_arguments_with_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(int x, int y) {
                    F(x == y, x < y, !x.Equals(y));
                }
                void F(bool a, bool b, bool c) {}
            }",
            "foo.cs",
            |metric| {
                // expected: `==` +1, `<` +1, and the negated argument
                // `!x.Equals(y)` +1 — it scored 0 until #1537, when every
                // C# argument reached the peel still in its `argument`
                // wrapper.
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // #1537: every C# argument is wrapped in an `argument` node that the
    // negation peel declined, so a negated argument scored 0 where every
    // other C-family language scores 1. Each row is a C# call next to its
    // Java twin, which takes the expected value from outside the fix.
    #[cfg(all(feature = "csharp", feature = "java"))]
    #[test]
    fn csharp_negated_call_argument_matches_java() {
        let rows = [
            ("G(!a);", "g(!a);", 1),
            ("G((!a));", "g((!a));", 1),
            ("G(!a, !b);", "g(!a, !b);", 2),
            ("G(a, !b);", "g(a, !b);", 1),
            ("new B(!a);", "new B(!a);", 1),
            ("G(-a);", "g(-a);", 0),
            // A negated comparison pays once, for its `>`; a chain pays
            // per operand. Neither argument may pay again as a negation.
            ("G(!(a > b));", "g(!(a > b));", 1),
            ("G(!a && b);", "g(!a && b);", 2),
        ];
        for (csharp, java, expected) in rows {
            let cs = abc_conditions(
                LANG::Csharp,
                &format!("class A {{ void M() {{ {csharp} }} }}"),
            );
            let jv = abc_conditions(LANG::Java, &format!("class A {{ void m() {{ {java} }} }}"));
            assert_eq!(jv, expected, "Java twin `{java}`");
            assert_eq!(cs, expected, "C# `{csharp}` against Java `{java}`");
        }
    }

    // The C#-only spellings around an argument. The value is the
    // `argument` wrapper's last operand, so a named-argument label, a
    // passing-mode keyword or a comment before it must not hide it.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_negated_call_argument_spellings() {
        let rows = [
            // A named argument: the value follows `name` and `:`.
            ("class A { void M() { G(name: !a); } }", 1),
            // A comment between the label and the value sits inside the
            // `argument` wrapper, so a positional read of the value lands
            // on it. A comment before or after a whole argument is a
            // sibling of the wrapper instead and never reaches this read.
            ("class A { void M() { G(name: /*c*/ !a); } }", 1),
            // `ref` / `out` / `in` precede a variable, never a negation. A
            // control only: 0 is also what the pre-#1537 walk scored, so
            // this row cannot fail for any defect the fix addresses.
            ("class A { void M() { G(ref x, out var y, in z); } }", 0),
            // The lambda arm pays for its `!a` body; the argument holding
            // the lambda is not a negation and must not pay again.
            ("class A { void M() { G(x => !a); } }", 1),
            // `: base(!a)` — a `constructor_initializer`'s list reaches the
            // walk like any call's.
            ("class A : B { A(bool a) : base(!a) {} }", 1),
            // The two primary-constructor base calls: the record nests its
            // list in a `primary_constructor_base_type`, the class's list
            // is the branch node itself and is scored on the branch path.
            ("record R(bool a) : Base(!a);", 1),
            ("class S(bool a) : Base(!a) {}", 1),
            // An indexer's `bracketed_argument_list` is not a call, as
            // Java's array index is not.
            ("class A { void M() { var q = o[!a]; } }", 0),
        ];
        for (src, expected) in rows {
            assert_eq!(abc_conditions(LANG::Csharp, src), expected, "{src}");
        }
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_if_single_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(int x) {
                    if (x > 0) { System.Console.WriteLine(\"a\"); }
                    if (x < 0) { System.Console.WriteLine(\"b\"); }
                    if (x == 0) { System.Console.WriteLine(\"c\"); }
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_if_multiple_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(int x, int y) {
                    if (x > 0 && y > 0) { System.Console.WriteLine(\"a\"); }
                    if (x < 0 || y < 0) { System.Console.WriteLine(\"b\"); }
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_while_and_do_while_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(int x) {
                    while (x > 0) { x--; }
                    do { x++; } while (x < 10);
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_return_with_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                bool M(int x) {
                    return (x > 0);
                }
                bool N(int x) {
                    return !(x < 0);
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    // C# `switch` *expression* arms scored zero ABC conditions before
    // #456 — they carry no `case` / `default` token, so the token-driven
    // `csharp_count_token_condition` never saw them, even though C#
    // cyclomatic counts each non-discard arm. Revert-verified: adding the
    // gated `SwitchExpressionArm` arm is what lifts this from 0 to 2. The
    // bare `_ =>` discard arm is excluded (the `default:` analogue),
    // mirroring the cyclomatic gate (lesson 11).
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_expression_arm_counts_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                int M(int x) {
                    return x switch { 1 => 10, 2 => 20, _ => 0 };
                }
            }",
            "foo.cs",
            |metric| {
                // arm `1 =>` (+1) + arm `2 =>` (+1) + `_ =>` discard (+0).
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // Cross-language parity (lesson 11): a C# `switch` expression and the
    // equivalent Java arrow-`switch` must report the same ABC condition
    // count on equivalent code. Both have two concrete case arms and no
    // fallback arm, so both must count exactly 2. `check_metrics` takes a
    // non-capturing `fn` pointer, so the shared expected value (2) is
    // asserted in each callback rather than compared across closures; the
    // matching constant is what enforces parity. This guards against the
    // C# fix drifting away from the Java arrow-case treatment.
    #[cfg(all(feature = "csharp", feature = "java"))]
    #[test]
    fn csharp_java_switch_arm_abc_parity() {
        // C# switch expression: two arms, no fallback → 2 conditions.
        check_metrics::<CsharpParser>(
            "class A {
                int M(int x) {
                    return x switch { 1 => 10, 2 => 20 };
                }
            }",
            "foo.cs",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );

        // Equivalent Java arrow-`switch`: two case arms, no default → 2.
        check_metrics::<JavaParser>(
            "class A {
                int m(int x) {
                    return switch (x) { case 1 -> 10; case 2 -> 20; };
                }
            }",
            "foo.java",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    // Issue #469: the `default` arm of a C-family `switch` is the
    // unconditional fallthrough and must NOT count as an ABC condition,
    // mirroring cyclomatic — which counts only the `Case` arms, never
    // the `Default` token.
    //
    // expected: each fixture is a single function whose switch has two
    // concrete `case` arms plus one `default`. ABC must count exactly
    // the two case arms (conditions = 2), matching cyclomatic's two
    // case-arm decisions. Pre-fix, every language below scored 3 (the
    // `Default` token leaked into the condition tally) — revert-verified
    // against the pre-#469 condition arms. We anchor on the integer
    // `conditions_sum()` headline (the value the public JSON serializes;
    // float magnitude is bit-brittle and excluded by the snapshot
    // policy). The cyclomatic side is pinned separately in
    // `java_csharp_cpp_switch_default_cyclomatic_parity` below, where
    // the per-space `cyclomatic()` decision count is isolated.
    #[cfg(feature = "java")]
    #[test]
    fn java_switch_default_not_a_condition() {
        // Classic statement `default:`.
        check_metrics::<JavaParser>(
            "class A {
                int m(int x) {
                    switch (x) { case 1: return 1; case 2: return 2; default: return 0; }
                }
            }",
            "foo.java",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
        // Arrow `default ->` — shares the same `Default` token.
        check_metrics::<JavaParser>(
            "class A {
                int m(int x) {
                    return switch (x) { case 1 -> 1; case 2 -> 2; default -> 0; };
                }
            }",
            "foo.java",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    // Over-exclusion guard (issue #469): a statement `switch` with two
    // `case` arms and NO `default` must still count both cases. This
    // pins that the fix excludes only the `Default` token, never a
    // `Case` arm — the count is identical before and after #469 (two
    // cases → 2), so it would catch a fix that over-eagerly dropped a
    // real case (e.g. treating the trailing case as a fallthrough).
    // expected: case 1 (+1) + case 2 (+1) = 2.
    #[cfg(feature = "java")]
    #[test]
    fn java_switch_without_default_counts_all_cases() {
        check_metrics::<JavaParser>(
            "class A {
                int m(int x) {
                    switch (x) { case 1: return 1; case 2: return 2; }
                    return -1;
                }
            }",
            "foo.java",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_default_not_a_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                int M(int x) {
                    switch (x) { case 1: return 1; case 2: return 2; default: return 0; }
                }
            }",
            "foo.cs",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    /// 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 an ABC condition it does not earn —
    /// an unconditional jump to an arm is not a decision.
    ///
    /// `jmp` differs from `ctl` by exactly one statement, so the
    /// `goto case` is the only thing that can separate their scores
    /// (`.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).
    ///
    /// [`assert_every_member_scores`] covers cyclomatic as well as ABC,
    /// through its per-member §8 parity assertion, and would catch the
    /// gate being removed from *either* side alone: dropping ABC's puts
    /// `jmp` at conditions 3 against the asserted 2, and dropping
    /// cyclomatic's leaves conditions 2 against a decision count of 3.
    /// Removing both restores the parity at `3 == 4 - 1` and is caught by
    /// the conditions value, which is why 2 is named rather than derived.
    ///
    /// The `Case` anchor is the second axis. Every member scores 2 from
    /// its two arms alone, so deleting `goto case 2;` 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_condition() {
        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::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_every_member_scores(
                &space.spaces[0],
                3,
                2,
                "one condition per `case` arm, none for a `goto` into one",
            );
        });
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_switch_default_not_a_condition() {
        // C++ (and plain C, which shares this grammar) already excluded
        // `default`; this pins the cross-language parity invariant.
        check_metrics::<CppParser>(
            "void f(int x) {
                 switch (x) { case 1: return; case 2: return; default: return; }
             }",
            "foo.cpp",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    #[cfg(feature = "objc")]
    #[test]
    fn objc_abc() {
        // ObjC ABC reuses the C/C++ walker with two additions: a message
        // send `[obj msg]` is a call (B), and `@try` / `@catch` count as
        // conditions (C) like C++ try/catch.
        //   A: `int total = 0`, `int i = 0`, `i++`, `total = total + …`,
        //      `total = -1` = 5.
        //   B: `[self valueAt:i]`, `[self risky]` = 2 message sends.
        //   C: `i < n`, `@try`, `@catch`, `total >= 0` = 4.
        check_metrics::<ObjcParser>(
            "@implementation Foo\n\
             - (int)bar:(int)n {\n\
                 int total = 0;\n\
                 for (int i = 0; i < n; i++) {\n\
                     total = total + [self valueAt:i];\n\
                 }\n\
                 @try {\n\
                     [self risky];\n\
                 } @catch (NSException *e) {\n\
                     total = -1;\n\
                 }\n\
                 if (total >= 0) {\n\
                     return total;\n\
                 }\n\
                 return 0;\n\
             }\n\
             @end\n",
            "foo.m",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 5);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 4);
            },
        );
    }

    #[cfg(feature = "objc")]
    #[test]
    fn objc_abc_conditions() {
        // Exercises the condition-slot arms shared with C/C++: a `while`
        // head, a `&&` chain, a `do … while` trailing condition, and a
        // `return <comparison>`. ObjC routes these through the same
        // grammar-agnostic `cpp_inspect_*` helpers.
        //   A: `p++`, `p--` = 2.   B: no calls = 0.
        //   C: `p != 0`, `*p > 0`, `*p < 9`, `*p == 0` = 4.
        check_metrics::<ObjcParser>(
            "@implementation Foo\n\
             - (int)g:(int *)p {\n\
                 while (p != 0 && *p > 0) {\n\
                     p++;\n\
                 }\n\
                 do {\n\
                     p--;\n\
                 } while (*p < 9);\n\
                 return *p == 0;\n\
             }\n\
             @end\n",
            "foo.m",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 4);
            },
        );
    }

    #[cfg(feature = "objc")]
    #[test]
    fn objc_abc_message_send_unary_condition() {
        // A negated boolean passed as a message-send argument is a unary
        // condition (Fitzpatrick Rule 9), the same as in a C-call argument.
        // Message args are direct children of `message_expression` (no
        // `argument_list`), so they are inspected in the `MessageExpression`
        // arm. Here: `[self use:!a]` (1 call + 1 unary condition) +
        // `cFunc(!a)` (1 call + 1 unary condition) → B=2, C=2.
        check_metrics::<ObjcParser>(
            "@implementation Foo\n\
             - (void)bar:(int)a {\n\
                 [self use:!a];\n\
                 cFunc(!a);\n\
             }\n\
             @end\n",
            "foo.m",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "objc")]
    #[test]
    fn objc_message_send_is_a_bool_terminal_in_condition_slots() {
        // `[obj ok]` is Objective-C's call, so in a condition slot it is
        // the unary condition `ok()` is (Fitzpatrick Rule 9). Until
        // `message_expression` joined the former `cpp_bool_terminal_kinds!` every
        // row here scored zero conditions where its C-call twin scored
        // one — and #1276's `for` slot inherited the gap. Each row is a
        // message send as the *whole* slot (grammar-dispatch §11: a
        // comparison would be counted by its own operator arm anyway),
        // and branches are asserted beside conditions so the arm cannot
        // be read as counting the call twice. The last three are the
        // over-count guards: a value position counts nothing, as `ok()`'s
        // does not.
        let cases = [
            ("if ([self ok]) {}", 1, 1),
            ("while (![self ok]) {}", 1, 1),
            ("do {} while ([self ok]);", 1, 1),
            ("for (; [self ok]; ) {}", 1, 1),
            ("x = [self ok] ? 1 : 2;", 2, 1),
            ("if ([self ok] && [o ok]) {}", 2, 2),
            ("return [self ok];", 0, 1),
            ("[self use:[self ok]];", 0, 2),
            ("[self use:![self ok]];", 1, 2),
        ];
        let mut ran = 0;
        for (body, conditions, branches) in cases {
            let src = format!("@implementation Foo\n- (int)bar {{\n    {body}\n}}\n@end\n");
            let abc = metrics_verbatim(
                LANG::Objc,
                src.as_bytes(),
                MetricsOptions::default().with_only(&[crate::Metric::Abc]),
            )
            .abc;
            assert_eq!(abc.conditions_sum(), conditions, "`{body}` conditions");
            assert_eq!(abc.branches_sum(), branches, "`{body}` branches");
            ran += 1;
        }
        assert_eq!(ran, cases.len());
        // Both answers are present, so a walker stuck at 0 or at 1 cannot
        // pass half the table silently.
        assert!(cases.iter().any(|&(_, c, _)| c == 0));
        assert!(cases.iter().any(|&(_, c, _)| c == 2));
    }

    #[cfg(feature = "objc")]
    #[test]
    fn objc_message_send_condition_agrees_with_c_call() {
        // The intra-ObjC parity C++ cannot express: a message send and a
        // C call in the same slot score alike. Non-degenerate by the
        // `assert_eq!(…, 1)` on the reference.
        for (send, call) in [
            ("if ([a ok]) {}", "if (ok()) {}"),
            ("for (; [a ok]; ) {}", "for (; ok(); ) {}"),
            ("x = [a ok] ? 1 : 2;", "x = ok() ? 1 : 2;"),
        ] {
            let wrap =
                |body: &str| format!("@implementation Foo\n- (int)bar {{\n    {body}\n}}\n@end\n");
            let reference = abc_conditions(LANG::Objc, &wrap(call));
            assert!(reference >= 1, "`{call}` must count at least the slot");
            assert_eq!(
                abc_conditions(LANG::Objc, &wrap(send)),
                reference,
                "`{send}`"
            );
        }
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_switch_default_not_a_condition() {
        check_metrics::<GroovyParser>(
            "class A {
                int m(int x) {
                    switch (x) { case 1: return 1; case 2: return 2; default: return 0 }
                }
            }",
            "foo.groovy",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn js_switch_default_not_a_condition() {
        check_metrics::<JavascriptParser>(
            "function f(x) {
                 switch (x) { case 1: return 1; case 2: return 2; default: return 0; }
             }",
            "foo.js",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn ts_switch_default_not_a_condition() {
        check_metrics::<TypescriptParser>(
            "function f(x: number): number {
                 switch (x) { case 1: return 1; case 2: return 2; default: return 0; }
             }",
            "foo.ts",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    // Cross-language parity (lesson 11): the equivalent statement-`switch`
    // with a `default` arm reports the same ABC condition count across
    // Java / C# / C++. All three have two concrete case arms plus a
    // fallthrough `default`, so all three must count exactly 2 conditions
    // (the `default` excluded). `check_metrics` takes a non-capturing
    // `fn` pointer, so the shared expected value is asserted in each
    // callback; the matching constant is what enforces parity.
    #[cfg(all(feature = "cpp", feature = "csharp", feature = "java"))]
    #[test]
    fn java_csharp_cpp_switch_default_abc_parity() {
        check_metrics::<JavaParser>(
            "class A {
                int m(int x) {
                    switch (x) { case 1: return 1; case 2: return 2; default: return 0; }
                }
            }",
            "foo.java",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
        check_metrics::<CsharpParser>(
            "class A {
                int M(int x) {
                    switch (x) { case 1: return 1; case 2: return 2; default: return 0; }
                }
            }",
            "foo.cs",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
        check_metrics::<CppParser>(
            "void f(int x) {
                 switch (x) { case 1: return; case 2: return; default: return; }
             }",
            "foo.cpp",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    // Pins the ABC-vs-cyclomatic agreement the fix is about (lesson 11):
    // on the method's own function space, the cyclomatic decision count
    // (`cyclomatic()` minus the per-space base of 1) must equal the ABC
    // `conditions()` for the same switch. Both must be 2 — the two case
    // arms — with the `default` excluded from each. Revert-verified: pre-
    // #469 ABC `conditions()` was 3 here while cyclomatic stayed at 2.
    #[cfg(all(feature = "cpp", feature = "csharp", feature = "java"))]
    #[test]
    fn java_csharp_cpp_switch_default_cyclomatic_parity() {
        check_func_space::<JavaParser, _>(
            "class A {
                int m(int x) {
                    switch (x) { case 1: return 1; case 2: return 2; default: return 0; }
                }
            }",
            "foo.java",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 2),
        );
        check_func_space::<CsharpParser, _>(
            "class A {
                int M(int x) {
                    switch (x) { case 1: return 1; case 2: return 2; default: return 0; }
                }
            }",
            "foo.cs",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 2),
        );
        check_func_space::<CppParser, _>(
            "void f(int x) {
                 switch (x) { case 1: return; case 2: return; default: return; }
             }",
            "foo.cpp",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 2),
        );
    }

    // Issue #473: PHP `switch` `default:` (`DefaultStatement`) is the
    // unconditional fallthrough, not a condition. ABC `conditions()` must
    // equal the cyclomatic decision count (`cyclomatic() - 1`) on the
    // function's own space — both 2 for the two `case` arms, with the
    // `default` excluded. Revert-verified: re-adding `DefaultStatement` to
    // the PHP ABC condition arm makes `conditions()` 3 here while cyclomatic
    // stays at 2, failing the invariant.
    #[cfg(feature = "php")]
    #[test]
    fn php_switch_default_not_a_condition() {
        check_func_space::<PhpParser, _>(
            "<?php
            function f($x) {
                switch ($x) {
                    case 1: return 1;
                    case 2: return 2;
                    default: return 0;
                }
            }",
            "foo.php",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 2),
        );
    }

    // Issue #473: PHP `match` `default =>` (`MatchDefaultExpression`) is the
    // unconditional fallthrough, mirroring the switch `default:` case above.
    // ABC `conditions()` must equal the cyclomatic decision count
    // (`cyclomatic() - 1`) — both 2 for the two non-default match arms.
    // Revert-verified: re-adding `MatchDefaultExpression` to the PHP ABC
    // condition arm makes `conditions()` 3 here while cyclomatic stays at 2.
    #[cfg(feature = "php")]
    #[test]
    fn php_match_default_not_a_condition() {
        check_func_space::<PhpParser, _>(
            "<?php
            function g($x) {
                return match ($x) {
                    1 => \"a\",
                    2 => \"b\",
                    default => \"z\",
                };
            }",
            "foo.php",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 2),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_if_bare_identifier_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(bool x) {
                    if (x) { System.Console.WriteLine(\"a\"); }
                }
            }",
            "foo.cs",
            |metric| {
                // `if (x)` contributes 1 condition (bare identifier).
                // `System.Console.WriteLine(...)` is the only call → 1 branch.
                // `*_sum()` is what the public JSON serializes as the
                // headline value (see `crate::wire::Abc`).
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.assignments_sum(), 0);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_while_bare_identifier_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(bool x) {
                    while (x) { x = false; }
                }
            }",
            "foo.cs",
            |metric| {
                // `while (x)` contributes 1 condition; `x = false` is 1 assignment.
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 0);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_do_while_bare_identifier_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(bool x) {
                    do { x = true; } while (x);
                }
            }",
            "foo.cs",
            |metric| {
                // `do { ... } while (x)` contributes 1 condition;
                // `x = true` is 1 assignment.
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 0);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_if_unary_not_condition() {
        // Two cases share one test:
        //
        //   if (!x) { … }  — the `if` predicate is a boolean slot, so
        //   `csharp_count_condition` pays for it once the peel
        //   (`csharp_wrapper_operand`) has taken the `!` off; the
        //   slot would pay without the `!` too.
        //
        //   return !x;  — a `return` value is not a slot, so the `!`
        //   is the *only* thing that makes the operand count, through
        //   `csharp_count_negated`. Asserting the `return !x;`
        //   case isolates the negation path from the slot path.
        check_metrics::<CsharpParser>(
            "class A {
                void M(bool x) {
                    if (!x) { System.Console.WriteLine(\"a\"); }
                }
                bool N(bool x) {
                    return !x;
                }
            }",
            "foo.cs",
            |metric| {
                // `if (!x)` contributes 1 condition (the slot pays for the
                // peeled `x`). `return !x;` contributes 1 condition (not a
                // slot — the unary `!` is what makes `x` count).
                // → 2 conditions total. 1 branch from WriteLine().
                assert_eq!(metric.abc.conditions_sum(), 2);
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.assignments_sum(), 0);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_if_double_parenthesized_condition() {
        // Audit-tests follow-up: with only the
        // `csharp_prefix_unary_expr_kinds!()` arm covered by
        // `csharp_if_unary_not_condition`, the
        // `csharp_paren_expr_kinds!()` delegation arm in
        // `csharp_count_condition` was a pure dead-code candidate —
        // disabling it caused zero existing tests to fail (verified
        // 2026-05-26).
        //
        // `if ((x))` puts a `ParenthesizedExpression` at child(2) of
        // the IfStatement (child(1) is the literal `(`, child(2) is
        // the inner parenthesised expression, child(3) is the literal
        // `)`). `csharp_count_condition` must peel that parenthesis
        // (`csharp_wrapper_operand`) down to the inner Identifier,
        // which does not score itself, so the slot pays once.
        check_metrics::<CsharpParser>(
            "class A {
                void M(bool x) {
                    if ((x)) { System.Console.WriteLine(\"a\"); }
                }
            }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.assignments_sum(), 0);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_bool_returning_terminal_kinds_count() {
        // Regression for issue #372 (lesson #19): before the fix,
        // `csharp_count_condition` / the former `csharp_inspect_container`
        // only recognised invocation / identifier / boolean literal as
        // terminal-bool operands, so the five idiomatic boolean
        // expressions in the `if (...)` slots below silently scored
        // zero conditions:
        //
        //   - `cfg.flag`        — MemberAccessExpression
        //   - `await c.Check()` — AwaitExpression
        //   - `(bool)v`         — CastExpression
        //   - `v is not null`   — IsPatternExpression
        //   - `flags[0]`        — ElementAccessExpression
        //
        // The `is` test has since moved out of the former terminal set to an
        // unconditional arm (#1461), so it no longer depends on the
        // slot to be counted. The total is unchanged, which is the
        // point of that change rather than an accident of it.
        //
        // expected: 5 conditions (one per `if`), 0 assignments,
        // 1 branch (the single `c.Check()` invocation; the other
        // `if`-condition expressions are not invocations).
        check_metrics::<CsharpParser>(
            "using System.Threading.Tasks;
            class A {
                async Task M(object v, bool[] flags, Cfg cfg, C c) {
                    if (cfg.flag) { }
                    if (await c.Check()) { }
                    if ((bool)v) { }
                    if (v is not null) { }
                    if (flags[0]) { }
                }
            }
            class Cfg { public bool flag; }
            class C { public Task<bool> Check() => null; }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 5);
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 1);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_if_method_call_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(string s) {
                    if (s.StartsWith(\"x\")) { System.Console.WriteLine(\"a\"); }
                }
            }",
            "foo.cs",
            |metric| {
                // `if (s.StartsWith("x"))` contributes 1 condition
                // (InvocationExpression) plus 1 branch for the call itself,
                // plus 1 branch for WriteLine.
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.assignments_sum(), 0);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_if_while_boolean_literal_condition() {
        // Regression for #371: the tree-sitter-c-sharp grammar wraps a
        // bare `true` / `false` literal used as the condition of
        // `if` / `while` / `do` / `?:` in a `boolean_literal` node,
        // not the leaf `true` / `false` tokens. `csharp_count_condition`
        // must therefore match `BooleanLiteral` (the wrapper),
        // mirroring the existing `csharp_walk_for_statement` arm.
        // Without that, every literal-condition statement scored 0
        // conditions. The `&&` / `||` chain-operand slot is covered
        // separately by `csharp_short_circuit_with_boolean_literal_operand`
        // and the negated-operand path (`csharp_count_negated`) by
        // `csharp_declarations_with_conditions` (`!true` / `!false`).
        check_metrics::<CsharpParser>(
            "class A {
                void M() {
                    if (true) { System.Console.WriteLine(\"a\"); }
                    if (false) { System.Console.WriteLine(\"b\"); }
                    while (true) { break; }
                    do { break; } while (false);
                    int t = true ? 1 : 0;
                }
            }",
            "foo.cs",
            |metric| {
                // Five literal-condition statements contribute 5
                // `BooleanLiteral` conditions (one per if/if/while/
                // do-while/ternary), plus the ternary's `?` token
                // adds one more via `csharp_count_token_condition`
                // → 6 total. The two `System.Console.WriteLine`
                // calls contribute 2 branches; the `int t = …`
                // initializer contributes 1 assignment.
                assert_eq!(metric.abc.conditions_sum(), 6);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.assignments_sum(), 1);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_short_circuit_with_boolean_literal_operand() {
        // Regression for #371 (companion to
        // `csharp_if_while_boolean_literal_condition`): a bare
        // `true` / `false` operand of `&&` / `||` is a chain-operand
        // slot scored through `csharp_count_condition`. A
        // `BooleanLiteral` does not score itself, so the slot pays for
        // it — otherwise the operand silently scores zero.
        check_metrics::<CsharpParser>(
            "class A {
                void M(bool x) {
                    if (x && true) { System.Console.WriteLine(\"a\"); }
                    if (false || x) { System.Console.WriteLine(\"b\"); }
                }
            }",
            "foo.cs",
            |metric| {
                // `&&` and `||` themselves are NOT in
                // `csharp_count_token_condition`'s match list — they
                // route through `csharp_walk_for_conditions::AMPAMP|
                // PIPEPIPE`, which scores each operand of the parent
                // BinaryExpression through `csharp_count_condition`.
                // An operand pays one condition unless it scores
                // itself. For
                // `x && true`: 1 (Identifier x) + 1 (BooleanLiteral
                // true) = 2. For `false || x`: 1 (BooleanLiteral
                // false) + 1 (Identifier x) = 2. Total 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.assignments_sum(), 0);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_return_without_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                int M() { return 42; }
                string N() { return \"hi\"; }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_lambda_expressions_return_with_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                public void M() {
                    System.Func<int, bool> f = x => (x > 0);
                    System.Func<int, bool> g = x => !(x < 0);
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_for_with_variable_declaration() {
        check_metrics::<CsharpParser>(
            "class A {
                void M() {
                    for (int i = 0; i < 10; i++) {
                        System.Console.WriteLine(i);
                    }
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_for_without_variable_declaration() {
        check_metrics::<CsharpParser>(
            "class A {
                void M() {
                    int i;
                    for (i = 0; i < 10; i++) {
                        System.Console.WriteLine(i);
                    }
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_for_identifier_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                void M(bool ready) {
                    for (; ready ;) { }
                }
            }",
            "foo.cs",
            |metric| {
                // expected: assignments=0 (no `=` / `++` / `--`),
                // branches=0 (no invocation / object creation),
                // conditions=1 (bare-identifier for-loop condition).
                // Averages divide by 3 spaces (top-level + class + method).
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 0,
                  "conditions": 1,
                  "magnitude": 1.0,
                  "value": 0.0,
                  "assignments_average": 0.0,
                  "branches_average": 0.0,
                  "conditions_average": 0.3333333333333333,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 0,
                  "branches_max": 0,
                  "conditions_min": 0,
                  "conditions_max": 1
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_for_invocation_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                bool Ok() { return true; }
                void M() {
                    for (; Ok() ;) { }
                }
            }",
            "foo.cs",
            |metric| {
                // expected: assignments=0, branches=1 (the `Ok()` call),
                // conditions=1 (invocation as for-loop condition).
                // Averages divide by 4 spaces (top-level + class + two
                // methods).
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 1,
                  "conditions": 1,
                  "magnitude": 1.4142135623730951,
                  "value": 0.0,
                  "assignments_average": 0.0,
                  "branches_average": 0.25,
                  "conditions_average": 0.25,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 0,
                  "branches_max": 1,
                  "conditions_min": 0,
                  "conditions_max": 1
                }
                "#
                );
            },
        );
    }

    // Regression coverage for #279: the C# grammar wraps a literal
    // `true` / `false` for-loop condition in a `boolean_literal` node.
    // The `BooleanLiteral` arm in the `ForStatement` dispatch must
    // attribute one condition; without it, `for (; true ;)` would
    // contribute 0 (the bug fixed by this commit also affected this
    // shape).
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_for_boolean_literal_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                void M() {
                    for (; true ;) { }
                }
            }",
            "foo.cs",
            |metric| {
                // expected: assignments=0, branches=0,
                // conditions=1 (the `true` literal as condition).
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
            },
        );
    }

    // Regression coverage for #279: an empty for-loop condition such as
    // `for (; ;) {}` must contribute 0 to conditions — there is no
    // condition node to count.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_for_empty_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                void M() {
                    for (; ;) { }
                }
            }",
            "foo.cs",
            |metric| {
                // expected: assignments=0, branches=0, conditions=0
                // (no condition expression in `for (; ;)`).
                insta::assert_json_snapshot!(
                    metric.abc,
                    @r#"
                {
                  "assignments": 0,
                  "branches": 0,
                  "conditions": 0,
                  "magnitude": 0.0,
                  "value": 0.0,
                  "assignments_average": 0.0,
                  "branches_average": 0.0,
                  "conditions_average": 0.0,
                  "assignments_min": 0,
                  "assignments_max": 0,
                  "branches_min": 0,
                  "branches_max": 0,
                  "conditions_min": 0,
                  "conditions_max": 0
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_ternary_conditions() {
        check_metrics::<CsharpParser>(
            "class A {
                int Sign(int x) {
                    return (x > 0) ? 1 : (x < 0 ? -1 : 0);
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_malformed_parenthesized_no_panic() {
        check_metrics::<CsharpParser>("class A { void M() { if (( }) }", "foo.cs", |metric| {
            // Don't panic on malformed source.
            assert_eq!(metric.abc.assignments(), 0);
            assert_eq!(metric.abc.branches(), 0);
        });
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_function_pointer_type_no_double_count() {
        // EC1 extension — `<` and `>` are also parameter-list delimiters
        // for unsafe function-pointer types. Since #1297 the arm is an
        // allowlist, so `FunctionPointerType` is excluded by being
        // absent from it rather than by being named in a deny set;
        // either way these brackets must not accumulate `conditions`.
        check_metrics::<CsharpParser>(
            "unsafe class A {
                public delegate*<int, int, int> Adder;
                public delegate*<string, void> Logger;
            }",
            "foo.cs",
            |metric| {
                assert_eq!(
                    metric.abc.conditions(),
                    0,
                    "function-pointer-type angle brackets must not count"
                );
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_generic_type_args_no_double_count() {
        // EC1 — `<` and `>` inside TypeArgumentList must not count as
        // boolean conditions.
        check_metrics::<CsharpParser>(
            "class A {
                void M(System.Collections.Generic.Dictionary<string, System.Collections.Generic.List<int>> d) {
                    System.Console.WriteLine(d);
                }
            }",
            "foo.cs",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    // #1297: `operator <` names the operator a type *defines*; applying
    // one is what a decision looks like. tree-sitter-c-sharp spells the
    // declaration's operator with the same bare token as a comparison,
    // and the previous denylist named only `type_argument_list`,
    // `type_parameter_list` and `function_pointer_type`, so every
    // comparison-operator overload scored a condition.
    //
    // The fixture carries the two overloads plus one `a < b` inside a
    // `binary_expression` and one `x is > 0 ? 2 : 3`, which the grammar
    // parses as a `relational_pattern` whose operand is the ternary (see
    // the assertion). Every mis-aim lands on its own number: 7
    // with neither gate, 5 if `RelationalPattern` is readmitted to the
    // allowlist (#1383 dropped it), 3 if the gate swallows
    // `BinaryExpression` too (only the ternary's `?` and slot and the
    // `is` test survive), 0 if the fixture stops parsing. Each is two
    // higher than before #1461 and #1526, which added the `is` test and
    // the ternary's slot as counts no gate on the `<` / `>` token can
    // reach.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_operator_declaration_is_not_a_condition() {
        check_func_space::<CsharpParser, _>(
            "class V {
                public static bool operator <(V a, V b) { return true; }
                public static bool operator >(V a, V b) { return true; }
                int m(int a, int b, int x) {
                    if (a < b) { return 1; }
                    return x is > 0 ? 2 : 3;
                }
            }",
            "foo.cs",
            |space| {
                // Assert the claim per space rather than through the
                // file total, which is 2 with the two overloads and 2
                // without them — an aggregate assertion would pass on a
                // fixture that had lost the very construct under test.
                let class = &space.spaces[0];
                assert_eq!(class.spaces.len(), 3, "two overloads plus `m`");
                for (i, member) in class.spaces.iter().enumerate().take(2) {
                    assert_eq!(
                        member.metrics.abc.conditions(),
                        0,
                        "operator declaration {i} must score no condition"
                    );
                }
                // 4: the `a < b` comparison, the ternary `?`, its
                // condition slot, and the `is` test. tree-sitter-c-sharp
                // 0.23.5 parses `x is > 0 ? 2 : 3` as `x is > (0 ? 2 :
                // 3)` — the ternary is the pattern's operand, so the
                // pattern sits in no decision slot and its `>` still
                // scores nothing (#1383), while the ternary's condition
                // is the literal `0`, which pays as a slot since #1526.
                // The fourth count is the enclosing
                // `is_pattern_expression` itself, which since #1461
                // scores by use rather than only inside a boolean slot.
                // C# itself binds the source `(x is > 0) ? 2 : 3`; a
                // grammar that agrees reads 3 here, because the `is`
                // test in the condition slot already pays for it.
                assert_eq!(class.spaces[2].metrics.abc.conditions(), 4);
            },
        );
    }

    // #1420, the other four spellings of the test above. C# overloads six
    // comparison operators and #1297 gated two: `<=` `>=` `==` `!=` are
    // distinct tokens that reach a different arm of
    // `csharp_count_token_condition` and each still scored one spurious
    // condition on its declaration — measured 1 apiece against `<` / `>`'s
    // 0, on a class where `cyclomatic()` is 1 for all six.
    //
    // Each token gets its own member so a partial fix names the spelling
    // it missed: gating `EQEQ | BANGEQ` and forgetting `GTEQ | LTEQ` fails
    // here by operator, where the file total cannot tell the two apart —
    // it reads 4 before the fix and 0 after, so any two-of-four fix halves
    // it and still looks like movement.
    //
    // `n` is the deliberate control (§11): the same four tokens *applied*,
    // inside `binary_expression` parents, which must keep scoring one
    // condition each. Without it the gate could be satisfied by refusing
    // to count these tokens at all.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_comparison_operator_overloads_are_not_conditions() {
        let src = "class V {
                public static bool operator <=(V a, V b) { return true; }
                public static bool operator >=(V a, V b) { return true; }
                public static bool operator ==(V a, V b) { return true; }
                public static bool operator !=(V a, V b) { return true; }
                int n(int a, int b) {
                    if (a <= b) { return 1; }
                    if (a >= b) { return 2; }
                    if (a == b) { return 3; }
                    if (a != b) { return 4; }
                    return 0;
                }
            }";
        // Two of each token: one declaring, one applying. Trimming either
        // half out collapses this test into the other half's control and
        // is what this anchor exists to catch.
        assert_csharp_fixture_spells(
            src,
            &[
                (
                    Csharp::OperatorDeclaration as u16,
                    4,
                    "operator declarations",
                ),
                (Csharp::LTEQ as u16, 2, "`<=`"),
                (Csharp::GTEQ as u16, 2, "`>=`"),
                (Csharp::EQEQ as u16, 2, "`==`"),
                (Csharp::BANGEQ as u16, 2, "`!=`"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            let class = &space.spaces[0];
            assert_eq!(class.spaces.len(), 5, "four overloads plus `n`");
            for (member, spelling) in class.spaces.iter().zip(["<=", ">=", "==", "!="]) {
                assert_eq!(
                    member.metrics.abc.conditions(),
                    0,
                    "`operator {spelling}` declares an operator, it does not apply one"
                );
                assert_eq!(
                    member.metrics.abc.conditions(),
                    member.metrics.cyclomatic.cyclomatic() - 1,
                    "`operator {spelling}`: §8 parity with the cyclomatic decision count"
                );
            }
            // The control, found by name so a reordered fixture cannot
            // silently re-point it at an overload. 0 here would mean the
            // gate swallowed the applying form along with the declaring
            // one.
            let control = child_space(class, "n");
            assert_eq!(
                control.metrics.abc.conditions(),
                4,
                "`n` applies all four tokens: one condition each"
            );
        });
    }

    // The allowlist #1420 installed is the only thing keeping `#if A == B`
    // a condition, and it keeps it for a reason no arm states: the grammar
    // aliases `preproc_binary_expression` onto `binary_expression`, so the
    // preprocessor's `==` arrives with kind id `BinaryExpression` (369)
    // and not with one of its own. Before #1420 the token was ungated and
    // no fact about its parent mattered; now a grammar bump that gave the
    // alias a distinct id would stop counting every `#if` equality with
    // nothing red. This is that pin.
    //
    // `BinaryExpression2` (469) is the pre-alias symbol the arm also
    // lists, defensively, per `.claude/rules/grammar-dispatch.md` §1. §2
    // asks that such an entry be kept *and* have its unreachability
    // asserted, so that a pin promoting the symbol changes behaviour
    // loudly rather than invisibly.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_preproc_equality_counts_through_the_binary_expression_alias() {
        let src = "class P {
            #if A == B
                int x;
            #endif
            #if C != D
                int y;
            #endif
            }";
        let parser = CsharpParser::new(
            src.as_bytes().to_vec(),
            std::path::Path::new("foo.cs"),
            None,
        );
        assert!(
            ast_has_kind_id(&parser, Csharp::BinaryExpression as u16),
            "the `#if` expressions must parse as `binary_expression` — \
             the alias is what the arm's allowlist matches"
        );
        assert!(
            !ast_has_kind_id(&parser, Csharp::BinaryExpression2 as u16),
            "`BinaryExpression2` is the pre-alias symbol and must stay \
             unreachable; if the grammar starts emitting it, re-derive the \
             allowlist rather than trusting this arm"
        );
        // 2, one per `#if` expression. The two directives carry no
        // declarations the walk would score, so nothing else contributes.
        check_metrics::<CsharpParser>(src, "foo.cs", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
        });
    }

    // #1448, the C++ / Mozcpp instance of #1420. C++ overloads seven
    // comparison operators; before the fix only `<` / `>` were gated on a
    // `binary_expression` parent, so `operator<=` `>=` `==` `!=` and the
    // spaceship `operator<=>` each scored one spurious condition on a
    // struct where every member has `cyclomatic()` 1.
    //
    // Members are looked up by name, so a partial fix fails on the
    // spelling it missed rather than on a total that merely moved. `n`
    // is the §11 control: the same seven tokens applied, which must
    // keep scoring one condition each. The census anchors both halves —
    // trimming an overload or an application out of the fixture fails
    // by name instead of decaying into its counterpart.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    const CPP_COMPARISON_OVERLOADS: &str = "struct V {
            bool operator<(const V& o) const { return true; }
            bool operator>(const V& o) const { return true; }
            bool operator<=(const V& o) const { return true; }
            bool operator>=(const V& o) const { return true; }
            bool operator==(const V& o) const { return true; }
            bool operator!=(const V& o) const { return true; }
            auto operator<=>(const V& o) const { return 0; }
        };
        struct W {
            int n;
            bool operator==(const W&) const = default;
        };
        int n(int a, int b) {
            return (a < b) + (a > b) + (a <= b) + (a >= b) + (a == b) + (a != b) + (a <=> b);
        }";

    // `operator_name` id, then the seven token ids in source order, for
    // whichever of the two grammars `P` parses.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    fn assert_cpp_comparison_overloads_are_not_conditions<P: MetricSuite>(
        operator_name: u16,
        tokens: [u16; 7],
    ) {
        #[cfg(any(feature = "cpp", feature = "mozcpp"))]
        const SPELLINGS: [&str; 7] = ["<", ">", "<=", ">=", "==", "!=", "<=>"];
        let mut census = vec![(operator_name, 8, "operator names")];
        // Two of each token, one declaring and one applying, plus the
        // third `==` that `W`'s defaulted comparison declares.
        census.extend(
            tokens
                .iter()
                .zip(SPELLINGS)
                .map(|(&id, s)| (id, if s == "==" { 3 } else { 2 }, s)),
        );
        assert_fixture_spells::<P>(CPP_COMPARISON_OVERLOADS, "foo.cpp", &census);
        check_func_space::<P, _>(CPP_COMPARISON_OVERLOADS, "foo.cpp", |space| {
            let class = child_space(&space, "V");
            assert_eq!(class.spaces.len(), 7, "seven overloads");
            for spelling in SPELLINGS {
                let member = child_space(class, &format!("operator{spelling}"));
                assert_eq!(
                    member.metrics.abc.conditions(),
                    0,
                    "`operator{spelling}` declares an operator, it does not apply one"
                );
                assert_eq!(
                    member.metrics.abc.conditions(),
                    member.metrics.cyclomatic.cyclomatic() - 1,
                    "`operator{spelling}`: §8 parity with the cyclomatic decision count"
                );
            }
            assert_eq!(
                child_space(&space, "n").metrics.abc.conditions(),
                7,
                "`n` applies all seven tokens: one condition each"
            );
            // A defaulted C++20 comparison declares the operator with no
            // body; it is the common modern spelling and must score
            // nothing anywhere in the file.
            assert_eq!(
                space.metrics.abc.conditions_sum(),
                7,
                "only `n`'s seven applications are conditions"
            );
        });
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_comparison_operator_overloads_are_not_conditions() {
        assert_cpp_comparison_overloads_are_not_conditions::<CppParser>(
            Cpp::OperatorName as u16,
            [
                Cpp::LT,
                Cpp::GT,
                Cpp::LTEQ,
                Cpp::GTEQ,
                Cpp::EQEQ,
                Cpp::BANGEQ,
                Cpp::LTEQGT,
            ]
            .map(|k| k as u16),
        );
    }

    // Mozcpp owns no file extension, so this is its only coverage of the
    // arm: no integration snapshot routes to it.
    #[cfg(feature = "mozcpp")]
    #[test]
    fn mozcpp_comparison_operator_overloads_are_not_conditions() {
        use crate::Mozcpp;
        assert_cpp_comparison_overloads_are_not_conditions::<crate::MozcppParser>(
            Mozcpp::OperatorName as u16,
            [
                Mozcpp::LT,
                Mozcpp::GT,
                Mozcpp::LTEQ,
                Mozcpp::GTEQ,
                Mozcpp::EQEQ,
                Mozcpp::BANGEQ,
                Mozcpp::LTEQGT,
            ]
            .map(|k| k as u16),
        );
    }

    // ISO C++ spells `!`, `&&`, `||` and `!=` equally as `not`, `and`,
    // `or` and `not_eq` ([lex.digraph]), and the C++ grammars give each
    // alternative token a kind of its own. ABC tested only the symbols,
    // so `if (not b)` scored 0 against `if (!b)`'s 1, `b and c` scored 0
    // against `b && c`'s 2, and `b not_eq c` scored 0 against `b != c`'s
    // 1. Each row pairs a symbolic spelling with its alternative and the
    // value both must give; the census proves the alternative fixture
    // really carries the alternative token rather than parsing it as an
    // identifier, which is what tree-sitter-c does with the same text.
    //
    // Arguments: the `not`, `and`, `or` and `not_eq` ids of `P`'s grammar.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    fn assert_cpp_alternative_tokens_score_like_symbols<P: MetricSuite>(alt: [u16; 4]) {
        let [not, and, or, not_eq] = alt;
        let rows = [
            ("if (!b) {}", "if (not b) {}", not, 1),
            ("bool x = !b && c;", "bool x = not b && c;", not, 2),
            ("bool x = c ? !b : c;", "bool x = c ? not b : c;", not, 3),
            ("bool x = b && c;", "bool x = b and c;", and, 2),
            ("if (b || c) {}", "if (b or c) {}", or, 2),
            ("if (b != c) {}", "if (b not_eq c) {}", not_eq, 1),
        ];
        for (symbolic, alternative, token, expected) in rows {
            let alt_source = format!("void f(bool b, bool c) {{\n  {alternative}\n}}\n");
            assert_fixture_spells::<P>(&alt_source, "foo.cpp", &[(token, 1, alternative)]);
            for source in [symbolic, alternative] {
                let source = format!("void f(bool b, bool c) {{\n  {source}\n}}\n");
                check_func_space::<P, _>(&source, "foo.cpp", |space| {
                    assert_eq!(
                        space.metrics.abc.conditions_sum(),
                        expected,
                        "`{source}` must score like its symbolic spelling `{symbolic}`"
                    );
                });
            }
        }
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_alternative_tokens_score_like_symbols() {
        assert_cpp_alternative_tokens_score_like_symbols::<CppParser>(
            [Cpp::Not, Cpp::And, Cpp::Or, Cpp::NotEq].map(|k| k as u16),
        );
    }

    // Mozcpp owns no file extension, so this is its only coverage of the
    // alternative tokens: no integration snapshot routes to it.
    #[cfg(feature = "mozcpp")]
    #[test]
    fn mozcpp_alternative_tokens_score_like_symbols() {
        use crate::Mozcpp;
        assert_cpp_alternative_tokens_score_like_symbols::<crate::MozcppParser>(
            [Mozcpp::Not, Mozcpp::And, Mozcpp::Or, Mozcpp::NotEq].map(|k| k as u16),
        );
    }

    // The two other productions #1448's allowlist decides, alongside the
    // operator overloads above.
    //
    // `#if A <= B` is a real decision and must keep counting: the grammar
    // aliases `preproc_binary_expression` onto `binary_expression`, and
    // the allowlist is the only thing that admits it now that `<=` / `!=`
    // are gated. The fixture's two directives are the root's only
    // conditions.
    //
    // A fold over a comparison operator counts once, through the fold's
    // `operator` field: before the fix `lt` scored 0, `le` 1 and the
    // binary fold `eq` 2 (one per spelling of its single operator).
    // `idiom` is the control — its `==` sits in a `binary_expression`
    // inside the fold and counts there, while the fold's own `&&` is not
    // a comparison: it scores what its twin `(a == 0) && (a == 0)` does,
    // 2 (#1533). `neg` is the same twice-spelled operator under the `||`
    // chain arm: it scores what `true || !a` does, 2, where walking the
    // fold once per spelling would pay 4.
    //
    // The census also pins §2: every `binary_expression` here carries the
    // `BinaryExpression2` id and the pre-alias `BinaryExpression` is never
    // emitted. `cpp_operator_is_applied` matches the kind *name*, which
    // covers both, so a grammar that starts emitting the pre-alias id
    // changes nothing — this census is what would notice it.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    fn assert_cpp_comparison_folds_and_preproc_operands<P: MetricSuite>(
        binary_expression: u16,
        binary_expression2: u16,
        fold_expression: u16,
    ) {
        let src = "#if A <= B
            #endif
            #if C != D
            #endif
            template <typename... T> bool lt(T... a) { return (a < ...); }
            template <typename... T> bool le(T... a) { return (a <= ...); }
            template <typename... T> bool eq(T... a) { return (0 == ... == a); }
            template <typename... T> bool idiom(T... a) { return ((a == 0) && ...); }
            template <typename... T> bool neg(T... a) { return (true || ... || !a); }";
        assert_fixture_spells::<P>(
            src,
            "foo.cpp",
            &[
                (fold_expression, 5, "fold expressions"),
                (binary_expression2, 3, "binary expressions"),
                (binary_expression, 0, "pre-alias binary expressions"),
            ],
        );
        check_func_space::<P, _>(src, "foo.cpp", |space| {
            for (name, want) in [("lt", 1), ("le", 1), ("eq", 1), ("idiom", 2), ("neg", 2)] {
                assert_eq!(
                    child_space(&space, name).metrics.abc.conditions(),
                    want,
                    "fold in `{name}`"
                );
            }
            assert_eq!(
                space.metrics.abc.conditions(),
                2,
                "one condition per `#if` comparison"
            );
        });
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_comparison_folds_and_preproc_operands() {
        assert_cpp_comparison_folds_and_preproc_operands::<CppParser>(
            Cpp::BinaryExpression as u16,
            Cpp::BinaryExpression2 as u16,
            Cpp::FoldExpression as u16,
        );
    }

    #[cfg(feature = "mozcpp")]
    #[test]
    fn mozcpp_comparison_folds_and_preproc_operands() {
        use crate::Mozcpp;
        assert_cpp_comparison_folds_and_preproc_operands::<crate::MozcppParser>(
            Mozcpp::BinaryExpression as u16,
            Mozcpp::BinaryExpression2 as u16,
            Mozcpp::FoldExpression as u16,
        );
    }

    // #1383: a `relational_pattern`'s operator is not a condition of
    // its own — the `switch_expression_arm` that owns it already scores
    // the decision, exactly as it does for the constant arm `5 => 1`.
    // Counting both charged a relational arm twice, and twice C#'s own
    // cyclomatic decision count.
    //
    // Per `.claude/rules/grammar-dispatch.md` §11 the `operator <`
    // fixture above cannot prove this alone: its `is > 0` sits beside a
    // `binary_expression` comparison that supplies a plausible total on
    // its own. Here the pattern operators are the *only* `<` / `>` /
    // `>=` / `<=` in the file, so a readmitted `RelationalPattern`
    // parent is the only thing that can lift the count.
    //
    // Both spellings are covered, and asserted per member rather than
    // through a total, because they reached two different arms when this
    // was written: `n`'s `>` / `<` were gated by a `GT | LT` parent
    // allowlist and `g`'s `>=` / `<=` by a separate `RelationalPattern`
    // denial, so fixing one and not the other left the *other method* at
    // 4. #1420 merged all six comparison tokens onto the one allowlist,
    // which removes that particular way to get it half right — but the
    // per-member shape still earns its keep, since a total of 6 is what
    // both `{2, 2, 2}` and a regressed `{4, 2, 0}` report:
    //
    // | state | `n` | `g` | `c` |
    // |---|---|---|---|
    // | `relational_pattern` excluded (shipped) | 2 | 2 | 2 |
    // | readmitted to the allowlist             | 4 | 4 | 2 |
    //
    // `c` is the constant-pattern control and reads 2 in both rows: it is
    // what the relational methods are supposed to agree with.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_relational_pattern_does_not_double_count_its_arm() {
        let src = "class A {
                int n(int x) => x switch { > 5 => 1, < 0 => 2, _ => 3 };
                int g(int x) => x switch { >= 5 => 1, <= 0 => 2, _ => 3 };
                int c(int x) => x switch { 5 => 1, 0 => 2, _ => 3 };
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::RelationalPattern as u16, 4, "relational patterns"),
                (Csharp::GT as u16, 1, "`>`"),
                (Csharp::LT as u16, 1, "`<`"),
                (Csharp::GTEQ as u16, 1, "`>=`"),
                (Csharp::LTEQ as u16, 1, "`<=`"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            // Per space, not through the root: the root can only see
            // the sum, and a `{4, 2, 0}` regression sums to the same 6
            // as the correct `{2, 2, 2}`. `cyclomatic()` parity is also
            // only expressible per space — `cyclomatic_sum()` folds in
            // a base of 1 for each one.
            assert_every_member_scores(&space.spaces[0], 3, 2, "one condition per non-discard arm");
        });
    }

    // The `is` half of #1383, and the one whose over-count came from a
    // different owner: `if (x is > 0)` scored the `IfStatement`
    // condition slot *and* the pattern's `>`. `f`'s guard is the
    // deliberate control — a `binary_expression` comparison in the same
    // slot still scores exactly one, so the fix cannot be read as
    // "stop counting `if` conditions".
    //
    // The two combinator methods pin the compound forms the issue asks
    // about. `and` / `or` are keyword tokens C# ABC never listed and C#
    // cyclomatic never counts, so the arm stays the single decision
    // however many relational operands it carries — which is exactly
    // what would regress if a later fix re-derived the gate from the
    // operand instead of the parent.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_is_pattern_and_combinators_score_one_decision() {
        let src = "class A {
                int m(int x) { if (x is > 0) { return 1; } return 0; }
                int f(int x) { if (x > 0) { return 1; } return 0; }
                int a(int x) { if (x is > 0 and < 9) { return 1; } return 0; }
                int o(int x) { if (x is < 0 or >= 100) { return 1; } return 0; }
                int n(int x) { if (x is not > 5) { return 1; } return 0; }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::RelationalPattern as u16, 6, "relational patterns"),
                (Csharp::IsPatternExpression as u16, 4, "`is` pattern tests"),
                (Csharp::AndPattern as u16, 1, "`and`"),
                (Csharp::OrPattern as u16, 1, "`or`"),
                (Csharp::NegatedPattern as u16, 1, "`not`"),
                (Csharp::GTEQ as u16, 1, "`>=` (only `o` carries one)"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_every_member_scores(&space.spaces[0], 5, 1, "the `if` is the only decision");
        });
    }

    // #1383's second, quieter effect, and the one its issue does not
    // mention: a relational pattern outside any decision slot went from
    // 1 to 0 as well, because the gate is on the operator's parent and
    // not on what encloses the pattern. That left `q` — the equivalent
    // binary comparison `x > 5` in the same slot — scoring 1 against
    // these four's 0, so a relational pattern read one *lower* than the
    // comparison it is sugar for. #1383 recorded that as a deliberate
    // exception to Fitzpatrick Rule 5 and kept it, because the only
    // route it had was to readmit the pattern's `<` / `>` token, which
    // would have scored the decision-slot case twice.
    //
    // #1461 closed it from the other end, and the test now pins the
    // agreement rather than the exception. The enclosing
    // `is_pattern_expression` scores by use, so `x is > 5` reads 1
    // wherever it is written — level with `q`, and level with the plain
    // type test `x is int` (`t`, whose `is_expression` moved for the
    // same reason). The pattern's own `>` still scores nothing, which
    // is what keeps the whole test at 1 rather than 2: one relational
    // operation, one condition.
    //
    // The four probes stay because they are four different enclosings —
    // a declarator, a bare `return`, an argument, a type test — and the
    // point was never that the pattern is special in one of them.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_relational_pattern_scores_one_wherever_it_is_written() {
        let src = "class A {
                static bool M(bool b) { return b; }
                bool p(int x) { bool b = x is > 5; return b; }
                bool q(int x) { bool b = x > 5; return b; }
                bool r(int x) { return x is > 5; }
                bool s(int x) { return M(x is > 5); }
                bool t(object x) { bool b = x is int; return b; }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::RelationalPattern as u16, 3, "relational patterns"),
                (Csharp::IsPatternExpression as u16, 3, "`is` pattern tests"),
                (Csharp::IsExpression as u16, 1, "the `is int` control"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            let class = &space.spaces[0];
            assert_eq!(class.spaces.len(), 6, "`M` plus five probes");
            let by_name = |n: &str| {
                class
                    .spaces
                    .iter()
                    .find(|s| s.name.as_deref() == Some(n))
                    .unwrap_or_else(|| panic!("fixture lost `{n}`"))
                    .metrics
                    .abc
                    .conditions()
            };
            // Named rather than indexed: the claim is about which
            // spelling scores what, so a reordering of the fixture must
            // not silently re-point the assertions.
            for probe in ["p", "r", "s"] {
                assert_eq!(by_name(probe), 1, "`{probe}`: the `is` test, once");
            }
            assert_eq!(by_name("t"), 1, "the bare type test, the same once");
            assert_eq!(by_name("q"), 1, "the comparison it is sugar for");
            assert_eq!(by_name("M"), 0, "no relational operator anywhere");
        });
    }

    // The boundary of #1383: the pattern's operator stops counting, a
    // *binary* operator in the arm's `when` guard keeps counting (`w`).
    // Both sit under the same `switch_expression_arm`, so this is what
    // stops a later "patterns don't count" pass from suppressing the
    // guard too.
    //
    // A relational *pattern* in the guard (`g`) is the other side of that
    // line: the operator itself still scores nothing, because the gate is
    // on the operator's parent — but since #1422 the guard is a condition
    // slot, and an `is` test scores itself (`csharp_condition_scores_itself`),
    // so the slot does not pay again. That is what closed the gap this test used to
    // carry a `FIXME(#1422)` for: `when n is > 5` now reads level with
    // `when n > 5` instead of one below it.
    //
    // §8 holds throughout, which it did not before #1422. The old table
    // here recorded the defect: neither metric modelled the guard, so
    // ABC's count was whatever operator token happened to sit inside it
    // and cyclomatic's was nothing at all. Both tiers measured, before
    // and after:
    //
    // | guard | `conditions()` | `cyclomatic() - 1` |
    // |---|---|---|
    // | `when x % 2 == 0` (this fixture) | 3 → 3 | 2 → 3 |
    // | `when x > 2`                     | 3 → 3 | 2 → 3 |
    // | `when IsEven(x)`                 | 2 → 3 | 2 → 3 |
    //
    // The `==` is the guard's own operator and the only `==` in the
    // file, so trimming the `when` clause out of `w` drops its count to
    // 2 rather than leaving the assertion satisfied by something else;
    // `assert_csharp_fixture_spells` pins both guards by kind against
    // the same decay.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_arm_guard_operator_still_counts() {
        let src = "class A {
                int w(int x) => x switch { > 0 when x % 2 == 0 => 1, > 0 => 2, _ => 3 };
                int g(int x) => x switch { int n when n is > 5 => 1, _ => 0 };
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::WhenClause as u16, 2, "`when` guards"),
                (Csharp::EQEQ as u16, 1, "the guard's `==`"),
                (Csharp::RelationalPattern as u16, 3, "relational patterns"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            let m = &space.spaces[0].spaces[0];
            assert_eq!(m.name.as_deref(), Some("w"));
            // 4 if the guard slot started counting a `binary_expression`
            // on top of its `==`, 2 if the `==` were suppressed along
            // with the pattern operators — both are live regressions.
            assert_eq!(
                m.metrics.abc.conditions(),
                3,
                "two arms plus the guard's `==`"
            );
            assert_eq!(m.metrics.cyclomatic.cyclomatic(), 4);

            let g = &space.spaces[0].spaces[1];
            assert_eq!(g.name.as_deref(), Some("g"));
            assert_eq!(
                g.metrics.abc.conditions(),
                2,
                "one arm plus the guard slot, which scores the `is` test"
            );
            assert_eq!(g.metrics.cyclomatic.cyclomatic(), 3);
        });
    }

    // #1422's headline: four spellings of one guard, previously worth
    // two different ABC numbers because nothing modelled the guard and
    // ABC counted whatever operator token happened to sit inside it —
    // `when x % 2 == 0` and `when x > 2` scored 1 through the
    // comparison-token arm, `when IsEven(x)` scored 0. Modelled as a
    // condition slot each contributes exactly 1, and the cyclomatic
    // `WhenClause` arm lifts the decision count to match.
    //
    // `none` is the unguarded control and the anchor: a two-arm switch
    // over the same relational patterns carrying no guard at all, so
    // every member here is exactly one guard away from it. Without that
    // row a fix that scored the *arms* differently would satisfy the
    // four guarded rows alike. Its arms run `> 2` before `> 0` because
    // the reverse order is a C# compile error (CS8510, the later arm
    // subsumed) — the guarded members escape that only because a guard
    // can fail, which is what makes their repeated `> 0` legal.
    //
    // `paren` is not a fourth spelling for its own sake — it is the only
    // member whose guard reaches the slot as a
    // `parenthesized_expression` for the peel (`csharp_wrapper_operand`)
    // to take off, since `when_clause` wraps a parenthesised guard in a
    // real `parenthesized_expression` rather than the anonymous parens
    // `catch_filter_clause` uses.
    //
    // `nullc` is #1459's row and the counter-example that falsified the
    // claim above when it was first written. The slot leaves an
    // operator guard to the arm that already counts the operator, and
    // no ABC arm counted `??`, so this one spelling read 2 where the
    // other four read 3. Counting the token levels it without touching
    // the slot; an unconditional `+1` in the slot instead would have
    // taken `cmp` to 4, re-creating the double count #1422 removed.
    //
    // It is the one guarded member whose cyclomatic is not 4, and that
    // is not a discrepancy to fix: C# cyclomatic counts `??` as a
    // decision *in addition to* the guard clause, so the arm below
    // narrows the ABC-versus-cyclomatic gap from two to one rather than
    // closing it. The remaining one is the slot's standing policy of
    // leaving a counted operator to its arm, and `cmp` pays it
    // too — it just happens to break even there.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_switch_arm_guard_scores_one_condition_however_spelled() {
        let src = "class A {
                static bool IsEven(int x) { return true; }
                int tok(int x) => x switch { > 0 when x % 2 == 0 => 1, > 0 => 2, _ => 3 };
                int cmp(int x) => x switch { > 0 when x > 2 => 1, > 0 => 2, _ => 3 };
                int call(int x) => x switch { > 0 when IsEven(x) => 1, > 0 => 2, _ => 3 };
                int paren(int x) => x switch { > 0 when (IsEven(x)) => 1, > 0 => 2, _ => 3 };
                int nullc(int x, bool? b) => x switch { > 0 when b ?? false => 1, > 0 => 2, _ => 3 };
                int none(int x) => x switch { > 2 => 1, > 0 => 2, _ => 3 };
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::WhenClause as u16, 5, "`when` guards"),
                (Csharp::EQEQ as u16, 1, "`tok`'s `==`"),
                (Csharp::QMARKQMARK as u16, 1, "`nullc`'s `??`"),
                (
                    Csharp::ParenthesizedExpression as u16,
                    1,
                    "`paren`'s parenthesised guard",
                ),
                // By the call's *argument list*, which carries no
                // numeric-suffix alias, rather than by
                // `invocation_expression`, which has three
                // (`InvocationExpression` / `2` / `3`) and would pin this
                // anchor to whichever one the pinned grammar happens to
                // emit. `call` and `paren` hold the only two argument
                // lists in the fixture — `IsEven(int x)` is a
                // `parameter_list`.
                (Csharp::ArgumentList as u16, 2, "the `IsEven` calls"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    ("IsEven", 0, 1),
                    ("tok", 3, 4),
                    ("cmp", 3, 4),
                    ("call", 3, 4),
                    ("paren", 3, 4),
                    // Was 2 — the guard spelling nothing counted.
                    // Cyclomatic 5 rather than 4 because `??` is a
                    // decision there on top of the guard clause.
                    ("nullc", 3, 5),
                    ("none", 2, 3),
                ],
            );
        });
    }

    // The bare type test `x is int` is `is_expression` (391); only once
    // a pattern is involved (`x is int y`, `x is null`) does the grammar
    // emit `is_pattern_expression` (392). They are distinct kinds, and
    // the former `csharp_bool_terminal_kinds!()` listed only the
    // second, so the two spellings of one test disagreed: `if (x is int)` scored zero
    // conditions against a cyclomatic decision of one while
    // `if (x is int y)` scored one.
    //
    // Found by the whole-branch review of this batch, and it falsified
    // #1422's own claim in the arm above that a guard "scores one
    // however it is spelled" — `when x is int` read 1 where
    // `when IsEven(x)` read 2, which is the spelling-dependence that
    // fix exists to remove. It is the C# half of the gap #1421 closed
    // for Kotlin by adding `IsExpression | InExpression` there. Both
    // languages' type tests have since moved out of the terminal set to
    // an unconditional arm (#1461), which leaves every number here
    // unchanged — the slot no longer counts the test and the arm does.
    //
    // The plain `if` members are the control that keeps this honest: a
    // guard-only fixture could be satisfied by a guard-specific rule,
    // and the defect was never guard-specific. `q` and `iq` are the
    // already-correct `is_pattern_expression` twins, so a regression
    // that reintroduced the asymmetry fails on the pair rather than on
    // an absolute number.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_bare_is_type_test_scores_one_condition() {
        let src = "class A {
                static bool IsEven(int x) { return true; }
                int g(object x) => x switch { object o when x is int => 1, _ => 0 };
                int gq(object x) => x switch { object o when x is int y => 1, _ => 0 };
                int gc(object x) => x switch { object o when IsEven(1) => 1, _ => 0 };
                int p(object x) { if (x is int) { return 1; } return 0; }
                int q(object x) { if (x is int y) { return 1; } return 0; }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::IsExpression as u16, 2, "the bare `is` type tests"),
                (
                    Csharp::IsPatternExpression as u16,
                    2,
                    "the designation-pattern twins",
                ),
                (Csharp::WhenClause as u16, 3, "`when` guards"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    ("IsEven", 0, 1),
                    // Level with `gq` and `gc`: every guard spelling
                    // scores one, which is what #1422 claims.
                    ("g", 2, 3),
                    ("gq", 2, 3),
                    ("gc", 2, 3),
                    // Level with `q`: the two spellings of one type
                    // test agree outside a guard too.
                    ("p", 1, 2),
                    ("q", 1, 2),
                ],
            );
        });
    }

    // The null-forgiving `b!` is transparent: it scores whatever the
    // operand it wraps scores (#1463).
    //
    // `postfix_unary_expression` was in neither
    // the former `csharp_bool_terminal_kinds!()` nor the wrapper peel,
    // so every spelling below scored **zero** conditions against a cyclomatic
    // decision of one, while the bare `b` control scored one. In a
    // codebase with nullable reference types enabled the suffix is
    // everywhere, so the gap is not an exotic corner.
    //
    // Both walker paths, per `.claude/rules/grammar-dispatch.md` §11:
    // `p*` go through the `if` predicate slot
    // (`csharp_count_condition`) and `c*` through the `&&` chain slot
    // (also `csharp_count_condition`, per chain operand), which reach
    // the peel independently. A fixture of only one
    // reads correct with the other path dead.
    //
    // The controls are load-bearing in both directions. `p` / `c` pin
    // what the wrapper must score, so a regression fails on the pair
    // rather than on an absolute number; and the cyclomatic column pins
    // that only `conditions` moved — the suffix is not a decision in any
    // language, so a fix that moved both together would be a different
    // bug.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_null_forgiving_operand_scores_like_its_operand() {
        let src = "class A {
                int p(bool b) { if (b) { return 1; } return 0; }
                int pn(bool b) { if (b!) { return 1; } return 0; }
                int pp(bool b) { if ((b!)) { return 1; } return 0; }
                int pd(bool b) { if (b!!) { return 1; } return 0; }
                int pb(bool b) { if (!b!) { return 1; } return 0; }
                int c(bool b) { if (b && b) { return 1; } return 0; }
                int cn(bool b) { if (b! && b) { return 1; } return 0; }
                int cp(bool b) { if ((b!) && b) { return 1; } return 0; }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                // Seven, not five: `b!!` is two nested nodes, and each
                // chain member carries one. Trimming a `!` out of any
                // member fails here by name instead of turning that
                // member into a silent copy of its control.
                (
                    Csharp::PostfixUnaryExpression as u16,
                    7,
                    "the null-forgiving suffixes",
                ),
                // The `if (…)` parens are anonymous tokens rather than
                // nodes in this grammar, so these two are `pp`'s and
                // `cp`'s explicit ones — the wrappers that make the peel
                // chain rather than peel once.
                (
                    Csharp::ParenthesizedExpression as u16,
                    2,
                    "the explicit parenthesised spellings",
                ),
                (Csharp::PrefixUnaryExpression as u16, 1, "`pb`'s `!`"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    ("p", 1, 2),
                    ("pn", 1, 2),
                    ("pp", 1, 2),
                    ("pd", 1, 2),
                    ("pb", 1, 2),
                    ("c", 2, 3),
                    ("cn", 2, 3),
                    ("cp", 2, 3),
                ],
            );
        });
    }

    // The null-forgiving operand is read by position, but from the end
    // the grammar cannot move: a `postfix_unary_expression` *starts* at
    // its operand, so `child(0)` is the operand whatever `extra` sits
    // between it and the operator. The operator is identified by
    // membership rather than by index for the same reason.
    //
    // The other two wrappers name no field either — the C# grammar gives
    // `parenthesized_expression`, `prefix_unary_expression` and
    // `postfix_unary_expression` an empty `fields` map in
    // node-types.json — so `child(1)` was a comment whenever one was
    // written there, and `nc` / `rc` scored zero. They read their
    // operand as the first one that is not an extra since #1455, so all
    // three pairs agree with their controls.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_null_forgiving_operand_survives_an_interposed_comment() {
        let src = "class A {
                int p(bool b) { if (b!) { return 1; } return 0; }
                int pc(bool b) { if (b /*c*/ !) { return 1; } return 0; }
                int n(bool b) { if (!b) { return 1; } return 0; }
                int nc(bool b) { if (! /*c*/ b) { return 1; } return 0; }
                int r(bool b) { if ((b)) { return 1; } return 0; }
                int rc(bool b) { if (( /*c*/ b)) { return 1; } return 0; }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (
                    Csharp::Comment as u16,
                    3,
                    "the interposed comments — without them every row is its own control",
                ),
                (Csharp::PostfixUnaryExpression as u16, 2, "`p` and `pc`"),
                (Csharp::PrefixUnaryExpression as u16, 2, "`n` and `nc`"),
                (
                    Csharp::ParenthesizedExpression as u16,
                    2,
                    "`r` and `rc` — the `if` parens are anonymous tokens",
                ),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    ("p", 1, 2),
                    // The row #1463 fixes.
                    ("pc", 1, 2),
                    ("n", 1, 2),
                    // #1455: `child(1)` of the prefix wrapper is the
                    // comment.
                    ("nc", 1, 2),
                    ("r", 1, 2),
                    // #1455 again, through the paren wrapper.
                    ("rc", 1, 2),
                ],
            );
        });
    }

    // The statement `switch` reaches the same `when_clause` kind through
    // a different parent — `switch_section` rather than
    // `switch_expression_arm` — which makes it an independent path in
    // the sense of `.claude/rules/grammar-dispatch.md` §11: the arms
    // themselves are counted by two different owners (a `Case` token
    // here, the `SwitchExpressionArm` node there), so a guard rule
    // written against one shape could be dead for the other and every
    // expression-form fixture would still read correct.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_statement_switch_section_guard_counts() {
        let src = "class A {
                static bool IsEven(int x) { return true; }
                int guarded(int x) {
                    switch (x) {
                        case > 0 when IsEven(x): return 1;
                        case > 0: return 2;
                        default: return 3;
                    }
                }
                int plain(int x) {
                    switch (x) {
                        case > 2: return 1;
                        case > 0: return 2;
                        default: return 3;
                    }
                }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::WhenClause as u16, 1, "the `case … when` guard"),
                (Csharp::SwitchSection as u16, 6, "switch sections"),
                (
                    Csharp::SwitchExpressionArm as u16,
                    0,
                    "expression arms (this fixture is the statement form)",
                ),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(
                &space.spaces[0],
                &[("IsEven", 0, 1), ("guarded", 3, 4), ("plain", 2, 3)],
            );
        });
    }

    // The sibling #1422's issue body does not mention, measured to have
    // the identical defect: `catch (E e) when (…)` is a second guard
    // spelling on its own `catch_filter_clause` kind, and it scored
    // conditions 3 / 2 / 2 for the comparison / call spellings and the
    // unfiltered control while `cyclomatic()` sat at 2 for all three.
    //
    // ABC runs one above `cyclomatic() - 1` on every row, guarded and
    // unguarded alike, and that offset is not this fix's: C# ABC counts
    // the `Try` token as a condition (Fitzpatrick Rule 5, the same
    // family as `else`) where cyclomatic counts only the `catch`. The
    // guard moves both tiers by exactly one, which is what `none`
    // anchors — the offset is a constant here, not something a guard
    // introduces.
    //
    // `paren` carries the *double* parenthesis on purpose. The grammar
    // spells `catch_filter_clause`'s own parentheses as anonymous tokens
    // the way `if_statement` does, so `when (IsEven(x))` hands the slot a
    // bare `invocation_expression` with no parenthesis for the peel
    // (`csharp_wrapper_operand`) to take off; only a
    // second pair of parentheses produces a `parenthesized_expression`
    // there.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_catch_filter_guard_scores_one_condition_however_spelled() {
        let src = "class A {
                static bool IsEven(int x) { return true; }
                int tok(int x) { try { return 1; } catch (System.Exception e) when (x % 2 == 0) { return 2; } }
                int cmp(int x) { try { return 1; } catch (System.Exception e) when (x > 0) { return 2; } }
                int call(int x) { try { return 1; } catch (System.Exception e) when (IsEven(x)) { return 2; } }
                int paren(int x) { try { return 1; } catch (System.Exception e) when ((IsEven(x))) { return 2; } }
                int none(int x) { try { return 1; } catch (System.Exception e) { return 2; } }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (
                    Csharp::CatchFilterClause as u16,
                    4,
                    "`catch … when` filters",
                ),
                (Csharp::CatchClause as u16, 5, "catch clauses"),
                (Csharp::WhenClause as u16, 0, "switch guards (none here)"),
                (
                    Csharp::ParenthesizedExpression as u16,
                    1,
                    "`paren`'s inner parentheses",
                ),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    ("IsEven", 0, 1),
                    ("tok", 3, 3),
                    ("cmp", 3, 3),
                    ("call", 3, 3),
                    ("paren", 3, 3),
                    ("none", 2, 2),
                ],
            );
        });
    }

    // A guarded discard is where the two rules meet. `_ when g =>` is
    // already exempt from the `default:` exclusion —
    // `csharp_switch_expression_arm_is_bare_discard` looks for a
    // `when_clause` for exactly this reason — so after #1422 it scores
    // twice: once as an arm that is no longer unconditional, once for
    // the guard that makes it conditional. `bare` is the control that
    // keeps the exclusion itself pinned: drop the guard and the arm goes
    // back to costing nothing.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_guarded_discard_arm_scores_arm_and_guard() {
        let src = "class A {
                static bool IsEven(int x) { return true; }
                int guarded(int x) => x switch { > 0 => 1, _ when IsEven(x) => 2, _ => 3 };
                int bare(int x) => x switch { > 0 => 1, _ => 3 };
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::WhenClause as u16, 1, "the guarded discard"),
                (Csharp::Discard as u16, 3, "discard patterns"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(
                &space.spaces[0],
                &[("IsEven", 0, 1), ("guarded", 3, 4), ("bare", 1, 2)],
            );
        });
    }

    // A comment inside the guard must not cost it its condition.
    // tree-sitter `extra`s are *named* nodes, so `comment` can be the
    // first named child of either guard clause — and a slot that read
    // only the first named child scored `when /*c*/ IsEven(x)` as 1
    // where `when IsEven(x)` scores 2, silently reinstating the very
    // spelling-dependence #1422 removes and breaking the §8 parity the
    // fix establishes. Found in review of #1422 before it shipped.
    //
    // This is the C# instance of the class #1181 fixed for the ternary,
    // where a comment between a token and its operand shifted every
    // positional read. Each commented member is asserted against the
    // same literal pair as its uncommented twin in the same table, so a
    // regression that moved only the commented spelling fails here; the
    // literals themselves are pinned by
    // `csharp_switch_arm_guard_scores_one_condition_however_spelled` and
    // its catch-filter sibling.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_guard_keeps_its_condition_across_a_comment() {
        let src = "class A {
                static bool IsEven(int x) => true;
                int plain(int x) => x switch { > 0 when IsEven(x) => 1, _ => 0 };
                int cmt(int x) => x switch { > 0 when /*c*/ IsEven(x) => 1, _ => 0 };
                int cplain(int x) { try { return 1; } catch (System.Exception e) when (IsEven(x)) { return 2; } }
                int ccmt(int x) { try { return 1; } catch (System.Exception e) when (/*c*/ IsEven(x)) { return 2; } }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::Comment as u16, 2, "the in-guard comments"),
                (Csharp::WhenClause as u16, 2, "switch guards"),
                (Csharp::CatchFilterClause as u16, 2, "catch filters"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    ("IsEven", 0, 1),
                    ("plain", 2, 3),
                    ("cmt", 2, 3),
                    ("cplain", 3, 3),
                    ("ccmt", 3, 3),
                ],
            );
        });
    }

    // Why the guard is a condition *slot* and not a flat +1: a compound
    // guard keeps its sub-structure. `when a > 1 && b < 2` scores the
    // two comparisons through the token arm and nothing extra from the
    // slot, because a `&&` chain scores itself
    // (`csharp_condition_scores_itself`) — so it reads one above `single`'s
    // lone comparison rather than collapsing to the same number, and
    // cyclomatic agrees because it counts the `&&`.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_compound_guard_keeps_its_sub_structure() {
        let src = "class A {
                int compound(int a, int b) => a switch { > 0 when a > 1 && b < 2 => 1, _ => 0 };
                int single(int a, int b) => a switch { > 0 when a > 1 => 1, _ => 0 };
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::WhenClause as u16, 2, "`when` guards"),
                (Csharp::AMPAMP as u16, 1, "`compound`'s `&&`"),
                (Csharp::LT as u16, 1, "`compound`'s `<`"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(&space.spaces[0], &[("compound", 3, 4), ("single", 2, 3)]);
        });
    }

    // #1275: tree-sitter-c-sharp spells `int?`, `where T : class?`, the
    // ternary and `a?.b` with one and the same bare `?` token, so the
    // unguarded `QMARK` arm scored the two type-syntax forms as
    // decisions.
    //
    // The fixture carries two `nullable_type` `?`, one
    // `type_parameter_constraint` `?`, and one real ternary over a real
    // `>` comparison, so every way of getting the gate wrong lands on
    // its own number: 5 pre-fix, 3 if only `NullableType` is denied, 4
    // if only `TypeParameterConstraint` is, 1 if the gate swallows the
    // genuine ternary, 0 if the fixture stops parsing. Asserting 0 on a
    // nullable-only body would have been vacuous — an unparsable file
    // scores 0 too.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_nullable_type_syntax_is_not_a_condition() {
        check_metrics::<CsharpParser>(
            "class A {
                int M<T>(int? p, int a, int b) where T : class? {
                    int? q = null;
                    return a > b ? 1 : 2;
                }
            }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // The polarity pin for #1275's C# half. `csharp_count_token_condition`
    // denies the two type-syntax parents rather than allowing the two
    // decision-bearing ones, so that `a?.b` and `a?[0]` keep counting by
    // construction: both spell their operator as the same bare `?` under
    // `conditional_access_expression`, and C# cyclomatic counts that node
    // (`safe_navigation_chain_parity` pins C# at one decision per
    // operator alongside every other safe-navigation language).
    //
    // This test is what stops a later "make all three languages
    // consistent" pass from flipping C# to a `ConditionalExpression`
    // allowlist: that would silently drop both `?` counts here while
    // every other ABC test still passed. The third condition is the
    // `??`, which #1459 added to close the gap this comment used to
    // record as out of scope for #1275 — so a flipped `QMARK` polarity
    // now reads 1 rather than 0, and the discrimination is unchanged.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_conditional_access_still_counts_as_a_condition() {
        let src = "class A {
                object M(string s, int[] xs) {
                    return s?.Length ?? xs?[0];
                }
            }";
        // The total is now fed by two token arms rather than one, so it
        // carries the per-source claim only alongside these counts: 3 is
        // two bare `?` plus one `??`, and without them a `QMARK` arm
        // that had stopped counting `a?[0]` while `??` gained a second
        // count elsewhere would still read 3.
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::QMARK as u16, 2, "the `?.` and `?[` operators"),
                (Csharp::QMARKQMARK as u16, 1, "the `??`"),
            ],
        );
        check_metrics::<CsharpParser>(src, "foo.cs", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 3);
        });
    }

    // The `QMARKQMARK` arm away from any guard, where nothing else can
    // supply the count (#1459). `coalesce`'s body holds no comparison,
    // no call and no control-flow keyword, so its one condition is the
    // `??` and nothing else; it read 0 before the arm while C#
    // cyclomatic scored the decision, which is the direction ABC is not
    // allowed to sit on.
    //
    // `plain` is the control that keeps this from being an assertion
    // about `return` or about the method shape: same body without the
    // operator, 0 conditions and 1 decision.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_null_coalescing_is_a_condition() {
        let src = "class A {
                int coalesce(int? x) { return x ?? 0; }
                int plain(int x) { return x; }
            }";
        assert_csharp_fixture_spells(src, &[(Csharp::QMARKQMARK as u16, 1, "the `??`")]);
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(&space.spaces[0], &[("coalesce", 1, 2), ("plain", 0, 1)]);
        });
    }

    // The other direction of #1275's C# gate, isolated: narrowing
    // `QMARK` must not swallow a real ternary. The fixture carries no
    // comparison operator at all, so the ternary is the only thing that
    // can put the count above the walker's own contribution — in the
    // test above, a surviving `>` would have masked an over-suppressed
    // `?` at 1 instead of 0 (grammar-dispatch §11). A nullable
    // parameter keeps the denied production live in the same parse, so
    // one fixture proves both directions: 3 pre-fix, 2 after, 1 if the
    // allowlist/denylist is aimed at `ConditionalExpression`.
    //
    // The 2 is the `?` token plus the ternary's condition slot, which
    // `csharp_walk_for_conditions` counts as a Fitzpatrick unary
    // condition. That is why this is not written as an
    // `assert_deepest_conditions_match_cyclomatic` parity pin the way
    // the Java `<` / `>` sibling is: C# cyclomatic scores this method 1
    // decision, and the divergence is the pre-existing unary-condition
    // rule, not the `?` gate.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_ternary_still_counts_alongside_nullable_types() {
        check_metrics::<CsharpParser>(
            "class A {
                int M(int? n, bool c) {
                    return c ? 1 : 2;
                }
            }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_aliased_invocation_expression_branches() {
        // Regression for issue #94 (lesson #2): the C# grammar emits three
        // aliased `kind_id`s for `invocation_expression`. Code that matches
        // only the unsuffixed `Csharp::InvocationExpression` undercounts ABC
        // branches whenever the AST emits an aliased variant. The three
        // method calls live in `M`, so the per-method maximum (visible at
        // the unit-space aggregate as `branches_max`) must be 3.
        check_metrics::<CsharpParser>(
            "class A {
                void M() {
                    System.Console.WriteLine(1);
                    System.Console.WriteLine(2);
                    System.Console.WriteLine(3);
                }
            }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.abc.branches_max(), 3);
                assert_eq!(metric.abc.conditions_max(), 0);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_zero_abc() {
        check_metrics::<PhpParser>("<?php\n", "foo.php", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_simple_assignment() {
        check_metrics::<PhpParser>(
            "<?php
function f(): void {
    $a = 1;
    $b = 2;
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_augmented_assignment() {
        check_metrics::<PhpParser>(
            "<?php
function f(int $x): int {
    $a = 0;
    $a += $x;
    $a -= 1;
    $a *= 2;
    return $a;
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_const_excluded() {
        // Constant declarations and enum cases are NOT counted as
        // assignments — they declare immutable values.
        check_metrics::<PhpParser>(
            "<?php
class A {
    const PI = 3.14;
    const E = 2.71;
}
enum Color {
    case Red;
    case Green;
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_function_call() {
        check_metrics::<PhpParser>(
            "<?php
function f(): void {
    foo();
    bar(1, 2);
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_method_call() {
        check_metrics::<PhpParser>(
            "<?php
function f($obj): void {
    $obj->m1();
    $obj->m2(1);
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_static_call() {
        check_metrics::<PhpParser>(
            "<?php
function f(): void {
    Foo::bar();
    Foo::baz(1);
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_nullsafe_call() {
        check_metrics::<PhpParser>(
            "<?php
function f($obj): void {
    $obj?->m1();
    $obj?->m2(1);
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_object_creation() {
        check_metrics::<PhpParser>(
            "<?php
function f(): void {
    new Foo();
    new Bar(1);
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_comparison_eq() {
        check_metrics::<PhpParser>(
            "<?php
function f(int $a, int $b): bool {
    return $a == $b || $a != $b;
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_comparison_strict() {
        check_metrics::<PhpParser>(
            "<?php
function f(int $a, int $b): bool {
    return $a === $b || $a !== $b;
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_spaceship() {
        check_metrics::<PhpParser>(
            "<?php
function f(int $a, int $b): int {
    return $a <=> $b;
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_instanceof() {
        check_metrics::<PhpParser>(
            "<?php
function f($x): bool {
    return $x instanceof Foo;
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_complex_function() {
        // One snippet exercising A, B, C buckets together.
        check_metrics::<PhpParser>(
            "<?php
function f(int $a, int $b): int {
    $sum = $a + $b;
    $prod = $a * $b;
    if ($sum > 0 && $prod === 0) {
        return foo($sum);
    }
    return bar()->double();
}",
            "foo.php",
            |metric| insta::assert_json_snapshot!(metric.abc),
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_if_boolean_literal_condition() {
        check_metrics::<PhpParser>(
            "<?php\n\
             function f() {\n\
             \x20   if (true) {}                 // +1c\n\
             \x20   if (!false) {}               // +1c\n\
             \x20   while (true) {}              // +1c\n\
             \x20   do {} while (false);         // +1c\n\
             }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_methods_arguments_with_conditions() {
        check_metrics::<PhpParser>(
            "<?php\n\
             function f($a, $b) {\n\
             \x20   m($a, $b);                   // +1b\n\
             \x20   m(!$a, !$b);                 // +1b +2c\n\
             }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_return_with_conditions() {
        check_metrics::<PhpParser>(
            "<?php\n\
             function m1($z) { return !($z >= 0); }\n\
             function m2($x) { return (((!$x))); }\n\
             function m3($x, $y) { return $x && $y; }\n",
            "foo.php",
            |metric| {
                // m1: `>=` (1). m2: walker unwraps to $x (1).
                // m3: `&&` walker counts both (2). Sum: 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_name2_hidden_rule_drift_marker() {
        // Drift marker (findings.md round-2 #3): `Php::Name2` maps
        // to the hidden grammar rule `_name`. At the pinned
        // tree-sitter-php version it is never emitted as a concrete
        // node — the visible `Name` (= 1) carries every name.
        // The former `php_bool_terminal_kinds!()` listed `Name2`
        // defensively (lesson 34); if a future grammar bump promotes `_name`
        // to a visible rule, this assertion fails loudly.
        let src = "<?php\nfunction f($x) { if ($x) { foo($x); } }\n";
        let parser = PhpParser::new(
            src.as_bytes().to_vec(),
            &std::path::PathBuf::from("foo.php"),
            None,
        );
        assert!(!ast_has_kind_id(&parser, Php::Name2 as u16));
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_scoped_property_access_condition_counts() {
        // Regression for findings.md round-2 #1 (PHP):
        // `if (Config::$enabled) {}` parses with
        // `scoped_property_access_expression` as the condition
        // node (kind_id 333 at the pinned grammar version — the
        // `*2` alias). Pre-fix, neither `ScopedPropertyAccessExpression`
        // nor its alias was in the former `php_bool_terminal_kinds!()`.
        // The walker reached the access node, found it non-terminal,
        // and broke. Mirrors C#'s `MemberAccessExpression` rule
        // (lesson 19, #372).
        check_metrics::<PhpParser>(
            "<?php\n\
             class Config { public static $enabled = true; }\n\
             function f() { if (Config::$enabled) { } }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_named_argument_unary_conditional_counts() {
        // Regression for the code-review finding: PHP 8 named-argument
        // syntax `m(name: !$a)` parses as `argument(name, ':',
        // unary_op_expression)`. Pre-fix, the count walker took
        // `argument.child(0)` (the name) and missed the value at the
        // last child. Now it picks the last named child as the value.
        check_metrics::<PhpParser>(
            "<?php\nfunction f($a) { m(name: !$a); }\n",
            "foo.php",
            |metric| {
                // 1 call (branch) + 1 unary-conditional named argument.
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_low_precedence_keyword_logical_ops_trigger_walker() {
        // Regression: pre-fix, `$a or $b` reported 0 conditions
        // because the dispatcher only handled `AMPAMP|PIPEPIPE`,
        // skipping the PHP-specific `and` / `or` keyword forms even
        // though they parse under the same `binary_expression` shape.
        // (`xor` is no chain: it is a value since #1536.)
        check_metrics::<PhpParser>(
            "<?php\n\
             function f($a, $b) {\n\
             \x20   return $a or $b;\n\
             }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_if_multiple_conditions() {
        check_metrics::<PhpParser>(
            "<?php\n\
             function f($a, $b, $c, $d) {\n\
             \x20   if ($a || $b || $c || $d) {}     // +4c\n\
             \x20   if ($a && $b && $c) {}           // +3c\n\
             \x20   if (!$a && !$b) {}               // +2c\n\
             }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_while_and_do_while_conditions() {
        check_metrics::<PhpParser>(
            "<?php\n\
             function f($a, $b) {\n\
             \x20   while ($a || $b) {}              // +2c\n\
             \x20   do {} while ($a && !$b);         // +2c\n\
             }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_short_circuit_with_boolean_literal_operand() {
        check_metrics::<PhpParser>(
            "<?php\nfunction f($a) { return $a && true; }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Issue #1102, PHP half. See
    // `cpp_ternary_operand_slots_count_as_unary_conditions` for the
    // rule. PHP's ABC dispatcher has no `?`-token arm — the grammar
    // does emit the token, but the `conditional_expression` node is
    // what carries the tally's +1 — so the arm keeps that increment and
    // adds the operand slots.
    #[cfg(feature = "php")]
    #[test]
    fn php_ternary_operand_slots_count_as_unary_conditions() {
        // ternary (1) + condition `$a` (1) + `!$b` (1) + `!$c` (1) = 4.
        check_metrics::<PhpParser>(
            "<?php\nfunction f() { $x = $a ? !$b : !$c; }\n",
            "foo.php",
            |metric| assert_eq!(metric.abc.conditions_sum(), 4),
        );
        // No-double-count pin: ternary (1) + `>` (1) = 2, unchanged by
        // the fix.
        check_metrics::<PhpParser>(
            "<?php\nfunction f() { $x = ($a > 0) ? $b : -$b; }\n",
            "foo.php",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
        // Nested (PHP 8 requires the inner ternary parenthesised): two
        // ternary nodes plus the two bare-variable conditions = 4.
        check_metrics::<PhpParser>(
            "<?php\nfunction f() { $x = $a ? ($b ? $c : $d) : $e; }\n",
            "foo.php",
            |metric| assert_eq!(metric.abc.conditions_sum(), 4),
        );
        // A negated condition is the only input reaching the walker's
        // `else` fallback — see the C++ sibling for why. ternary (1) +
        // `!$a` (1) = 2.
        check_metrics::<PhpParser>(
            "<?php\nfunction f() { $x = !$a ? $b : $c; }\n",
            "foo.php",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    // PHP's short ternary `$a ?: $b` elides the consequence, which the
    // grammar names `body` (not `consequence`) and marks optional. The
    // alternative lands at child(3), so addressing the slot by field
    // name rather than a fixed child(4) is what keeps `!$b` counted.
    #[cfg(feature = "php")]
    #[test]
    fn php_elided_ternary_body_still_walks_the_alternative() {
        // ternary (1) + condition `$a` (1) + `!$b` (1) = 3.
        check_metrics::<PhpParser>(
            "<?php\nfunction f() { $x = $a ?: !$b; }\n",
            "foo.php",
            |metric| assert_eq!(metric.abc.conditions_sum(), 3),
        );
    }

    // Issue #1276, PHP half. The `for` header's condition slot was the
    // one condition slot `PhpCode::compute` never dispatched, so a
    // bare / negated / parenthesised loop condition scored zero while
    // the identical predicate in an `if` header scored one. Each
    // fixture below is a shape only the new arm can classify — a
    // comparison-shaped condition proves nothing here, because the `<`
    // token arm counts it either way (grammar-dispatch §11).
    #[cfg(feature = "php")]
    #[test]
    fn php_for_condition_slot_counts_unary_conditions() {
        // Bare variable: the whole condition, no operator token.
        check_metrics::<PhpParser>(
            "<?php\nfunction f($a) { for (; $a; ) {} }\n",
            "foo.php",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
        // Negation: the slot peels the `!` (`php_wrapper_operand`) and
        // pays for the operand beneath it.
        check_metrics::<PhpParser>(
            "<?php\nfunction f($a) { for (; !$a; ) {} }\n",
            "foo.php",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
        // Parentheses: counted because the slot peels them
        // (`php_wrapper_operand`), the path #1276 found dead.
        check_metrics::<PhpParser>(
            "<?php\nfunction f($a) { for (; ($a); ) {} }\n",
            "foo.php",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
        // No-double-count pin: the `<` token arm already counted this
        // shape before the fix, and the walker must not add a second.
        // Two assignments (`$i = 0`, `$i++`) confirm the header parsed
        // as the three-clause form rather than degenerating.
        check_metrics::<PhpParser>(
            "<?php\nfunction f($n) { for ($i = 0; $i < $n; $i++) {} }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
        // Empty condition: no `condition` field, no decision, zero.
        check_metrics::<PhpParser>(
            "<?php\nfunction f() { for (;;) { break; } }\n",
            "foo.php",
            |metric| assert_eq!(metric.abc.conditions_sum(), 0),
        );
    }

    // --- Kotlin ABC tests -------------------------------------------------

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_empty_class() {
        check_metrics::<KotlinParser>("class C {}", "foo.kt", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_val_declarations_are_not_assignments() {
        // `val` introduces an immutable binding — the `=` initialising it
        // is not an assignment in the ABC sense.
        check_metrics::<KotlinParser>(
            "class C {
                val a: Int = 1
                val b: Int = 2
                val c: Int = 3
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_var_declarations_count_assignment() {
        // `var` initialisers count as assignments (mutable binding).
        check_metrics::<KotlinParser>(
            "class C {
                var a: Int = 1
                var b: Int = 2
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_val_then_assignments_count() {
        // Regression for #455: a `val` initialiser must not suppress the
        // standalone `=` assignments that follow it. tree-sitter-kotlin
        // emits no `SEMI` token (even for explicit semicolons), so the
        // pre-#455 `SEMI`-cleared declaration stack never cleared and the
        // immutable-`val` sentinel leaked, reporting A=0 here.
        check_metrics::<KotlinParser>(
            "fun f() {
                val cfg = 0
                a = 1
                b = 2
            }",
            "foo.kt",
            |metric| {
                // val initialiser suppressed; `a = 1` and `b = 2` count.
                assert_eq!(metric.abc.assignments_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_var_then_assignments_count() {
        // Companion to the #455 regression: a `var` declaration leaves a
        // mutable-binding sentinel that *permits* the `=` — this path
        // accidentally masked the leak (its `Var` sentinel never suppressed
        // anything), so it must keep counting both the initialiser and the
        // following standalone assignments.
        check_metrics::<KotlinParser>(
            "fun f() {
                var cfg = 0
                a = 1
                b = 2
            }",
            "foo.kt",
            |metric| {
                // var initialiser (+1) plus `a = 1` and `b = 2` (+2).
                assert_eq!(metric.abc.assignments_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_augmented_assignments_count() {
        // Augmented operators (+=, -=, etc.) and ++/-- always count.
        check_metrics::<KotlinParser>(
            "fun m() {
                var x = 0
                x += 1
                x -= 2
                x *= 3
                x++
                --x
            }",
            "foo.kt",
            |metric| {
                // var declaration (var x = 0): +1
                // x += 1, x -= 2, x *= 3, x++, --x: +5
                assert_eq!(metric.abc.assignments_sum(), 6);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_branches_call_expression() {
        check_metrics::<KotlinParser>(
            "fun m() {
                println(\"a\")
                println(\"b\")
                println(\"c\")
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_object_construction_branch() {
        // Kotlin's object construction is just `Foo()` — a `CallExpression`.
        check_metrics::<KotlinParser>(
            "class P(val x: Int)
            fun m(): P = P(1)",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_comparisons_count_conditions() {
        check_metrics::<KotlinParser>(
            "fun m(a: Int, b: Int): Boolean {
                val r1 = a < b
                val r2 = a > b
                val r3 = a <= b
                val r4 = a >= b
                val r5 = a == b
                val r6 = a != b
                return r1 || r2 || r3 || r4 || r5 || r6
            }",
            "foo.kt",
            |metric| {
                // Six comparison operators in the `val` initialisers
                // (<, >, <=, >=, ==, !=) → 6, plus the six bare-identifier
                // operands of the `r1 || … || r6` return chain, each a
                // Fitzpatrick Rule 9 unary condition (issue #557) → 6.
                // Total 12. Before the Kotlin walker was wired the chain
                // operands were silently dropped and this read 6.
                assert_eq!(metric.abc.conditions_sum(), 12);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_identity_equality_conditions() {
        // `===` / `!==` are referential equality in Kotlin; they count too.
        check_metrics::<KotlinParser>(
            "fun m(a: Any, b: Any): Boolean {
                return a === b || a !== b
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_else_branch_counts() {
        check_metrics::<KotlinParser>(
            "fun m(x: Int): Int {
                return if (x > 0) 1 else -1
            }",
            "foo.kt",
            |metric| {
                // condition: > (1) + else (1) = 2
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_when_entries_count() {
        check_metrics::<KotlinParser>(
            "fun m(x: Int): Int {
                return when (x) {
                    1 -> 10
                    2 -> 20
                    else -> 0
                }
            }",
            "foo.kt",
            |metric| {
                // Non-`else` WhenEntry arms count; the `else ->` fallback
                // arm does not (issue #456). Two case arms + zero for the
                // `else` arm = 2.
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Pins the `else ->` exclusion directly: a `when` whose only fallback
    // is `else ->` must not count that arm. Revert-verified — gating the
    // `WhenEntry` arm on `!kotlin_when_entry_is_else` is what drops this
    // from 3 to 2 (issue #456, lesson 11). Mirrors the cyclomatic gate.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_when_else_not_a_condition() {
        check_metrics::<KotlinParser>(
            "fun m(x: Int): Int {
                return when (x) { 1 -> 10; 2 -> 20; else -> 0 }
            }",
            "foo.kt",
            |metric| {
                // case `1 ->` (+1) + case `2 ->` (+1) + `else ->` (+0) = 2.
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // The Kotlin binding of the two assertions every #1421 fixture needs,
    // coupled on purpose. A per-member score table is worth only as much
    // as the anchor proving the fixture still spells what it claims to
    // (`.claude/rules/testing.md`, "Perturb the fixture as well as the
    // production line"), and the `when_subject` count is the anchor no
    // score can stand in for: a `when` that grew a subject scores its
    // entries the pre-#1421 way with every other row still satisfied.
    // Each fixture is one class, so the members are `spaces[0]`'s.
    #[cfg(feature = "kotlin")]
    #[track_caller]
    fn assert_kotlin_class_members(
        src: &str,
        kinds: &[(u16, usize, &str)],
        expected: &[(&str, u64, u64)],
    ) {
        assert_fixture_spells::<KotlinParser>(src, "foo.kt", kinds);
        check_func_space::<KotlinParser, _>(src, "foo.kt", |space| {
            assert_members_score(&space.spaces[0], expected);
        });
    }

    // #1421's headline. A subject-less `when` arm's condition is an
    // ordinary boolean expression, so its comparison operator is already
    // an ABC condition through the token arms; the `WhenEntry` arm added
    // a second one on top, and `two` reported 4 against a decision count
    // of 2.
    //
    // `bare` is the control that isolates the defect rather than merely
    // observing it: same arm count, same entry shape, no comparison
    // operator anywhere — so it scored the right 2 before the fix and
    // after it. A fix that changed both members alike would be attacking
    // the entry count, which was never wrong.
    //
    // `ge` and `eq` exist because the issue named `<` and `>` only. All
    // six comparison spellings share the defect: `>=` and `==` reach
    // `stats.conditions` through the `LTEQ | GTEQ | EQEQ | …` arm rather
    // than the parent-gated `LT | GT` arm, and both scored 2 against a
    // decision count of 1.
    //
    // `iff` is the member that legitimately sits *above* its decision
    // count, and it is here so the table cannot be read as "§8 parity
    // everywhere". ABC counts the `else` (Fitzpatrick Rule 5) and
    // cyclomatic does not, so 2 conditions against 1 decision is correct
    // and unchanged by this fix.
    //
    // The `when_subject` anchor is the load-bearing one: the whole test
    // turns on these `when`s having no subject, and nothing in the
    // measured numbers would notice a fixture that grew one — a
    // subject-ful `when (x) { … }` scores its entries the old way and
    // `two` would read 4 again with every other row still satisfied.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_subjectless_when_arm_counts_its_condition_once() {
        let src = "class K {
                fun f(): Boolean = true
                fun two(x: Int): Int = when { x > 5 -> 1; x < 0 -> 2; else -> 0 }
                fun bare(x: Boolean, y: Boolean): Int = when { x -> 1; y -> 2; else -> 0 }
                fun ge(x: Int): Int = when { x >= 5 -> 1; else -> 0 }
                fun eq(x: Int): Int = when { x == 5 -> 1; else -> 0 }
                fun andd(a: Int, b: Int): Int = when { a > 1 && b < 2 -> 1; else -> 0 }
                fun call(): Int = when { f() -> 1; else -> 0 }
                fun iff(x: Int): Int = if (x > 5) 1 else 0
            }";
        assert_kotlin_class_members(
            src,
            &[
                (Kotlin::WhenSubject as u16, 0, "`when` subjects"),
                (Kotlin::WhenEntry as u16, 14, "`when` entries"),
                (
                    Kotlin::BinaryExpression as u16,
                    8,
                    "comparison / chain expressions",
                ),
                (Kotlin::AMPAMP as u16, 1, "`andd`'s `&&`"),
            ],
            &[
                // (member, abc.conditions, cyclomatic)
                ("f", 0, 1),
                // Was 4: two entries, two comparisons, counted twice.
                ("two", 2, 3),
                // The no-comparison control — 2 before and after.
                ("bare", 2, 3),
                // Was 2 each: the `GTEQ` / `EQEQ` spellings.
                ("ge", 1, 2),
                ("eq", 1, 2),
                // Was 3. A compound condition keeps both of its
                // comparisons — suppressing the operators instead
                // would have collapsed this one to 1.
                ("andd", 2, 3),
                // The condition slot scores a call directly, so a
                // spelling with no operator in it still reads 1.
                ("call", 1, 2),
                // Above its decision count on purpose: ABC counts
                // the `else`, cyclomatic does not.
                ("iff", 2, 2),
            ],
        );
    }

    // #1459, the regression #1421 left behind. Turning the `when`
    // entry's blanket count into a condition slot moved the payment from
    // the entry to the condition — so every shape the slot cannot
    // classify went from 1 to 0, silently. Two shapes did:
    //
    // - `a!!`. `unary_expression` is one kind for *both* Kotlin unary
    //   spellings, and the slot routed it to the peel, so this reads as
    //   handled at every call site. The peel then looked for the operand
    //   at child(1) — right for the prefix `!x`, wrong for a postfix
    //   `x!!`, whose child(1) is the `!!` token — and stopped.
    // - `a as Boolean`. `as_expression` was not a wrapper the peel knew
    //   at all, so the slot fell off the end of its `else if`.
    //
    // The controls are `bare` / `cmp` / `call`, one per surviving path
    // (terminal, comparison token, invocation): a fix that moved the
    // entry count back would take those to 2 and fail here, which is
    // what distinguishes repairing the peel from reverting #1421.
    //
    // `safe` is the §5 row and the one measurement decided rather than
    // taste. `as?` is already a condition *token*
    // (`src/metrics/abc/kotlin.rs`), so a peel that treated `as` and
    // `as?` alike would score it 2 — the double count that arm's own
    // fix was avoiding. `kotlin_wrapper_operand` excludes `as?` for
    // that reason, and this member is what fails if the exclusion goes:
    // `(a as? Boolean)!!` is valid Kotlin whose peel reaches the cast
    // through two other wrappers, so it needs no invalid fixture to
    // discriminate.
    //
    // `iff` carries the same `a!!` through the `if` slot. That half is
    // not #1421 fallout — `if (a!!)` has read 0 since the slot landed in
    // #773 — but it is the same peel and the same edit, and a fix
    // narrowed to `when` entries would leave it at 0.
    //
    // Every member is valid Kotlin: `a!!` on a `Boolean?`, `as` on an
    // `Any`, and `(a as? Boolean)!!` back to a `Boolean`. The kind
    // anchors are what stop a later edit from trimming a spelling out
    // and turning its member into a silent copy of `bare`.
    //
    // Since #1533 the slot pays for any operand it cannot see a
    // comparison or chain inside, so `bang`, `paren`, `cast` and `chain`
    // score 1 with or without the peel. `bangCmp` and `castCmp` are what
    // still need it: unpeeled, the wrapper pays as a value on top of the
    // `>` it hides, and they read 2.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_condition_slot_peels_null_assertions_and_casts() {
        let src = "class K {
                fun g(x: Boolean): Boolean = true
                fun bare(a: Boolean): Int = when { a -> 1; else -> 0 }
                fun cmp(a: Int): Int = when { a > 5 -> 1; else -> 0 }
                fun call(a: Boolean): Int = when { g(a) -> 1; else -> 0 }
                fun bang(a: Boolean?): Int = when { a!! -> 1; else -> 0 }
                fun paren(a: Boolean?): Int = when { (a!!) -> 1; else -> 0 }
                fun cast(a: Any): Int = when { a as Boolean -> 1; else -> 0 }
                fun chain(a: Any?): Int = when { a!! as Boolean -> 1; else -> 0 }
                fun safe(a: Any): Int = when { (a as? Boolean)!! -> 1; else -> 0 }
                fun cmt(a: Boolean): Int = when { ! /*c*/ a -> 1; else -> 0 }
                fun iff(a: Boolean?): Int { if (a!!) { return 1 }; return 0 }
                fun bangCmp(a: Int): Int = when { (a > 5)!! -> 1; else -> 0 }
                fun castCmp(a: Int): Int = when { (a > 5) as Boolean -> 1; else -> 0 }
            }";
        assert_kotlin_class_members(
            src,
            &[
                (Kotlin::WhenSubject as u16, 0, "`when` subjects"),
                (
                    Kotlin::BANGBANG as u16,
                    6,
                    "the `!!` null assertions of `bang` / `paren` / `chain` / `safe` / `iff` / \
                     `bangCmp`",
                ),
                (
                    Kotlin::AsExpression as u16,
                    4,
                    "the casts of `cast` / `chain` / `safe` / `castCmp`",
                ),
                (Kotlin::AsQMARK as u16, 1, "`safe`'s safe cast"),
                (
                    Kotlin::BlockComment as u16,
                    1,
                    "`cmt`'s interposed comment, spaces and all",
                ),
                (
                    Kotlin::ParenthesizedExpression as u16,
                    4,
                    "the parenthesised operands of `paren` / `safe` / `bangCmp` / `castCmp`",
                ),
            ],
            &[
                // (member, abc.conditions, cyclomatic)
                ("g", 0, 1),
                // The three controls, unchanged by this fix.
                ("bare", 1, 2),
                ("cmp", 1, 2),
                ("call", 1, 2),
                // Each was 0: the peel stopped on the wrapper.
                ("bang", 1, 2),
                ("paren", 1, 2),
                ("cast", 1, 2),
                ("chain", 1, 2),
                // 1, not 2 — the `as?` token owns this one, and the
                // peel declines to charge for it a second time.
                ("safe", 1, 2),
                // The peel reads its operand through the `operator` /
                // `argument` fields, so an `extra` between the two no
                // longer displaces it. The spacing is load-bearing and
                // must not be tidied away: `!/*c*/a` unspaced parses
                // with the comment somewhere a `child(1)` read still
                // skips, so only the spaced spelling can tell the field
                // read from the positional one. Measured both ways.
                ("cmt", 1, 2),
                // The `if` slot, which has read 0 since #773.
                ("iff", 1, 2),
                // The `>` pays; the peel keeps the wrapper from paying too.
                ("bangCmp", 1, 2),
                ("castCmp", 1, 2),
            ],
        );
    }

    // The other half of #1421: a subject-ful entry must not move. Its
    // condition is a *pattern* matched against the subject, not an
    // independent boolean expression, so the implicit `subject ==
    // pattern` is the decision and the entry itself pays for it —
    // `range_test`, `type_test` and a bare constant carry no token the
    // comparison arms would count.
    //
    // `cmp` is the interesting row and the reason `nested` sits beside
    // it. `when (x) { y > 5 -> … }` is legal when `x` is `Boolean`, and
    // it reads 2 conditions against 1 decision — the entry's implicit
    // equality plus the `>` inside the operand. That is not the #1421
    // double-count reappearing: `nested` spells the same thing as an
    // `if` (`x == (y > 5)`) and ABC has always scored it 2 against the
    // same 1 decision. A comparison nested inside a comparison is two
    // comparisons; only one of them is a branch.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_subjectful_when_arms_keep_the_per_entry_count() {
        let src = "class K {
                fun inn(a: Int): Int = when (a) { in 1..2 -> 1; else -> 0 }
                fun notin(a: Int): Int = when (a) { !in 1..2 -> 1; else -> 0 }
                fun iss(a: Any): Int = when (a) { is String -> 1; else -> 0 }
                fun konst(a: Int): Int = when (a) { 1 -> 10; 2 -> 20; else -> 0 }
                fun cmp(x: Boolean, y: Int): Int = when (x) { y > 5 -> 1; else -> 0 }
                fun nested(x: Boolean, y: Int): Int { if (x == (y > 5)) { return 1 }; return 0 }
            }";
        assert_kotlin_class_members(
            src,
            &[
                (Kotlin::WhenSubject as u16, 5, "`when` subjects"),
                (Kotlin::WhenEntry as u16, 11, "`when` entries"),
                (Kotlin::RangeTest as u16, 2, "`in` / `!in` patterns"),
                (Kotlin::TypeTest as u16, 1, "the `is` pattern"),
                (
                    Kotlin::BinaryExpression as u16,
                    3,
                    "`cmp`'s and `nested`'s comparisons",
                ),
            ],
            &[
                ("inn", 1, 2),
                ("notin", 1, 2),
                ("iss", 1, 2),
                ("konst", 2, 3),
                // Above its decision count, like `nested` below it
                // and for the same reason.
                ("cmp", 2, 2),
                ("nested", 2, 2),
            ],
        );
    }

    // `kotlin_enclosing_when_has_subject` stops scanning at the `{`, so
    // that a subject-less `when` does not walk all N arms once per arm.
    // The bound has to clear the header first, and the header can carry
    // an `extra`: tree-sitter hangs `when /*c*/ (x)`'s comment off the
    // `when_expression` between the keyword and the subject, so a bound
    // one child tighter — `child(1)`, or a stop at the first *named*
    // child — reads `cmtSubject` as subject-less. It would then score
    // its `1` arm through the slot, where a `number_literal` is not a
    // Kotlin terminal, and report 0 conditions instead of 1. That is
    // what discriminates here; `cmtNone` is the other direction, where
    // the brace is all the bound has to stop on.
    //
    // The `block_comment` census is the fixture anchor: delete either
    // comment and the members still read 1, because a plain `when (x)`
    // and a plain `when {` both do. The count fails by name instead.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_when_subject_scan_clears_a_comment_before_the_brace() {
        let src = "class K {
                fun cmtSubject(x: Int): Int = when /*c*/ (x) { 1 -> 1; else -> 0 }
                fun cmtNone(a: Boolean): Int = when /*c*/ { a -> 1; else -> 0 }
            }";
        assert_kotlin_class_members(
            src,
            &[
                (Kotlin::BlockComment as u16, 2, "the two header comments"),
                (Kotlin::WhenSubject as u16, 1, "`cmtSubject`'s subject"),
                (Kotlin::WhenEntry as u16, 4, "`when` entries"),
            ],
            &[("cmtSubject", 1, 2), ("cmtNone", 1, 2)],
        );
    }

    // A subject-less condition reaches the slot through the same
    // `kotlin_wrapper_operand` peel an `if` predicate does, which
    // is what separates this design from suppressing the entry's
    // operator. `notted` and `paren` unwrap to a bare terminal and score
    // through the slot; `notCmp` and `parenCmp` unwrap to a
    // `binary_expression`, score nothing from the slot, and take their
    // one condition from the `>` the token arm already owned. Both pairs
    // land on 1, which no blanket `+1` can produce for the second pair —
    // they read 2 before the fix.
    //
    // `paren` once reached the slot only through a `WhenEntry` seed in the
    // retired walker's boolean-context set, and dropped to 0 without it.
    // On the shared slot (#1533) it pins that a `when` entry peels a
    // parenthesis as `if ((a))` does; `notted` cannot stand in for it,
    // since a `!` is a wrapper of its own.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_subjectless_when_condition_wrappers_count_once() {
        let src = "class K {
                fun notted(a: Boolean): Int = when { !a -> 1; else -> 0 }
                fun paren(a: Boolean): Int = when { (a) -> 1; else -> 0 }
                fun notCmp(a: Int): Int = when { !(a > 1) -> 1; else -> 0 }
                fun parenCmp(a: Int): Int = when { (a > 1) -> 1; else -> 0 }
                fun nest(x: Int, y: Int): Int =
                    when { x > 1 -> when { y > 2 -> 1; else -> 2 }; else -> 0 }
                fun blockBody(x: Int): Int { when { x > 5 -> { return 1 } }; return 0 }
            }";
        assert_kotlin_class_members(
            src,
            &[
                // Paired, not bare: "no subjects" alone is satisfied by a
                // fixture that lost its `when`s altogether.
                (Kotlin::WhenSubject as u16, 0, "`when` subjects"),
                (Kotlin::WhenEntry as u16, 13, "`when` entries"),
                (Kotlin::UnaryExpression as u16, 2, "the two `!` operands"),
                (
                    Kotlin::ParenthesizedExpression as u16,
                    3,
                    "the three parenthesised operands",
                ),
                (Kotlin::BinaryExpression as u16, 5, "comparisons"),
            ],
            &[
                ("notted", 1, 2),
                ("paren", 1, 2),
                // Both were 2: the entry's blanket count plus the `>`.
                ("notCmp", 1, 2),
                ("parenCmp", 1, 2),
                // Was 4 — one entry and one comparison per `when`,
                // each counted twice.
                ("nest", 2, 3),
                // The `when`-as-statement shape: a `block` body and no
                // `else` arm at all. Reading the condition from the
                // `condition` field rather than by position is what keeps
                // the block out of the slot; it was 2 before the fix.
                ("blockBody", 1, 2),
            ],
        );
    }

    // The one place this design deliberately does not reach parity, put
    // under test so the choice cannot drift unremarked. A `when` entry
    // may list alternatives (`when { a, b -> … }`, an implicit `or`), and
    // the `condition` field is `multiple` — but cyclomatic scores the
    // whole entry as one decision, so `bareAlts` is at parity only
    // because the slot reads the *first* alternative and stops. Routing
    // every alternative through the slot would push it to 2.
    //
    // `alts` is the row that cannot be brought to parity from the ABC
    // side at all: the comparison-token arms count `>` and `<` wherever
    // they appear, so it reads 2 against 1 decision no matter what the
    // entry slot does. It was 3 before #1421 and the remaining gap is
    // cyclomatic's single count per multi-alternative entry, not a
    // double-count here.
    //
    // `subjAlts` is the subject-ful control, unchanged and at parity: its
    // alternatives are constants carrying no token to count.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_subjectless_when_multi_alternative_entry() {
        let src = "class K {
                fun alts(x: Int, y: Int): Int = when { x > 5, y < 0 -> 1; else -> 0 }
                fun bareAlts(x: Boolean, y: Boolean): Int = when { x, y -> 1; else -> 0 }
                fun subjAlts(a: Int): Int = when (a) { 1, 2 -> 10; else -> 0 }
            }";
        assert_kotlin_class_members(
            src,
            &[
                (Kotlin::WhenSubject as u16, 1, "`subjAlts`'s subject"),
                (Kotlin::WhenEntry as u16, 6, "`when` entries"),
                (
                    Kotlin::BinaryExpression as u16,
                    2,
                    "`alts`'s two comparisons",
                ),
            ],
            &[
                // Above its decision count: cyclomatic scores the entry
                // once, the token arms score both comparisons. Was 3.
                ("alts", 2, 2),
                ("bareAlts", 1, 2),
                ("subjAlts", 1, 2),
            ],
        );
    }

    // `is_expression` and `in_expression` are the two relational forms
    // tree-sitter-kotlin-ng spells as their own production rather than as
    // a `binary_expression`, so no comparison-token arm sees them and
    // nothing counted them: `if (a is String)` scored 0 against a
    // decision count of 1, and the same test in a subject-less `when`
    // scored 1 only because the entry's blanket `+1` happened to cover
    // it. Removing that blanket without counting these two somewhere
    // would have regressed `whenIs` and `whenIn` to 0, and `isAnd` —
    // where the `is` test is one operand of a `&&` chain and so reaches
    // the walker rather than the slot — from 2 to 1.
    //
    // The `if` members are here because the fix was never `when`-
    // specific: they are the call sites that prove it reaches the `if` /
    // `while` predicate slot too.
    //
    // #1421 counted them through the former
    // `kotlin_bool_terminal_kinds!()` and
    // #1461 moved them to an unconditional arm, which leaves every
    // number below unchanged — the slot no longer counts the test and
    // the arm does. `kotlin_is_and_in_score_outside_a_boolean_slot` is
    // the half this fixture cannot see, every member of it being inside
    // a slot.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_is_and_in_expressions_are_unary_conditions() {
        let src = "class K {
                fun ifIs(a: Any): Int { if (a is String) { return 1 }; return 0 }
                fun ifIn(a: Int): Int { if (a in 1..2) { return 1 }; return 0 }
                fun whenIs(a: Any): Int = when { a is String -> 1; else -> 0 }
                fun whenIn(a: Int): Int = when { a in 1..2 -> 1; else -> 0 }
                fun isAnd(a: Any, b: Boolean): Int = when { a is String && b -> 1; else -> 0 }
            }";
        assert_kotlin_class_members(
            src,
            &[
                // Paired, not bare — see the wrappers test above.
                (Kotlin::WhenSubject as u16, 0, "`when` subjects"),
                (Kotlin::WhenEntry as u16, 6, "`when` entries"),
                (Kotlin::IsExpression as u16, 3, "`is` tests"),
                (Kotlin::InExpression as u16, 2, "`in` tests"),
                (Kotlin::AMPAMP as u16, 1, "`isAnd`'s `&&`"),
            ],
            &[
                // Both were 0 — the predicate slot saw a kind it did
                // not classify and the token arms saw no operator.
                ("ifIs", 1, 2),
                ("ifIn", 1, 2),
                ("whenIs", 1, 2),
                ("whenIn", 1, 2),
                ("isAnd", 2, 3),
            ],
        );
    }

    // Kotlin spells boolean `and` / `or` / `xor` as infix *functions*, so
    // `a and b` parses as `infix_expression` — not `binary_expression`,
    // and not any token arm. A slot pays for it for the same reason it
    // pays for a `call_expression`: `a and b` is `a.and(b)`.
    //
    // This was a regression of #1421, not a pre-existing gap, and it is
    // the third shape the blanket per-entry count turned out to be
    // propping up — after `is` / `in` and bare parens, which that fix
    // caught. Found by the whole-branch review. Measured on both sides:
    // `when { a and b -> … }` scored 1 before and 0 after, while the
    // `if (a and b)` it is supposed to agree with still scored 1.
    //
    // The `if` members are the anchor rather than a second `when`: the
    // whole premise of #1421 is that a subject-less arm scores like an
    // `if` predicate, so a fixture where the two disagree is the
    // statement of the bug. `andAmp` holds the pair level against the
    // `&&` spelling, which never regressed and would otherwise be the
    // only form under test.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_infix_boolean_functions_are_unary_conditions() {
        let src = "class K {
                fun whenAnd(a: Boolean, b: Boolean): Int = when { a and b -> 1; else -> 0 }
                fun whenOr(a: Boolean, b: Boolean): Int = when { a or b -> 1; else -> 0 }
                fun whenXor(a: Boolean, b: Boolean): Int = when { a xor b -> 1; else -> 0 }
                fun whenAmp(a: Boolean, b: Boolean): Int = when { a && b -> 1; else -> 0 }
                fun ifAnd(a: Boolean, b: Boolean): Int { if (a and b) { return 1 }; return 0 }
            }";
        assert_kotlin_class_members(
            src,
            &[
                (Kotlin::WhenSubject as u16, 0, "`when` subjects"),
                (Kotlin::InfixExpression as u16, 4, "the infix calls"),
                (Kotlin::AMPAMP as u16, 1, "`whenAmp`'s `&&`"),
            ],
            &[
                // 0 before this fix: the predicate slot saw a kind it
                // did not classify and no token arm matched.
                ("whenAnd", 1, 2),
                ("whenOr", 1, 2),
                ("whenXor", 1, 2),
                // Never regressed — `&&` is a `binary_expression` whose
                // operator the token arm owns. Holds the others level.
                ("whenAmp", 2, 3),
                // The agreement #1421 exists to establish: a
                // subject-less arm scores what the equivalent `if`
                // predicate scores.
                ("ifAnd", 1, 2),
            ],
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_catch_block_counts() {
        check_metrics::<KotlinParser>(
            "fun m() {
                try {
                    println(\"ok\")
                } catch (e: Exception) {
                    println(\"err\")
                }
            }",
            "foo.kt",
            |metric| {
                // `try` (+1) and `catch` (+1) each contribute one condition,
                // matching Java / C# / C++ / Groovy (Fitzpatrick counts both
                // keywords). Before #696 Kotlin counted only the catch block.
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_elvis_and_safe_cast() {
        // `?:` (elvis) and `as?` (safe cast) are condition-like.
        check_metrics::<KotlinParser>(
            "fun m(s: String?): Int {
                val n = (s as? Int) ?: 0
                return n
            }",
            "foo.kt",
            |metric| {
                // as? (+1) + ?: (+1) = 2 conditions.
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_generic_brackets_not_conditions() {
        // `<` / `>` used as type-parameter brackets must not be counted.
        check_metrics::<KotlinParser>(
            "class Box<T>(val v: T)
            fun <T> wrap(x: T): Box<T> = Box(x)",
            "foo.kt",
            |metric| {
                // No comparisons — only generic brackets.
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // #1297: a qualified super call disambiguates its supertype with
    // the same two bare tokens a comparison uses — `super<A>.g()` is a
    // `super_expression`, which the previous denylist
    // (`type_arguments` / `type_parameters`) did not name, so it scored
    // two conditions. One `super<A>` against one genuine `a < b`
    // separates every mis-aim: 3 pre-fix, 1 once the arm allows
    // `BinaryExpression`, 0 if it allows the wrong parent or the
    // fixture stops parsing.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_super_type_argument_is_not_a_condition() {
        check_metrics::<KotlinParser>(
            "class B : A() {
                override fun g(a: Int, b: Int): Int {
                    if (a < b) { return super<A>.g(a, b) }
                    return 0
                }
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                // Non-vacuity guard: 1 is also what a body whose `if`
                // survived but whose super call did not would score, so
                // pin the call itself. Measured: dropping
                // `super<A>.g(a, b)` takes `branches_sum()` from 2 to 1 —
                // the remaining branch is the `A()` primary-constructor
                // delegation in the class header, which #1384 taught this
                // metric to count.
                assert_eq!(metric.abc.branches_sum(), 2);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_class_with_methods_and_branches() {
        check_metrics::<KotlinParser>(
            "class C {
                var counter: Int = 0
                fun bump() {
                    counter += 1
                    println(counter)
                }
            }",
            "foo.kt",
            |metric| {
                // assignments: var counter = 0 (+1), counter += 1 (+1) = 2
                // branches: println(counter) = 1
                assert_eq!(metric.abc.assignments_sum(), 2);
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_object_singleton_abc() {
        check_metrics::<KotlinParser>(
            "object Util {
                fun work(x: Int): Int {
                    var y = x
                    y += 1
                    if (y > 0) {
                        return y
                    }
                    return -1
                }
            }",
            "foo.kt",
            |metric| {
                // assignments: var y = x (+1), y += 1 (+1) = 2
                // branches: 0 (return is not a call)
                // conditions: y > 0 (+1) = 1
                assert_eq!(metric.abc.assignments_sum(), 2);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_interface_abc() {
        // Pure-abstract interface with no bodies — all-zero.
        check_metrics::<KotlinParser>(
            "interface I {
                fun work(): Int
                fun describe(): String
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_nested_class_abc() {
        check_metrics::<KotlinParser>(
            "class Outer {
                var o: Int = 0
                class Nested {
                    var n: Int = 0
                    fun bump() { n += 1 }
                }
            }",
            "foo.kt",
            |metric| {
                // Outer: var o = 0 (+1)
                // Nested: var n = 0 (+1), n += 1 (+1) = 2
                // total assignments = 3
                assert_eq!(metric.abc.assignments_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_data_class_abc() {
        // `data class` with primary-constructor `val`s — no assignments
        // (vals don't count) and no body conditions.
        check_metrics::<KotlinParser>(
            "data class Point(val x: Int, val y: Int)",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_primary_constructor_default_value_not_assignment() {
        // Regression: default values on primary-constructor `val`
        // parameters are initialisers, not assignments. Without
        // `ClassParameter` pushing a declaration sentinel, the `=` token
        // here would be counted unconditionally as a standalone
        // assignment.
        check_metrics::<KotlinParser>("class C(val a: Int = 5)", "foo.kt", |metric| {
            // `val a = 5` → suppressed (Const sentinel).
            assert_eq!(metric.abc.assignments_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_unary_conditions_in_chain() {
        // Fitzpatrick Rule 9 (issue #557): each bare boolean operand of a
        // `&&` / `||` chain is one condition. `a && b || c` → a, b, c each
        // contribute one; the `&&` / `||` operators contribute nothing.
        // expected: 3 unary conditions, no comparisons, no `if`-keyword
        // condition in Kotlin (matches the Java byte-equivalent of 3).
        check_metrics::<KotlinParser>(
            "fun f(a: Boolean, b: Boolean, c: Boolean) {
                if (a && b || c) { println(\"x\") }
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_comparison_operands_add_nothing() {
        // Isolation check: comparison operands of a `&&` chain are nested
        // `binary_expression` nodes, not bare boolean leaves, so the
        // walker adds nothing — only the two `>` comparisons count.
        // expected: 2 (the two `>` tokens), walker contributes 0.
        check_metrics::<KotlinParser>(
            "fun g(x: Int, y: Int) {
                if (x > 0 && y > 0) { println(\"x\") }
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_negated_operand_is_unary_condition() {
        // A `!`-negated operand is still a unary condition: `a && !b`
        // unwraps the `unary_expression` to reach the inner identifier.
        // expected: 2 (`a` and the `!b` operand).
        check_metrics::<KotlinParser>(
            "fun f(a: Boolean, b: Boolean) {
                if (a && !b) { println(\"x\") }
            }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // The wrapper peel has two callers, and #1459's fixture members all
    // reach it through the *slot* (`kotlin_count_condition`). This is the
    // other one: the `&&` / `||` walker (`count_field_operands`),
    // which hands each operand to the same slot. The two wrappers #1459
    // taught it therefore have a
    // second, structurally independent path into the count, and a
    // fixture covering only the slot leaves it untested
    // (`.claude/rules/grammar-dispatch.md` §11).
    //
    // Each chain is one identifier plus one wrapped comparison, so 2 is
    // "the walker peeled the wrapper to the comparison, which pays for
    // itself" and 3 is "it paid the wrapper as a value as well". Since
    // the slot pays for any operand it cannot see a comparison inside
    // (#1533), a wrapped bare identifier scores 2 either way, so only a
    // wrapped comparison tells the peel from its absence. The bare
    // `a && b` control is `kotlin_unary_conditions_in_chain`'s shape at
    // 2, so a regression cannot be read as the chain itself changing.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_chain_operands_peel_null_assertions_and_casts() {
        // Anchored per row, because the assertion alone cannot tell the
        // wrapper from its operand: `a && x > 1` scores the same 2 / 3 as
        // every row here, so trimming the `!!` or the cast out of a
        // fixture would leave this green with its subject gone
        // (`.claude/rules/testing.md`, "Perturb the fixture as well as
        // the production line").
        for (chain, spelling, anchors) in [
            (
                "a && (x > 1)!!",
                "null assertion",
                &[(Kotlin::BANGBANG as u16, 1usize, "the `!!`")][..],
            ),
            (
                "a && (x > 1) as Boolean",
                "cast",
                &[(Kotlin::AsExpression as u16, 1, "the `as` cast")][..],
            ),
            (
                "a && ((x > 1)!!)",
                "parenthesised null assertion",
                &[
                    (Kotlin::BANGBANG as u16, 1, "the `!!`"),
                    (Kotlin::ParenthesizedExpression as u16, 2, "the parens"),
                ][..],
            ),
        ] {
            let src = format!("fun f(a: Boolean, x: Int) {{ if ({chain}) {{ println(\"x\") }} }}");
            assert_fixture_spells::<KotlinParser>(&src, "foo.kt", anchors);
            check_func_space::<KotlinParser, _>(&src, "foo.kt", |space| {
                let f = child_space(&space, "f");
                assert_eq!(
                    f.metrics.abc.conditions(),
                    2,
                    "`{chain}`: the identifier plus the comparison under the {spelling}"
                );
                assert_eq!(f.metrics.cyclomatic.cyclomatic(), 3, "`{chain}`: decisions");
            });
        }
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_bare_if_predicate_is_one_condition() {
        // Issue #773: a bare-boolean `if` predicate (`if (flag)`) is one
        // Fitzpatrick unary condition. Before the Phase-2B arm it counted
        // 0, so `if (flag) 1 else -1` scored 1 (only the `else`) instead of
        // 2, dropping below Kotlin's own cyclomatic decision count.
        // expected: predicate (1) + else (1) = 2.
        check_metrics::<KotlinParser>(
            "fun m(flag: Boolean): Int { return if (flag) 1 else -1 }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_bare_while_predicate_is_one_condition() {
        // Issue #773: the bare predicate of a `while` loop counts one
        // condition via the `condition` field. expected: 1.
        check_metrics::<KotlinParser>(
            "fun m(running: Boolean) { while (running) { println(\"x\") } }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_bare_do_while_predicate_is_one_condition() {
        // Issue #773: the bare predicate of a `do`/`while` loop counts one
        // condition. expected: 1.
        check_metrics::<KotlinParser>(
            "fun m(ok: Boolean) { do { println(\"x\") } while (ok) }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_comparison_predicate_not_double_counted() {
        // Double-count guard (#773): a comparison predicate (`if (a == b)`)
        // is a nested `binary_expression` already counted by the `==` token
        // arm, so the Phase-2B condition-slot arm must add nothing here.
        // expected: `==` (1) + else (1) = 2 — unchanged by the new arm.
        check_metrics::<KotlinParser>(
            "fun m(a: Int, b: Int): Int { return if (a == b) 1 else -1 }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_short_circuit_predicate_not_double_counted() {
        // Double-count guard (#773): an `&&`/`||` predicate is counted by
        // the Rule 9 chain walker (each operand once); the Phase-2B arm
        // must add nothing for it. expected: `x` (1) + `y` (1) + else (1)
        // = 3 — unchanged by the new arm.
        check_metrics::<KotlinParser>(
            "fun m(x: Boolean, y: Boolean): Int { return if (x && y) 1 else -1 }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_parenthesised_bare_predicate_is_one_condition() {
        // A parenthesised bare predicate (`if ((flag))`) is unwrapped by
        // `kotlin_wrapper_operand` and still counts one condition (#773).
        // expected: 1.
        check_metrics::<KotlinParser>(
            "fun m(flag: Boolean) { if ((flag)) { println(\"x\") } }",
            "foo.kt",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    // --- TypeScript / TSX ABC tests --------------------------------------
    //
    // Assignment, branch, condition counting per Fitzpatrick:
    // - Augmented assignment / `++` / `--` always count.
    // - Plain `=` counts unless inside `const` declaration.
    // - `call_expression` / `new_expression` count as branches.
    // - Comparison / equality operators, ternary `?`, `??`, control-flow
    //   arms (`else`, `case`, `default`, `catch`, `try`, `instanceof`),
    //   and `<`/`>` (outside `type_arguments` / `type_parameters`) count
    //   as conditions.

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_assignments_basic() {
        check_metrics::<TypescriptParser>(
            "class C {
                m(): void {
                    let x = 0;          // +1 — only a `const` initializer is suppressed
                    x = 1;              // +1
                    x += 2;             // +1
                    x++;                // +1
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_const_excluded_from_assignments() {
        check_metrics::<TypescriptParser>(
            "class C {
                m(): void {
                    const a = 1;        // suppressed (`const` initializer)
                    const b = 2;        // suppressed
                    let c = 3;          // +1 — `let` initializers count
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Regression cluster for #1277. The pre-fix implementation decided
    // "is this `=` a `const` initializer?" from a sentinel stack cleared
    // only on a `SEMI` token, so the answer for one statement depended on
    // the *previous* statement's terminator. Automatic semicolon
    // insertion makes that terminator optional in all four JS-family
    // languages. The replacement is structural — see
    // `impl_js_family_const_binding!` in `src/metrics/abc/js_family.rs`.

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_asi_const_does_not_suppress_later_assignments() {
        check_metrics::<TypescriptParser>(
            "function f() {
                const a = 1
                x = 2
                y = 3
            }",
            "foo.ts",
            |metric| {
                // `const a = 1` suppressed; `x = 2` and `y = 3` count.
                // Pre-#1277 this reported 0: the unterminated `const`
                // never popped its sentinel.
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_semicolon_const_does_not_suppress_later_assignments() {
        // The semicolon-terminated spelling of the fixture above, which
        // must score the same as it. Pre-#1277 they scored 2 and 0 — the
        // pair is what pins the terminator out of the answer.
        check_metrics::<TypescriptParser>(
            "function f() {
                const a = 1;
                x = 2;
                y = 3;
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_as_const_does_not_suppress_later_assignments() {
        // The sentinel stack was also reachable from the other side: the
        // `const` token of a TypeScript `x as const` assertion promoted a
        // live `let` slot to `Const` and suppressed every `=` until the
        // next `;`. Structurally that `const` is a child of an
        // `as_expression`, not a declaration keyword.
        check_metrics::<TypescriptParser>(
            "function f(x: number) {
                let y = x as const
                w = 3
            }",
            "foo.ts",
            |metric| {
                // `let` initializer (+1) and `w = 3` (+1); pre-#1277: 1.
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_const_declarator_shapes_stay_suppressed() {
        // Shapes the sentinel stack handled implicitly, which the
        // structural predicate must reproduce: *every* declarator under a
        // `const`-bearing `lexical_declaration` is suppressed, including
        // the second element of a multi-declarator list, a destructuring
        // pattern, and the defaults inside one — `c = 5`, the nested
        // `e = 6` and its `= {}`, `g = 7`, and the rest element's `h = 8`,
        // each one more pattern layer the predicate's climb has to cross
        // — while `for (const x of xs)` carries no `=` at all. Only
        // `let i = 3` and `var j = 4` count — the deliberate deviation
        // documented on `js_abc_compute!`. Gating on
        // `variable_declaration` instead of `lexical_declaration`,
        // dropping the `const` check, or stopping the climb at the
        // declarator's own `=`, each flips one of these rows. The
        // `for`-of row is the exception: it carries no `=`, so no change
        // to the predicate can move it. It pins the grammar shape instead
        // — a future grammar emitting a `variable_declarator` there would
        // start suppressing something that never counted.
        check_metrics::<TypescriptParser>(
            "function f(o: any, xs: number[]) {
                const a = 1, b = 2
                const {c = 5, d: {e = 6} = {}} = o
                const [g = 7, ...[h = 8]] = xs
                let i = 3
                var j = 4
                for (const x of xs) { k(x) }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_const_initializer_value_assignments_still_count() {
        // TypeScript half of
        // `javascript_const_initializer_value_assignments_still_count`.
        check_metrics::<TypescriptParser>(
            "function m(o: any, a: any, b: any) { const x = (o.p = 1); const y = a || (b = 2); }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_branches_function_calls() {
        check_metrics::<TypescriptParser>(
            "class C {
                m(): void {
                    foo();              // +1
                    bar(1, 2);          // +1
                    new Date();         // +1
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_conditions_comparison_operators() {
        check_metrics::<TypescriptParser>(
            "class C {
                m(x: number, y: number): boolean {
                    return x == y       // +1
                        || x === y      // +1
                        || x != y       // +1
                        || x !== y      // +1
                        || x < y        // +1
                        || x <= y       // +1
                        || x > y        // +1
                        || x >= y;      // +1
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 8);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_conditions_control_flow_arms() {
        check_metrics::<TypescriptParser>(
            "class C {
                m(x: number): number {
                    try {                       // +1 (try)
                        if (x > 0) {            // +1 (>)
                            return 1;
                        } else {                // +1 (else)
                            return -1;
                        }
                    } catch (e) {               // +1 (catch)
                        return 0;
                    }
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_conditions_switch_case() {
        check_metrics::<TypescriptParser>(
            "class C {
                m(x: number): number {
                    switch (x) {
                        case 1:                 // +1
                            return 1;
                        case 2:                 // +1
                            return 2;
                        default:                // +0 (fallthrough, #469)
                            return 0;
                    }
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_ternary_and_nullish() {
        check_metrics::<TypescriptParser>(
            "class C {
                m(x: number | null): number {
                    return x !== null           // +1 (!==)
                        ? x                     // +1 (ternary ?)
                        : 0;
                }
                n(x: number | null): number {
                    return x ?? 0;              // +1 (??)
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_instanceof_counts_as_condition() {
        check_metrics::<TypescriptParser>(
            "class C {
                m(o: unknown): boolean {
                    return o instanceof C;      // +1
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_generic_lt_gt_not_a_condition() {
        // `<T>` in `class C<T>` and `Array<number>` should not contribute
        // to conditions even though the tokens are `<` and `>`.
        check_metrics::<TypescriptParser>(
            "class C<T> {
                xs: Array<number> = [];
                m(): void {
                    const arr: Array<string> = [];   // suppressed const
                    void arr;
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // #1297, TypeScript half: the `<` / `>` arm flipped from denying
    // `type_arguments` / `type_parameters` to allowing
    // `binary_expression`, and this pins the direction that flip could
    // have broken. `Array<string>` keeps a generic in scope so the
    // fixture proves both sides at once, and the assertion is the
    // grammar-dispatch §8 pin: on the function's own space the ABC
    // condition count equals the cyclomatic decision count
    // (`cyclomatic()` minus the per-space base of 1). Both are 2, one
    // per `if`.
    //
    // As with the Lua fixture, `Array<string>` leaves no ABC trace once
    // excluded, so nothing here fails if a later edit drops the
    // generic; that the generic reaches the arm is established by the
    // revert test, which fails this test when the gate is removed.
    //
    // TypeScript gets no JSX fixture because the `.ts` dialect has no
    // JSX to exercise: it lexes `return <div>…</div>` as a type
    // assertion and a comparison chain, sometimes with `ERROR` nodes and
    // sometimes without, depending on what follows the tag. Either way
    // the tokens land under `type_arguments` and `binary_expression`
    // rather than the `jsx_*` productions, so the construct that
    // motivated #1297 is only reachable through
    // `tsx_jsx_elements_are_not_conditions` below.
    //
    // That mis-parse still over-counts — a `.ts` file containing JSX
    // scores conditions this gate cannot exclude, because the grammar
    // genuinely reports a `binary_expression`. It is a wrong-dialect
    // input rather than a defect in this arm, and no allowlist can
    // distinguish it; see the same caveat on Kotlin's arm.
    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_comparison_operators_still_count_alongside_generics() {
        check_func_space::<TypescriptParser, _>(
            "function m(xs: Array<string>, a: number, b: number): number {
                if (a < b) { return 1; }
                if (a > b) { return 2; }
                void xs;
                return 0;
            }",
            "foo.ts",
            |space| assert_deepest_conditions_match_cyclomatic(&space, 2),
        );
    }

    // #1275, TypeScript half. Eleven grammar productions emit a bare
    // `?` and only `ternary_expression` is a decision; the other ten are
    // type syntax. This fixture exercises five of them — `optional_
    // parameter`, `property_signature`, `method_signature`,
    // `abstract_method_signature` and `public_field_definition`, plus an
    // `optional_type` in a tuple — against one real ternary over one
    // real `>`.
    //
    // Six type-syntax `?` means the numbers separate cleanly: 8 pre-fix,
    // 2 once the allowlist is aimed at `TernaryExpression`, 1 if it is
    // aimed at anything else (the ternary stops counting too), 0 if the
    // fixture stops parsing. Any partial gate — one that named some of
    // the type-syntax parents in a denylist instead — lands between 3
    // and 7 and is equally visible.
    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_optional_type_syntax_is_not_a_condition() {
        check_metrics::<TypescriptParser>(
            "interface I { a?: string; m?(x: number): void; }
            abstract class K { f?: number; abstract g?(): void; }
            type Tup = [number, string?];
            function h(x?: number, y: number = 0): number { return y > 1 ? 1 : 2; }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // The explicit half of #1275's TypeScript decision: a conditional
    // type (`T extends U ? X : Y`) is resolved by the type checker and
    // erased before runtime, so its `?` is not a condition. That falls
    // out of the `TernaryExpression` allowlist rather than being named,
    // which is exactly why it needs its own test — the choice reads as
    // an omission otherwise, and nothing else here would notice if a
    // later edit added `ConditionalType` to the allowlist "for
    // symmetry".
    //
    // The real ternary below keeps the expectation off zero: 3 pre-fix,
    // 2 with the conditional type excluded, 1 if the ternary is
    // swallowed too.
    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_conditional_type_is_not_a_condition() {
        check_metrics::<TypescriptParser>(
            "type Cond<T> = T extends string ? number : boolean;
            function pick(a: number, b: number): number { return a > b ? 1 : 2; }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // grammar-dispatch §2. `Typescript::QMARK2` is the enum entry for
    // the external scanner's `_ternary_qmark` token, and
    // tree-sitter-typescript's public symbol map folds it back onto
    // `anon_sym_QMARK`, so `kind_id()` never reports it — every ternary
    // `?` in the fixture below arrives as plain `QMARK`. Listing
    // `QMARK2` in the gated arm would therefore be dead code, and
    // leaving it out is safe only for as long as that mapping holds.
    // This pins both halves so a grammar bump that starts exposing the
    // alias fails here rather than silently zeroing every TypeScript
    // ternary.
    //
    // The fixture's only `?` is the ternary's, deliberately. An optional
    // parameter (`b?: number`) would emit a `QMARK` of its own and
    // satisfy the positive assertion on its own, leaving it true no
    // matter what id the ternary's `?` came back as — decoration rather
    // than the non-vacuity guard it is here for.
    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_ternary_qmark_alias_stays_unreachable() {
        let parser = TypescriptParser::new(
            "function f(a: boolean): number { return a ? 1 : 2; }\n"
                .as_bytes()
                .to_vec(),
            std::path::Path::new("foo.ts"),
            None,
        );
        assert!(ast_has_kind_id(&parser, Typescript::QMARK as u16));
        assert!(!ast_has_kind_id(&parser, Typescript::QMARK2 as u16));
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_abstract_class_abc() {
        // Abstract methods have no body — they contribute nothing.
        check_metrics::<TypescriptParser>(
            "abstract class C {
                abstract a(): void;
                m(x: number): number {
                    if (x > 0) return 1;        // +1 condition
                    return 0;
                }
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_interface_abc_zero() {
        check_metrics::<TypescriptParser>(
            "interface I {
                a(): void;
                b(): number;
                p: string;
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_arrow_field_contributes_abc() {
        // Arrow function class members are function spaces; their
        // assignments/branches/conditions are counted.
        check_metrics::<TypescriptParser>(
            "class C {
                arrow = (x: number) => {
                    if (x > 0) {                // +1 condition
                        return foo();           // +1 branch
                    }
                    return 0;
                };
            }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_parameter_property_init_not_assignment() {
        // Parameter properties don't introduce a `=` token themselves;
        // only the explicit `let z = 0` body assignment is counted.
        // The class field initializer `f: number = 0` likewise has a `=`
        // that DOES count (matches `typescript_assignments_basic`).
        check_metrics::<TypescriptParser>(
            "class C {
                f: number = 0;
                constructor(public x: number, private y: string) {
                    let z = 0;
                }
            }",
            "foo.ts",
            |metric| {
                // f's initializer + `let z = 0` = 2 assignments; the
                // parameter properties contribute zero.
                assert_eq!(metric.abc.assignments_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // TSX parity

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_assignments_basic() {
        check_metrics::<TsxParser>(
            "class C {
                m(): void {
                    let x = 0;
                    x = 1;
                    x += 2;
                    x++;
                }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_const_excluded_from_assignments() {
        check_metrics::<TsxParser>(
            "class C {
                m(): void {
                    const a = 1;
                    let b = 2;
                }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_branches_function_calls() {
        check_metrics::<TsxParser>(
            "class C {
                m(): void {
                    foo();
                    new Date();
                }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_conditions_comparison_operators() {
        check_metrics::<TsxParser>(
            "class C {
                m(x: number, y: number): boolean {
                    return x == y || x < y || x >= y;
                }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_conditions_control_flow_arms() {
        check_metrics::<TsxParser>(
            "class C {
                m(x: number): number {
                    try {
                        if (x > 0) return 1;
                        else return -1;
                    } catch (e) {
                        return 0;
                    }
                }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_conditions_switch_case() {
        check_metrics::<TsxParser>(
            "class C {
                m(x: number): number {
                    switch (x) {
                        case 1: return 1;       // +1
                        case 2: return 2;       // +1
                        default: return 0;      // +0 (fallthrough, #469)
                    }
                }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_ternary_and_nullish() {
        check_metrics::<TsxParser>(
            "class C {
                m(x: number | null): number {
                    return x !== null ? x : 0;
                }
                n(x: number | null): number { return x ?? 0; }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_instanceof_counts_as_condition() {
        check_metrics::<TsxParser>(
            "class C { m(o: unknown): boolean { return o instanceof C; } }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_generic_lt_gt_not_a_condition() {
        check_metrics::<TsxParser>(
            "class C<T> { xs: Array<number> = []; }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // #1297: a JSX tag delimiter is markup punctuation, not a
    // comparison. The `<` / `>` arm denied only `type_arguments` and
    // `type_parameters`, so every tag bracket scored a condition —
    // `jsx_opening_element` contributes both tokens, `jsx_closing_element`
    // a `>` (its `</` is one token) and `jsx_self_closing_element` a `<`
    // (its `/>` is one token).
    //
    // The fixture pairs seven such brackets — two elements' opening and
    // closing tags, plus one self-closing tag — against one genuine
    // `a < b`, so every way of mis-aiming the gate lands on its own
    // number: 8 pre-fix, 1 once it allows `BinaryExpression`, 0 if it
    // allows the wrong parent or the fixture stops parsing. Asserting 0
    // on a JSX-only body would not have separated those last two.
    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_jsx_elements_are_not_conditions() {
        check_metrics::<TsxParser>(
            "function f(a: number, b: number) {
                if (a < b) { return <div className=\"x\"><span>hi</span></div>; }
                return <br />;
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                // Fixture-presence anchor: the `className="x"` attribute
                // `=` is this fixture's only assignment, so the test
                // fails if a later edit drops the JSX. Without it the
                // surviving `a < b` alone also scores 1, and the
                // conditions assertion would pass while proving nothing.
                assert_eq!(metric.abc.assignments_sum(), 1);
            },
        );
    }

    // #1275 in the second expansion of `ts_abc_compute!`. TSX shares
    // TypeScript's `?` productions and its own `TernaryExpression` /
    // `QMARK` ids, so the gate is a distinct instantiation and needs its
    // own fixture — a passing TypeScript test says nothing about the
    // macro's other expansion. Four type-syntax `?` plus one `>` and one
    // ternary: 6 pre-fix, 2 after, 1 if the allowlist is misaimed.
    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_optional_type_syntax_is_not_a_condition() {
        check_metrics::<TsxParser>(
            "interface I { a?: string; m?(x: number): void; }
            class K { f?: number; }
            function h(x?: number, y: number = 0): number { return y > 1 ? 1 : 2; }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // The TSX half of `typescript_conditional_type_is_not_a_condition`.
    // `ts_abc_compute!` expands twice and the two expansions are
    // independent code (grammar-dispatch §11): adding `ConditionalType`
    // to the allowlist "for symmetry" fails only the TypeScript test
    // without this one, which reads as the TSX expansion being fine
    // rather than untested. `conditional_type` is in the tsx grammar's
    // `?` set exactly as it is in typescript's.
    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_conditional_type_is_not_a_condition() {
        check_metrics::<TsxParser>(
            "type Cond<T> = T extends string ? number : boolean;
            function pick(a: number, b: number): number { return a > b ? 1 : 2; }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // The TSX half of `typescript_ternary_qmark_alias_stays_unreachable`
    // — the tsx grammar declares the same `_ternary_qmark` external and
    // maps it back onto `anon_sym_QMARK` at its own id. Same
    // single-`?` fixture rule; see that test for why.
    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_ternary_qmark_alias_stays_unreachable() {
        let parser = TsxParser::new(
            "function f(a: boolean): number { return a ? 1 : 2; }\n"
                .as_bytes()
                .to_vec(),
            std::path::Path::new("foo.tsx"),
            None,
        );
        assert!(ast_has_kind_id(&parser, Tsx::QMARK as u16));
        assert!(!ast_has_kind_id(&parser, Tsx::QMARK2 as u16));
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_abstract_class_abc() {
        check_metrics::<TsxParser>(
            "abstract class C {
                abstract a(): void;
                m(x: number): number {
                    if (x > 0) return 1;
                    return 0;
                }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_interface_abc_zero() {
        check_metrics::<TsxParser>(
            "interface I { a(): void; p: string; }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_arrow_field_contributes_abc() {
        check_metrics::<TsxParser>(
            "class C {
                arrow = (x: number) => {
                    if (x > 0) return foo();
                    return 0;
                };
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_asi_const_does_not_suppress_later_assignments() {
        // TSX half of the #1277 cluster; see
        // `typescript_asi_const_does_not_suppress_later_assignments`.
        // TSX has its own `Const` / `VariableDeclarator` /
        // `LexicalDeclaration` kind ids, so the predicate is generated
        // separately and needs its own fixture.
        check_metrics::<TsxParser>(
            "function f() {
                const a = 1
                x = 2
                y = 3
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_const_declarator_shapes_stay_suppressed() {
        // TSX half of `typescript_const_declarator_shapes_stay_suppressed`.
        check_metrics::<TsxParser>(
            "function f(o: any, xs: number[]) {
                const a = 1, b = 2
                const {c = 5, d: {e = 6} = {}} = o
                const [g = 7, ...[h = 8]] = xs
                let i = 3
                var j = 4
                for (const x of xs) { k(x) }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_parameter_property_init_not_assignment() {
        // Parameter properties contribute no `=`; the body's `let z = 0`
        // and the field initializer do.
        check_metrics::<TsxParser>(
            "class C {
                f: number = 0;
                constructor(public x: number) { let z = 0; }
            }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // --- Ruby ABC tests ---------------------------------------------------
    //
    // Each Ruby `assignment` / `operator_assignment` is one assignment
    // regardless of whether the LHS is a local, instance, or class
    // variable. Every `call` / `super` / `yield` is one branch. Every
    // comparison-operator token inside a `binary` node plus each
    // `else` / `elsif` / `when` / `then` / `?` / `rescue` clause is
    // one condition.

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_zero_abc() {
        check_metrics::<RubyParser>("\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_simple_assignment() {
        check_metrics::<RubyParser>("def f\n  a = 1\n  b = 2\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 2);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_augmented_assignment() {
        // `+=`, `-=`, `*=` are `operator_assignment` nodes — each is
        // one assignment. Plain `=` to set the initial value adds one
        // more.
        check_metrics::<RubyParser>(
            "def f(x)\n  a = 0\n  a += x\n  a -= 1\n  a *= 2\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_logical_augmented_assignment() {
        // `||=` and `&&=` are also `operator_assignment` nodes.
        check_metrics::<RubyParser>("def f\n  @x ||= 0\n  @x &&= 1\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 2);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_method_call_branch() {
        // Each method invocation is one branch.
        check_metrics::<RubyParser>(
            "def f(obj)\n  foo()\n  obj.bar(1)\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_super_and_yield_branches() {
        // `super` and `yield` both count as branches (control-pass).
        check_metrics::<RubyParser>("def f\n  super\n  yield\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.branches_sum(), 2);
            assert_eq!(metric.abc.assignments_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_attr_macro_is_branch() {
        // `attr_accessor` is a `Call3` node and registers as a branch
        // like any method invocation.
        check_metrics::<RubyParser>("class A\n  attr_accessor :x\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.branches_sum(), 1);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_comparison_conditions() {
        // Each comparison operator is one condition.
        check_metrics::<RubyParser>(
            "def f(a, b)\n  a == b\n  a != b\n  a < b\n  a > b\n  a <= b\n  a >= b\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 6);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_superclass_clause_is_not_a_condition() {
        // Regression for #1280: a superclass clause spells its `<` with the
        // same `LT` token as a comparison, but parents it under
        // `superclass` rather than `binary`, so the parent gate excludes
        // it. Before the gate every subclass declaration scored a phantom
        // condition.
        // expected: 0 conditions — the file contains no conditional at all;
        // the single assignment is `x = 1`.
        check_metrics::<RubyParser>(
            "class Foo < Bar\n  def plain\n    x = 1\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                assert_eq!(metric.abc.assignments_sum(), 1);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_operator_method_name_is_not_a_condition() {
        // The `<` naming an operator method parents under `operator`, which
        // the `binary` gate likewise excludes (#1280). The body carries a
        // real comparison so the expected value is not the all-zero default:
        // 1 discriminates "only the name token is excluded" from both "the
        // gate excludes everything" (0) and "nothing is gated" (2).
        // expected: 1 condition — the `@v < other` comparison, not the `def <`.
        check_metrics::<RubyParser>("def <(other)\n  @v < other\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 1);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_every_comparison_operator_method_name_is_not_a_condition() {
        // The sibling half of #1280. `<` is not special: every comparison
        // and equality token Ruby lets you `def` parents under `operator`
        // in that position, so gating only `LT` / `GT` left `def ==`,
        // `def <=`, `def >=`, `def <=>`, `def !=` and `def =~` each
        // scoring a phantom condition — measured at 1 apiece for a body
        // containing no conditional at all.
        // expected: 0 conditions per definition; only the name token is on
        // the line, so a single non-zero total localises the regression.
        check_metrics::<RubyParser>(
            "def ==(o)\n  1\nend\n\
             def !=(o)\n  1\nend\n\
             def <=(o)\n  1\nend\n\
             def >=(o)\n  1\nend\n\
             def <=>(o)\n  1\nend\n\
             def =~(o)\n  1\nend\n\
             def <(o)\n  1\nend\n\
             def >(o)\n  1\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
            },
        );
        // The positive control: the same tokens inside a `binary` are real
        // comparisons and still count, so the gate is not blanket
        // suppression.
        check_metrics::<RubyParser>(
            "def cmp(a, b)\n  a == b || a <= b || a <=> b\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_case_match_in_arms_are_conditions() {
        // Regression for #977: each non-wildcard `case … in` arm is one
        // ABC condition, matching Python's `case_clause` handling. Using
        // literal patterns (no comparison operators) isolates the
        // `in_clause` contribution from any operand tokens.
        // expected: 2 conditions — one per `in 1` / `in 2` arm.
        check_metrics::<RubyParser>(
            "def f(x)\n  case x\n  in 1 then :one\n  in 2 then :two\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_case_match_guarded_wildcard_is_a_condition() {
        // Regression for #977: a guarded wildcard arm `in _ if x` is not a
        // bare default and counts as one ABC condition, while the trailing
        // bare `in _` adds none.
        // expected: 2 conditions — the guarded `in _ if x` arm, plus its
        // guard slot. The guard predicate is a bare identifier, so before
        // #1454 it contributed nothing and the total was 1; the slot is
        // what makes `if x`, `if x.even?` and `if x > 0` agree.
        check_metrics::<RubyParser>(
            "def f(x)\n  case x\n  in _ if x then :y\n  in _ then :default\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_case_match_bare_wildcard_is_not_a_condition() {
        // Regression for #977: a `case … in` whose only arm is the bare
        // wildcard `in _` (no guard) is the default arm and contributes no
        // ABC condition, keeping ABC and cyclomatic in lockstep on the
        // same construct.
        // expected: 0 conditions.
        check_metrics::<RubyParser>(
            "def f(x)\n  case x\n  in _ then :default\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_bare_predicate_control_flow_counts_one_condition() {
        // Regression for #696: idiomatic Ruby bare predicates
        // (`if flag` / `while flag` / `unless flag` / `until flag`) each
        // count one unary condition, matching Rust / C# / PHP / Python. The
        // condition field is read for both block and modifier forms.
        //
        // expected: 8 conditions — four block forms (`if`/`unless`/`while`/
        // `until`) plus the same four as modifiers, one each.
        check_metrics::<RubyParser>(
            "def f(flag)\n  if flag\n    a\n  end\n  unless flag\n    b\n  end\n  while flag\n    c\n  end\n  until flag\n    d\n  end\n  a if flag\n  b unless flag\n  c while flag\n  d until flag\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 8);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_bare_predicate_does_not_double_count_comparison_or_chain() {
        // `if a == b` counts only the `==` comparison (the condition field
        // is a `binary` node, adding nothing). `if a && b` counts the two
        // chain operands via the `&&` walker, again with the condition-field
        // arm adding nothing — so neither shape is double-counted (#696).
        //
        // expected: 3 — `==` (1) + the `a`,`b` operands of `&&` (2).
        check_metrics::<RubyParser>(
            "def f(a, b)\n  if a == b\n    x\n  end\n  if a && b\n    y\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_spaceship_and_case_equality() {
        // `<=>` and `===` are comparison operators (conditions).
        check_metrics::<RubyParser>(
            "def f(a, b)\n  a <=> b\n  a === b\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_ternary_condition() {
        // The `?` ternary marker is one condition; the inner `==` is
        // another.
        check_metrics::<RubyParser>("def f(x)\n  x == 0 ? :z : :nz\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    // Issue #1161. Ruby's ternary carried only the `?` token arm, so
    // `a ? !b : !c` scored 1 against the 4 that Java, C#, Groovy, the C
    // family, the JS family, PHP and Perl all report for the same
    // expression (#1102).
    //
    // Every expectation below is the value its C++ sibling
    // (`cpp_ternary_operand_slots_count_as_unary_conditions`) already
    // asserts for the same expression, so the two read as one table.
    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_ternary_operand_slots_count_as_unary_conditions() {
        // `?` (1) + condition `a` (1) + `!b` (1) + `!c` (1) = 4.
        check_metrics::<RubyParser>("def f\n  x = a ? !b : !c\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 4);
        });
        // No-double-count pin, and the assertion that catches the trap
        // this grammar sets: `-b` and `!b` are the SAME node kind
        // (`unary:284`), separated only by their operator. Scoring a
        // branch only when the peel proves it boolean — a `!` / `not`
        // layer, not the `unary` kind — is what keeps this at 2. An
        // implementation keying on `Unary` reads 3 here.
        // `?` (1) + `>` (1) = 2, unchanged by the fix: the parenthesised
        // condition unwraps to a comparison its own token already
        // counts, and neither branch is negated.
        check_metrics::<RubyParser>("def f\n  x = (a > 0) ? b : -b\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
        });
        // Nested — Ruby needs the inner ternary parenthesised. Outer `?`
        // (1) + outer condition `a` (1) + inner `?` (1) + inner
        // condition `b` (1) = 4. The outer consequence unwraps to the
        // inner `conditional`, which proves nothing boolean and is no
        // further paren / `!` layer, so it adds nothing on its own; the
        // inner ternary is reached by the walk, not by descent.
        check_metrics::<RubyParser>(
            "def f\n  x = a ? (b ? c : d) : e\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
            },
        );
        // A parenthesised condition, pinning the paren unwrap on the
        // condition slot: `(a)` is `parenthesized_statements`, which the
        // peel must look through.
        // `?` (1) + `(a)` (1) + `!b` (1) + `!c` (1) = 4.
        check_metrics::<RubyParser>("def f\n  x = (a) ? !b : !c\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 4);
        });
        // A negated condition takes the same fallback through the `!`
        // unwrap rather than the paren one. `?` (1) + `!a` (1) = 2.
        check_metrics::<RubyParser>("def f\n  x = !a ? b : c\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
        });
    }

    // The boolean-context seed must discriminate between the condition
    // slot and the two branch slots — not merely exist. None of the
    // fixtures above can tell the difference: their branches are either
    // `!`-unaries (which set the flag inside the unwrap loop regardless
    // of the seed) or kinds the loop breaks on before any terminal test.
    // A seed that returned `true` for every slot of a `Conditional`
    // leaves all five at their asserted values and fails nothing.
    //
    // A parenthesised *branch* is the input that separates them: the
    // unwrap reaches a bare terminal, so only the seed decides whether
    // it counts. `?` (1) + condition `a` (1) = 2 in both directions.
    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_ternary_branch_operands_are_not_double_counted() {
        check_metrics::<RubyParser>("def f\n  x = a ? (b) : c\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
        });
        check_metrics::<RubyParser>("def f\n  x = a ? b : (c)\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
        });
        // The same pair with a comment before the operand. Comments are
        // tree-sitter `extras`, so they become the branch's previous
        // sibling — which is why the seed asks the grammar which child
        // is the `condition` field rather than testing that sibling for
        // `?` / `:` as the C family does. Under the token form both of
        // these read 3.
        check_metrics::<RubyParser>(
            "def f\n  x = a ?\n    # note\n    (b) : c\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
        check_metrics::<RubyParser>(
            "def f\n  x = a ? b :\n    # note\n    (c)\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_case_when_arms() {
        // Each `when` named clause and the `else` clause count as one
        // condition each; the `case` head and the implicit `then`
        // wrappers do not.
        check_metrics::<RubyParser>(
            "def f(x)\n  case x\n  when 1 then 'one'\n  when 2 then 'two'\n  else 'other'\n  end\nend\n",
            "foo.rb",
            |metric| {
                // 2 `when` + 1 `else` = 3 conditions.
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_elsif_and_else() {
        // `elsif` and `else` named clauses are conditions; their inner
        // `then` wrappers are not.
        check_metrics::<RubyParser>(
            "def f(x)\n  if x > 0\n    1\n  elsif x < 0\n    -1\n  else\n    0\n  end\nend\n",
            "foo.rb",
            |metric| {
                // `>`(1) + `elsif`(1) + `<`(1) + `else`(1) = 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_rescue_clause_condition() {
        // The `rescue` named clause is one condition; the `rescue`
        // keyword token (`Rescue2`) is not counted on its own.
        // `do_it` without parens is an `identifier`, not a `call`, so
        // it contributes no branch. `handle(e)` is a `call` (1 branch).
        check_metrics::<RubyParser>(
            "def f\n  begin\n    do_it\n  rescue StandardError => e\n    handle(e)\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_class_complex_function() {
        // Mixed: assignment(=), branch(call), conditions(`>` and `==`).
        check_metrics::<RubyParser>(
            "class A\n  def f(a, b)\n    sum = a + b\n    if sum > 0 && b == 0\n      foo(sum)\n    end\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 1);
                // `>`(1) + `==`(1) = 2 conditions. `if` is not a
                // token; `&&` is `AMPAMP` and is not counted (see
                // the module-level `Stats` doc-comment for the
                // cross-language policy; #395, walker tracked in
                // #403).
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_unary_conditions_in_chain() {
        // Fitzpatrick Rule 9 (issue #557): each bare boolean operand of a
        // `&&` / `||` chain is one condition. `a && b || c` → a, b, c each
        // contribute one. Ruby's `if` keyword is not a condition token.
        // expected: 3 unary conditions (matches the Java byte-equivalent).
        check_metrics::<RubyParser>(
            "def f(a, b, c)\n  if a && b || c\n    puts \"x\"\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_keyword_and_or_chain_counts_operands() {
        // The keyword forms `and` / `or` get the same Rule 9 treatment as
        // `&&` / `||`. expected: 3 unary conditions (a, b, c).
        check_metrics::<RubyParser>(
            "def f(a, b, c)\n  if a and b or c\n    puts \"x\"\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_negated_operand_is_unary_condition() {
        // A `!`-negated operand unwraps the `unary` node to the inner
        // identifier. expected: 2 (`a` and the `!b` operand).
        check_metrics::<RubyParser>(
            "def f(a, b)\n  if a && !b\n    puts \"x\"\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_comparison_operands_add_nothing() {
        // Isolation for Rule 9 (issue #557): when the `&&` operands are
        // themselves comparisons, the unary-condition walker must add
        // nothing on top of the two `>` comparisons already counted as
        // conditions — distinguishing the gap (bare boolean operands)
        // from ordinary relational conditions. Mirrors the Kotlin and
        // Elixir isolation tests. expected: 2 (the two `>` comparisons).
        check_metrics::<RubyParser>(
            "def f(x, y)\n  if x > 0 && y > 0\n    puts \"x\"\n  end\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // The two anchors every #1453 fixture needs, coupled on purpose as
    // `assert_kotlin_class_members` couples them for #1421. `subjects` is
    // the load-bearing one: the whole distinction is whether a `case`
    // carries a `value` field, no node kind spells that, and a fixture
    // that grew a subject would score its clauses the pre-#1453 way with
    // every other row still satisfied. Each fixture is top-level `def`s,
    // so the members are the unit space's.
    #[cfg(feature = "ruby")]
    fn assert_ruby_case_members(
        src: &str,
        subjects: usize,
        kinds: &[(u16, usize, &str)],
        expected: &[(&str, u64, u64)],
    ) {
        let parser = RubyParser::new(
            src.as_bytes().to_vec(),
            std::path::Path::new("foo.rb"),
            None,
        );
        let found = parser
            .root()
            .preorder()
            .filter(|n| n.kind_id() == Ruby::Case && n.child_by_field_name("value").is_some())
            .count();
        assert_eq!(found, subjects, "`case` subjects — the fixture moved");
        assert_fixture_spells::<RubyParser>(src, "foo.rb", kinds);
        check_func_space::<RubyParser, _>(src, "foo.rb", |space| {
            assert_members_score(&space, expected);
        });
    }

    // #1453's headline. A subject-less `when` clause's condition is an
    // ordinary boolean expression, so a comparison in it is already an
    // ABC condition through the token arm; the clause added a blanket one
    // on top, and `gt` scored 3 against its `if` analogue `iff`'s 2.
    //
    // `bare` and `call` are the controls that isolate the defect: same
    // clause shape, no operator for any other arm to count, so the clause
    // must still pay for its decision — 2 and 1 before the fix and after.
    // A fix that moved them would be attacking the clause count, which
    // was never wrong.
    //
    // `gt`, `bare` and `iff` sit one above cyclomatic's decision count
    // because ABC counts the `else` (Fitzpatrick Rule 5) and cyclomatic
    // does not; every other row is at `conditions == cyclomatic - 1`.
    // `cmt` puts a comment where the subject would go: an extra is not the
    // `value` field, so the `case` stays subject-less.
    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_subjectless_case_when_counts_its_condition_once() {
        let src = "def gt(x)
  case
  when x > 5 then 1
  else 0
  end
end
def iff(x)
  if x > 5 then 1 else 0 end
end
def two(x)
  case
  when x > 5 then 1
  when x < 0 then 2
  end
end
def ge(x)
  case
  when x >= 5 then 1
  end
end
def andd(a, b)
  case
  when a > 1 && b < 2 then 1
  end
end
def orr(a, b)
  case
  when a || b then 1
  end
end
def kw_or(a, b)
  case
  when a or b then 1
  end
end
def bare(b)
  case
  when b then 1
  else 0
  end
end
def call(x)
  case
  when x.even? then 1
  end
end
def cmt(x)
  case # no subject
  when x > 5 then 1
  end
end
";
        assert_ruby_case_members(
            src,
            0,
            &[
                (Ruby::When as u16, 10, "`when` clauses"),
                (Ruby::GT as u16, 5, "`>` comparisons"),
                (Ruby::AMPAMP as u16, 1, "`andd`'s `&&`"),
                (Ruby::PIPEPIPE as u16, 1, "`orr`'s `||`"),
                (Ruby::Or as u16, 1, "`kw_or`'s `or`"),
                (Ruby::Comment as u16, 1, "`cmt`'s comment"),
            ],
            &[
                // (member, abc.conditions, cyclomatic)
                // Was 3: the `>` and the clause, for one decision.
                ("gt", 2, 2),
                ("iff", 2, 2),
                // Was 4.
                ("two", 2, 3),
                // Was 2: `>=` reaches the same token arm.
                ("ge", 1, 2),
                // Was 3. The compound condition keeps both comparisons —
                // suppressing the operators instead would collapse it.
                ("andd", 2, 3),
                // The Rule 9 walker scores both operands of a bare chain,
                // in both spellings; the clause adds nothing on top.
                ("orr", 2, 3),
                ("kw_or", 2, 3),
                ("bare", 2, 2),
                ("call", 1, 2),
                // Was 2.
                ("cmt", 1, 2),
            ],
        );
    }

    // Wrappers and the shapes no other arm owns. `not_cmp`, `paren_cmp`,
    // `tern` and `test_pat` peel to an expression another arm already
    // scored, and each read one above parity before the fix. `paren` and
    // `notted` peel to a bare operand nothing else counts, so the clause
    // pays exactly as an `if` predicate would.
    //
    // `scope`, `neg`, `splat` and `arith` are why the clause asks "is this
    // already paid for" rather than "is this a known terminal": the `if`
    // slot asked the second question and scored each of these 0 until
    // #1520 moved it onto the clause's question — see
    // `ruby_condition_slot_pays_what_no_other_arm_counted`.
    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_subjectless_case_when_condition_wrappers_count_once() {
        let src = "def paren(b)
  case
  when (b) then 1
  end
end
def notted(b)
  case
  when !b then 1
  end
end
def not_cmp(x)
  case
  when not(x > 1) then 1
  end
end
def paren_cmp(x)
  case
  when (x > 1) then 1
  end
end
def tern(x, a, b)
  case
  when x ? a : b then 1
  end
end
def test_pat(x)
  case
  when (x in Integer) then 1
  end
end
def scope
  case
  when Foo::Bar then 1
  end
end
def neg(x)
  case
  when -x then 1
  end
end
def splat(xs)
  case
  when *xs then 1
  end
end
def arith(x)
  case
  when x + 1 then 1
  end
end
";
        assert_ruby_case_members(
            src,
            0,
            &[
                (Ruby::When as u16, 10, "`when` clauses"),
                (
                    Ruby::ParenthesizedStatements as u16,
                    4,
                    "parenthesised operands",
                ),
                (Ruby::Conditional as u16, 1, "`tern`'s ternary"),
                (Ruby::TestPattern as u16, 1, "`test_pat`'s pattern test"),
                (Ruby::ScopeResolution2 as u16, 1, "`scope`'s `Foo::Bar`"),
                (Ruby::SplatArgument as u16, 1, "`splat`'s `*xs`"),
            ],
            &[
                ("paren", 1, 2),
                ("notted", 1, 2),
                // Each was 2.
                ("not_cmp", 1, 2),
                ("paren_cmp", 1, 2),
                ("test_pat", 1, 2),
                // Was 3. The ternary's own `?` and its condition `x` are
                // its two conditions, as in `if x ? a : b`.
                ("tern", 2, 3),
                ("scope", 1, 2),
                ("neg", 1, 2),
                ("splat", 1, 2),
                ("arith", 1, 2),
            ],
        );
    }

    // A clause may list several patterns: an implicit `||`, so each is
    // one operand of that chain and scores once unless its own arm already
    // counted it — every row here must equal its `if … || …` twin in the
    // `or_*` defs. `bare_first` and `cmp_first` differ only in pattern
    // order and must agree; reading the first pattern alone, as Kotlin's
    // `kotlin_count_when_entry` does, would score them 2 and 1. None can
    // reach `conditions == cyclomatic - 1`: cyclomatic scores the clause
    // as one decision, and the `||` twins sit just as far above it.
    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_subjectless_case_when_multiple_patterns() {
        let src = "def bare_alts(a, b)
  case
  when a, b then 1
  end
end
def alts(x)
  case
  when x > 1, x < -1 then 1
  end
end
def bare_first(a, x)
  case
  when a, x > 1 then 1
  end
end
def cmp_first(a, x)
  case
  when x > 1, a then 1
  end
end
def or_bare(a, b)
  if a || b then 1 end
end
def or_cmp(x)
  if x > 1 || x < -1 then 1 end
end
def or_mixed(a, x)
  if a || x > 1 then 1 end
end
";
        assert_ruby_case_members(
            src,
            0,
            &[
                (Ruby::When as u16, 4, "`when` clauses"),
                (Ruby::Pattern as u16, 8, "two patterns per clause"),
            ],
            &[
                // Was 1: one pattern went unscored.
                ("bare_alts", 2, 2),
                ("or_bare", 2, 3),
                // Was 3.
                ("alts", 2, 2),
                ("or_cmp", 2, 3),
                ("bare_first", 2, 2),
                ("cmp_first", 2, 2),
                ("or_mixed", 2, 3),
            ],
        );
    }

    // An `elsif` is Java's `else if`: one condition for the `else`
    // (Rule 5) plus an `if` predicate slot. It paid only the `else`, so
    // `eb`, `eself`, `eneg` and `eparen` scored 2 where
    // `if (a) {} else if (b) {}` scores 3, while `ecmp` matched only
    // because its `>` arm paid the predicate. Each row now equals its Java
    // twin (`eelse` 4 / 3: Rule 5 counts the `else` arm, cyclomatic
    // does not), and `ecmp` / `eand` must not move, or the slot is paying
    // on top of the operator arms (#1520).
    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_elsif_predicate_is_a_condition_slot() {
        let src = "def eb(a, b)
  if a then 1 elsif b then 2 end
end
def ecmp(a, x)
  if a then 1 elsif x > 0 then 2 end
end
def eself(a)
  if a then 1 elsif self then 2 end
end
def eneg(a, b)
  if a then 1 elsif !b then 2 end
end
def eparen(a, b)
  if a then 1 elsif (b) then 2 end
end
def eand(a, b, c)
  if a then 1 elsif b && c then 2 end
end
def eelse(a, b)
  if a then 1 elsif b then 2 else 3 end
end
";
        assert_fixture_spells::<RubyParser>(
            src,
            "foo.rb",
            &[
                (Ruby::Elsif as u16, 7, "one `elsif` per member"),
                (Ruby::Else as u16, 1, "`eelse`'s `else`"),
            ],
        );
        check_func_space::<RubyParser, _>(src, "foo.rb", |space| {
            assert_members_score(
                &space,
                &[
                    // (member, abc.conditions, cyclomatic)
                    // Was 2.
                    ("eb", 3, 3),
                    ("ecmp", 3, 3),
                    // Was 2.
                    ("eself", 3, 3),
                    // Was 2.
                    ("eneg", 3, 3),
                    // Was 2.
                    ("eparen", 3, 3),
                    ("eand", 4, 4),
                    // Was 3.
                    ("eelse", 4, 3),
                ],
            );
        });
    }

    // #1520: every Ruby condition slot — block and modifier `if` /
    // `unless` / `while` / `until`, a `case … in` guard, a ternary
    // condition — pays one condition unless another arm already charged
    // the same decision. The slot used to pay only for a predicate that
    // peeled down to a known boolean terminal, so the first block below
    // scored 0 for one decision each, while the same expression as a
    // subject-less `when` scored 1 (`ruby_subjectless_case_when_condition_
    // wrappers_count_once`). Every row sits at `conditions == cyclomatic
    // - 1` except `tern` and `ifelse`, which agree with each other one
    // above it: ABC counts the `?` / `else` arm and cyclomatic does not.
    // `chain` and `chain_neg` sit level with each other, as a Rule 9
    // chain scores one per operand.
    //
    // The second block must not move, or the slot is paying twice: each
    // predicate's comparison or chain operand is already counted by its
    // own arm. `begin_cmp` and `assign_cmp` are why the peel looks through
    // `begin … end` and an assignment's value — without that the slot
    // would see a non-terminal and pay on top of the `>`. `chain_neg`'s
    // operands are slots of their own: the Rule 9 walker pays for `-a`
    // and `-b` as it does for `a` and `b`, and the `if` adds nothing
    // (#1529; before it, the walker skipped both and the `if` paid one).
    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_condition_slot_pays_what_no_other_arm_counted() {
        let src = "def scope
  if Foo::Bar then 1 end
end
def zelf
  if self then 1 end
end
def neg(x)
  if -x then 1 end
end
def defd(x)
  if defined?(x) then 1 end
end
def assign(x)
  if (y = x) then y end
end
def arith(x)
  if x + 1 then 1 end
end
def blk(b)
  g if begin b end
end
def unl
  g unless Foo::Bar
end
def til(x)
  g until -x
end
def whl
  while self do g end
end
def guard(x)
  case x
  in [y] if -y then 1
  end
end
def tern(x)
  -x ? 1 : 2
end
def ifelse(x)
  if -x then 1 else 2 end
end
def cmp(x)
  if x > 1 then 1 end
end
def begin_cmp(x)
  if begin x > 1 end then 1 end
end
def assign_cmp(x)
  if (y = x > 1) then y end
end
def notted(x)
  if !x then 1 end
end
def chain(a, b)
  if a && b then 1 end
end
def chain_neg(a, b)
  if -a && -b then 1 end
end
";
        assert_fixture_spells::<RubyParser>(
            src,
            "foo.rb",
            &[
                (Ruby::ScopeResolution2 as u16, 2, "`Foo::Bar`"),
                (Ruby::Zelf as u16, 2, "`self`"),
                (Ruby::Begin as u16, 2, "`begin … end`"),
                (Ruby::Assignment as u16, 2, "parenthesised assignments"),
                (Ruby::Conditional as u16, 1, "`tern`'s ternary"),
                (Ruby::IfGuard as u16, 1, "`guard`'s guard"),
            ],
        );
        check_func_space::<RubyParser, _>(src, "foo.rb", |space| {
            assert_members_score(
                &space,
                &[
                    // (member, abc.conditions, cyclomatic); each of the
                    // first thirteen was one lower.
                    ("scope", 1, 2),
                    ("zelf", 1, 2),
                    ("neg", 1, 2),
                    ("defd", 1, 2),
                    ("assign", 1, 2),
                    ("arith", 1, 2),
                    ("blk", 1, 2),
                    ("unl", 1, 2),
                    ("til", 1, 2),
                    ("whl", 1, 2),
                    ("guard", 2, 3),
                    ("tern", 2, 2),
                    ("ifelse", 2, 2),
                    ("cmp", 1, 2),
                    ("begin_cmp", 1, 2),
                    ("assign_cmp", 1, 2),
                    ("notted", 1, 2),
                    ("chain", 2, 3),
                    // Was 0, then 1 until #1529.
                    ("chain_neg", 2, 3),
                ],
            );
        });
    }

    // The other half of #1453: a subject-ful clause must not move. It
    // lists a pattern matched with `pattern === subject`, a comparison
    // written nowhere, so the clause itself pays for the decision.
    // `subj_cmp` is the subject-ful counterpart of `gt` above and keeps
    // the clause's count *and* its `>`: `y > 5` is a value compared
    // against `x`, two comparisons for one branch. `in_arms` (the
    // `InClause` arm), `unl` and `elsif_` share no code with `When` and
    // are here to pin that the fix left them alone.
    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_subjectful_case_when_keeps_the_per_clause_count() {
        let src = "def konst(x)
  case x
  when 1 then 1
  when 2 then 2
  else 0
  end
end
def subj_alts(x)
  case x
  when 1, 2 then 1
  else 0
  end
end
def subj_cmp(x, y)
  case x
  when y > 5 then 1
  end
end
def in_arms(x)
  case x
  in Integer then 1
  in String then 2
  else 0
  end
end
def unl(x)
  unless x > 5 then 1 else 0 end
end
def elsif_(x)
  if x > 5 then 1 elsif x < 0 then 2 else 0 end
end
";
        // Three: `in_arms` is a `case_match`, a separate production.
        assert_ruby_case_members(
            src,
            3,
            &[
                (Ruby::CaseMatch as u16, 1, "`in_arms`'s `case`"),
                (Ruby::When as u16, 4, "`when` clauses"),
                (Ruby::InClause as u16, 2, "`in_arms`'s clauses"),
                (Ruby::GT as u16, 3, "`>` comparisons"),
            ],
            &[
                ("konst", 3, 3),
                ("subj_alts", 2, 2),
                ("subj_cmp", 2, 2),
                ("in_arms", 3, 3),
                ("unl", 2, 2),
                ("elsif_", 4, 3),
            ],
        );
    }

    // ---------------------------------------------------------------
    // Default-impl placeholder smoke tests (audited in #188).
    //
    // These tests assert that the *current* default-impl languages
    // return ABC = 0/0/0 for source that DOES contain branches,
    // conditions, and assignments. When the real impl lands for any
    // of these languages, the corresponding assertion below will fire
    // — the implementer must update the expected values, which is the
    // gate. Tag the follow-up issue in each test.
    // ---------------------------------------------------------------

    // --- Python ABC ---------------------------------------------------

    #[cfg(feature = "python")]
    #[test]
    fn python_empty_module_zero() {
        check_metrics::<PythonParser>("", "empty.py", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_plain_assignments_count() {
        // Three plain `=` assignments → A=3. No branches, no conditions.
        check_metrics::<PythonParser>("x = 1\ny = 2\nz = x\n", "foo.py", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 3);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_typed_assignment_counts_bare_annotation_does_not() {
        // `x: int = 1` carries an `=`, so it counts.
        // `y: int` is a bare annotation (no `=`) — declares a type but
        // binds nothing; it must NOT inflate the assignment count.
        check_metrics::<PythonParser>("x: int = 1\ny: int\n", "foo.py", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 1);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_augmented_assignments_count() {
        // Each augmented op counts once.
        check_metrics::<PythonParser>("x = 0\nx += 1\nx -= 1\nx *= 2\n", "foo.py", |metric| {
            // 1 plain `=` + 3 augmented = 4 assignments.
            assert_eq!(metric.abc.assignments_sum(), 4);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_walrus_counts_as_assignment() {
        // `x := 10` is a `NamedExpression` (PEP 572). It binds a value
        // → one assignment under Fitzpatrick's rule.
        check_metrics::<PythonParser>("if (n := 10) > 5:\n    pass\n", "foo.py", |metric| {
            // 1 assignment (walrus) + 1 condition (`> 5` is a
            // ComparisonOperator).
            assert_eq!(metric.abc.assignments_sum(), 1);
            assert_eq!(metric.abc.conditions_sum(), 1);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_calls_are_branches() {
        // `foo()`, `bar()`, `Baz()` (constructor) all parse as `Call`
        // → three branches.
        check_metrics::<PythonParser>(
            "def foo():\n    pass\ndef bar():\n    pass\nclass Baz:\n    pass\nfoo()\nbar()\nBaz()\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 3);
                assert_eq!(metric.abc.assignments_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_comparisons_count_conditions() {
        // `x > 0`, `x == y`, `x is None` are each a single
        // `ComparisonOperator` node — three conditions.
        check_metrics::<PythonParser>(
            "def f(x, y):\n    a = x > 0\n    b = x == y\n    c = x is None\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                // 3 plain assignments; the comparisons are operands.
                assert_eq!(metric.abc.assignments_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_chained_comparison_counts_once() {
        // tree-sitter-python collapses `0 < x < 10` into a single
        // `ComparisonOperator` — one condition, not two.
        check_metrics::<PythonParser>("def f(x):\n    return 0 < x < 10\n", "foo.py", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 1);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_number_truthy_condition_counts() {
        // Regression for #772: Python treats every non-zero number as
        // truthy, so `if 5:` and `x and 5` should each count their
        // numeric literal as a Fitzpatrick unary condition. Pre-fix
        // the former `python_bool_terminal_kinds!()` listed `True` /
        // `False` but omitted `Integer` / `Float`, so the walker dropped every
        // numeric-truthy operand (mirrors the Lua `Number` fix).
        check_metrics::<PythonParser>(
            "def f(a):\n    if 5:\n        pass\n    return a and 2\n",
            "foo.py",
            |metric| {
                // `if 5:` → walker counts the Integer literal (+1).
                // `a and 2` → `and` walker counts both operands:
                //   identifier `a` (+1), Integer `2` (+1).
                // Total: 3.
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_boolean_operators_not_counted_directly() {
        // Python's `and` / `or` are not counted as conditions on
        // their own (Fitzpatrick Rule 5; #395). Each operand is
        // instead counted as a unary conditional by the walker
        // (Rule 9; #403). `if a and b or c:` parses left-to-right
        // with `or` lower precedence: `(a and b) or c`. Walker
        // tallies: inner `and` counts `a`, `b` (+2); outer `or`
        // counts only the new outer operand `c` (+1; the inner
        // `(a and b)` BooleanOperator is not a terminal). Total
        // C = 3.
        check_metrics::<PythonParser>(
            "def f(a, b, c):\n    if a and b or c:\n        pass\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    /// Python's unary `not` operator parses as `NotOperator` and now
    /// counts as one condition, matching Java's `!x` rule. Closes
    /// the parity gap noted in #214: without this, `if not flag:`
    /// reported 0 conditions while the Java equivalent reports 1.
    #[cfg(feature = "python")]
    #[test]
    fn python_unary_not_counts_as_condition() {
        check_metrics::<PythonParser>(
            "def f(flag):\n    if not flag:\n        return 1\n    return 0\n",
            "foo.py",
            |metric| {
                // One `NotOperator` -> 1 condition. The `if` itself
                // is structural and doesn't add an Abc condition.
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    /// `return not flag` — the unary `not` is the entire return
    /// expression. Without `NotOperator` counted, this reports zero
    /// conditions; with it, one. Java's `return !flag;` is one.
    #[cfg(feature = "python")]
    #[test]
    fn python_return_unary_not_counts() {
        check_metrics::<PythonParser>("def f(flag):\n    return not flag\n", "foo.py", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 1);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    /// `foo(not ready, value)` — the unary `not` inside an argument
    /// list still contributes. Mirrors Java's `java_count_negated`
    /// walk over argument lists.
    #[cfg(feature = "python")]
    #[test]
    fn python_unary_not_in_argument_list_counts() {
        check_metrics::<PythonParser>(
            "def f(ready, value):\n    log(not ready, value)\n",
            "foo.py",
            |metric| {
                // 1 Call (log) -> 1 branch.
                // 1 NotOperator (not ready) -> 1 condition.
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    /// A negated comparison is one condition. `not (x > 0)` parses as
    /// `NotOperator(ParenthesizedExpression(ComparisonOperator))`; the
    /// comparison's arm pays and the `not` adds nothing, as Java's
    /// `!(x > 0)` scores 1 (#1526). This test asserted 2 on the false
    /// premise that Java scores 2.
    #[cfg(feature = "python")]
    #[test]
    fn python_unary_not_with_comparison_counts_each_once() {
        check_metrics::<PythonParser>(
            "def f(x):\n    if not (x > 0):\n        return 1\n    return 0\n",
            "foo.py",
            |metric| {
                // ComparisonOperator (1); the `not` negates a counted
                // comparison and adds nothing.
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    /// `not x and y` parses as `BooleanOperator(NotOperator(x), and,
    /// y)`. The `and` itself is NOT counted (Fitzpatrick Rule 5
    /// lists only comparison operators); the `NotOperator` is
    /// counted at the top level (Rule 7); and the `y` operand is
    /// counted by the Rule 9 walker (issue #403). Total: 2.
    /// `NotOperator` is intentionally not walked-into a second
    /// time — the walker skips it to avoid double-counting.
    #[cfg(feature = "python")]
    #[test]
    fn python_unary_not_with_boolean_combinator_counts_each() {
        check_metrics::<PythonParser>(
            "def f(x, y):\n    if not x and y:\n        return 1\n    return 0\n",
            "foo.py",
            |metric| {
                // NotOperator (1) + walker on `and` finds `y` (1) = 2.
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_control_flow_arms_count_conditions() {
        // `elif`, `else`, `except`, `finally`, `case` each contribute
        // one condition. The comparisons in the `if`/`elif`/`while`
        // headers contribute their own ComparisonOperator counts.
        check_metrics::<PythonParser>(
            "def f(x):\n    if x > 0:\n        a = 1\n    elif x > -1:\n        a = 2\n    else:\n        a = 3\n",
            "foo.py",
            |metric| {
                // 2 ComparisonOperator (`x > 0`, `x > -1`) + 1
                // ElifClause + 1 ElseClause = 4 conditions.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_ternary_counts_as_condition() {
        // `a if c else b` is `ConditionalExpression` → 1 condition.
        // `c > 0` adds 1 more (ComparisonOperator).
        check_metrics::<PythonParser>(
            "def f(c):\n    return 1 if c > 0 else 0\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Issue #1161. Python counted the `conditional_expression` node but
    // never its condition slot, so `a if c() else b` reported 1 where
    // the equivalent `c() ? a : b` reports 2 everywhere else — and
    // the former `python_inspect_container`'s `ConditionalExpression`
    // boolean-context seed was unreachable, no call site having passed
    // that parent.
    #[cfg(feature = "python")]
    #[test]
    fn python_ternary_condition_slot_counts_as_a_unary_condition() {
        // ternary (1) + condition `c()` (1) = 2. `c()` is a `Call`, a
        // boolean terminal; it also adds one *branch*, not a condition.
        check_metrics::<PythonParser>(
            "def f(a, b, c):\n    return a if c() else b\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
        // A parenthesised condition: `(c)` is a `parenthesized_expression`,
        // so only the peel (`python_wrapper_operand`) can resolve it to
        // `c`, which the slot then pays for.
        // ternary (1) + `(c)` (1) = 2.
        check_metrics::<PythonParser>(
            "def f(a, b, c):\n    return a if (c) else b\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
        // A negated condition is *not* counted by the new slot: it is a
        // `NotOperator`, which already has its own top-level dispatcher
        // arm. ternary (1) + `not c` (1) = 2, not 3.
        check_metrics::<PythonParser>(
            "def f(a, b, c):\n    return a if not c else b\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
        // The cross-language reference case. `(not b) if a else (not c)`
        // is the exact semantic equivalent of `a ? !b : !c`, which every
        // other language reports as 4: ternary (1) + condition `a` (1) +
        // two `NotOperator`s (2). The negated operands come from
        // Python's own arm, the condition from the slot added here.
        //
        // #1161's resolution plan predicted this would stay 3, having
        // measured the condition slot's contribution against the pre-fix
        // total. 3 would have left Python disagreeing with every other
        // language on the reference expression — the gap the issue was
        // filed about.
        check_metrics::<PythonParser>(
            "def f(a, b, c):\n    return (not b) if a else (not c)\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
            },
        );
    }

    // The double-count pin, and the reason Python gets a condition-slot
    // helper rather than a copy of `cpp_walk_ternary`: Python's branch
    // operands are counted by the top-level `NotOperator` /
    // `ComparisonOperator` arms, a different mechanism from every other
    // language's walker. Routing the branch slots through a negated-
    // operand walk as the C family does (`python_inspect_container`
    // before #1526) would have counted a parenthesised operand that
    // the identical unparenthesised expression scores at zero.
    //
    // Both fixtures below are 2 today and were 4 under such a copy, so a
    // later "make Python consistent with the others" change cannot land
    // silently.
    #[cfg(feature = "python")]
    #[test]
    fn python_ternary_branch_operands_are_not_double_counted() {
        // ternary (1) + condition `a` (1) = 2. The two parenthesised
        // operands add nothing — an unnegated branch is type-free.
        check_metrics::<PythonParser>(
            "def f(a, b, c):\n    return (b) if a else (c)\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
        // The unparenthesised form must agree: nothing about `(b)`
        // versus `b` is a condition.
        check_metrics::<PythonParser>(
            "def f(a, b, c):\n    return b if a else c\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    // Comments are tree-sitter `extras`, so they arrive as direct
    // children of `conditional_expression` and shift every positional
    // index after them. `python_count_ternary_condition` therefore
    // anchors on the `if` keyword and skips comments after it; both
    // halves are needed and each fixture below fails without one.
    #[cfg(feature = "python")]
    #[test]
    fn python_ternary_condition_survives_an_interposed_comment() {
        // Comment before the keyword: `child(2)` is the `if` token here,
        // so a positional lookup reads 1. ternary (1) + `f()` (1) = 2.
        check_metrics::<PythonParser>(
            "def f(b, c):\n    return (b\n            # why\n            if f() else c)\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
        // Comment after the keyword: the child immediately following
        // `if` is the comment, so taking the first rather than the first
        // non-comment reads 1. ternary (1) + `f()` (1) = 2.
        check_metrics::<PythonParser>(
            "def f(b, c):\n    return (b if\n            # why\n            f() else c)\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_try_except_finally_count_conditions() {
        // ExceptClause + FinallyClause → 2 conditions.
        check_metrics::<PythonParser>(
            "def f():\n    try:\n        pass\n    except ValueError:\n        pass\n    finally:\n        pass\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_match_case_counts_conditions() {
        // Each non-wildcard `CaseClause` → 1 condition. The bare
        // `case _:` arm is the language-neutral `default:` equivalent
        // and is excluded (matches Rust's bare-`_` MatchArm filter and
        // Java/C#'s `default:` rule). Source has `case 1:` (counts) +
        // `case _:` (excluded) → C = 1.
        check_metrics::<PythonParser>(
            "def f(x):\n    match x:\n        case 1:\n            pass\n        case _:\n            pass\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_match_case_guarded_wildcard_counts() {
        // `case _ if g:` is NOT a bare wildcard — the guard
        // contributes real branching, so the arm counts as a
        // condition. Mirrors Rust's `_ if g => ...` behavior.
        // Source: `case 1:` (counts) + `case _ if x > 0:` (guarded
        // wildcard, counts) + `case _:` (bare wildcard, excluded) →
        // C from CaseClause = 2; the guard's `x > 0` adds one
        // ComparisonOperator → total C = 3.
        check_metrics::<PythonParser>(
            "def f(x):\n    match x:\n        case 1:\n            pass\n        case _ if x > 0:\n            pass\n        case _:\n            pass\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_complex_function_abc() {
        // Mixed-shape regression: assignments, calls, conditions all in
        // a single function.
        check_metrics::<PythonParser>(
            "def f(items, threshold):\n\
             \x20   result = []\n\
             \x20   for item in items:\n\
             \x20       if item > threshold:\n\
             \x20           result.append(item)\n\
             \x20   return result\n",
            "foo.py",
            |metric| {
                // assignments: `result = []` → 1
                // branches: `result.append(item)` is one call → 1
                // conditions: `item > threshold` is one
                // ComparisonOperator → 1
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_if_multiple_conditions() {
        // Fitzpatrick Rule 9 walker on `and` / `or` (issue #403).
        //   - `if a or b or c or d:` → 4 (each operand counted once)
        //   - `if a and b and c:`    → 3
        //   - `if not a and not b:`  → 2 (two `NotOperator`s counted
        //     by the top-level dispatcher arm; the walker SKIPS
        //     `NotOperator` children to avoid double-counting)
        // Total: 4 + 3 + 2 = 9.
        check_metrics::<PythonParser>(
            "def f(a, b, c, d):\n\
             \x20   if a or b or c or d:           # +4c\n\
             \x20       pass\n\
             \x20   if a and b and c:              # +3c\n\
             \x20       pass\n\
             \x20   if not a and not b:            # +2c (NotOperator x2)\n\
             \x20       pass\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_while_conditions() {
        // Python has no `do { ... } while(cond);` construct, so this
        // mirrors only the `while` half of the Java suite. The
        // walker fires on each `and` / `or` token inside the loop
        // header.
        check_metrics::<PythonParser>(
            "def f(a, b):\n\
             \x20   while a or b:                  # +2c\n\
             \x20       break\n\
             \x20   while a and not b:             # +2c (a + NotOperator)\n\
             \x20       break\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_short_circuit_with_boolean_literal_operand() {
        // `a and True` reports 2 conditions: one identifier, one
        // True literal. Confirms `True` / `False` are in the walker
        // terminal set.
        check_metrics::<PythonParser>("def f(a):\n    return a and True\n", "foo.py", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_await_expression_condition_counts() {
        // Regression for findings.md round-2 #2 (Python):
        // `if await ready(): pass` parses with `await` as the
        // condition node. Adding `Python::Await` to the
        // terminal-bool set mirrors the C# reference (lesson 19).
        check_metrics::<PythonParser>(
            "async def ready(): return True\n\
             async def f():\n    if await ready(): pass\n",
            "foo.py",
            |metric| {
                // ready() is a call (1 branch); await is the
                // condition (1).
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_if_call_terminal_condition_counts_once() {
        // Pins the Phase-2B behaviour for Python's `Call` terminal-bool
        // kind: `if foo():` is a Fitzpatrick Rule 6 unary conditional
        // (a bare boolean-evaluating call as the if-condition). The
        // walker's terminal-at-top check fires once per call-condition;
        // the call itself separately contributes 1 branch. Surfaced
        // (and verified intentional) by the code-review pass on
        // Phase 2B.
        check_metrics::<PythonParser>("def f():\n    if foo(): pass\n", "foo.py", |metric| {
            assert_eq!(metric.abc.branches_sum(), 1);
            assert_eq!(metric.abc.conditions_sum(), 1);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_if_boolean_literal_condition() {
        // Phase 2B (issue #403): bare-boolean conditions count once.
        // Python has no paren wrap around if-conditions, so the
        // condition node is checked directly. The existing
        // NotOperator / ComparisonOperator arms continue to fire
        // for those shapes; only the bare-terminal cases (Identifier,
        // True, False, etc.) are added by the new arm.
        check_metrics::<PythonParser>(
            "def f(a):\n\
             \x20   if True: pass        # +1c\n\
             \x20   if False: pass       # +1c\n\
             \x20   while True: break    # +1c\n\
             \x20   if a: pass           # +1c (Rule 6 — bare identifier as condition)\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_methods_arguments_with_conditions() {
        // `m(not a, not b)` reports 2 conditions — both `NotOperator`
        // nodes are counted by Python's pre-existing top-level
        // NotOperator dispatcher arm. The argument-list walker does
        // not need a separate Python arm.
        check_metrics::<PythonParser>(
            "def f(a, b):\n\
             \x20   m(a, b)             # +1b\n\
             \x20   m(not a, not b)     # +1b +2c\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_return_with_conditions() {
        // Phase 2B (issue #403). Python uses the pre-existing top-
        // level NotOperator / ComparisonOperator arms for return
        // expressions; no dedicated ReturnStatement walker arm is
        // needed.
        check_metrics::<PythonParser>(
            "def m1(z): return not (z >= 0)\n\
             def m2(x): return (((not x)))\n\
             def m3(x, y): return x and y\n",
            "foo.py",
            |metric| {
                // m1: ComparisonOperator (1); the `not` adds nothing,
                //     as Java's `return !(z >= 0)` scores 1 (#1526).
                // m2: NotOperator (1).
                // m3: walker on `and` counts both operands = 2.
                // Sum: 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_empty_unit_zero() {
        // No code at all → A=B=C=0. Establishes the trait is wired up
        // and the per-language compute is reachable.
        check_metrics::<RustParser>("", "empty.rs", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_assignments_let_init_plain_and_compound() {
        // `let mut x = 0` is a `let_declaration` carrying an `=`
        // initializer → counts as 1 (matches Fitzpatrick's literal
        // "every `=` is an assignment" rule and the JS impl's
        // treatment of `let x = 5`). `x = 5` and `x = 7` are plain
        // `=` assignments → 2. `x += 2` is a compound assignment → 1.
        // Total A = 4.
        check_metrics::<RustParser>(
            "fn f() { let mut x = 0; x = 5; x += 2; x = 7; }",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 4);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_let_without_initializer_does_not_count() {
        // `let a;` is a `let_declaration` with NO `=` and no `value`
        // field — the binding is uninitialised. The arm only fires
        // when `value` is present, so this contributes zero to A.
        // `let _b;` is the same shape (the `_` pattern is still a
        // pattern, not a wildcard suppression of the binding).
        // Regression test for issue #393: only `=` counts, not the
        // bare declaration.
        check_metrics::<RustParser>(
            "fn f() { let a: i32; let _b: i32; a = 5; }",
            "foo.rs",
            |metric| {
                // Only `a = 5` (assignment_expression) → A = 1.
                assert_eq!(metric.abc.assignments_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_let_initializers_immutable_and_mutable_count() {
        // Issue #393: `let a = 1;`, `let b = 2;`, `let c = a + b;`,
        // `let mut d = 0;` are all `let_declaration` nodes carrying
        // an `=` initializer — each counts as 1 (Option B in the
        // issue body: literal Fitzpatrick, both `let` and `let mut`
        // count). `d = 5;` is one plain assignment_expression, `d
        // += 1;` is one compound. Total A = 4 + 1 + 1 = 6.
        check_metrics::<RustParser>(
            "fn f() { let a=1; let b=2; let c=a+b; let mut d=0; d=5; d+=1; }",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 6);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_calls_are_branches() {
        // Free function call + method call (parses as call_expression
        // with a field_expression callee) + associated-fn call. All
        // three are `call_expression` → B = 3. Macro invocations like
        // `println!` parse as `macro_invocation`, NOT `call_expression`,
        // so they are not branches.
        check_metrics::<RustParser>(
            "fn f() { g(); 1.to_string(); String::new(); }\nfn g() {}\n",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 3);
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_try_operator_is_branch() {
        // `?` parses as `try_expression` and counts as one branch
        // (short-circuit return on Err / None). The `Err(())` call
        // contributes one branch in addition (call_expression).
        check_metrics::<RustParser>(
            "fn f() -> Result<i32, ()> { let r: Result<i32, ()> = Err(()); Ok(r?) }",
            "foo.rs",
            |metric| {
                // Err(()) + Ok(...) + r? → 2 calls + 1 try = 3 branches.
                assert_eq!(metric.abc.branches_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_comparisons_count_conditions() {
        // `<`, `>`, `<=`, `>=`, `==`, `!=` each count once. Six
        // comparisons → C = 6.
        check_metrics::<RustParser>(
            "fn f(a: i32, b: i32) -> bool { a < b || a > b || a <= b || a >= b || a == b || a != b }",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 6);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_generic_brackets_not_conditions() {
        // `<` / `>` in `Vec<i32>` are TypeArguments delimiters, not
        // comparison operators. The parent-check in the LT/GT arms
        // must filter them out. Expected C = 0.
        check_metrics::<RustParser>(
            "fn f() -> Vec<i32> { Vec::<i32>::new() }",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_if_let_counts_as_condition() {
        // `if let Some(v) = opt { ... }` introduces a `let_condition`
        // → 1 condition. The `if` keyword itself does not add another
        // count — Fitzpatrick counts conditions, not branch keywords.
        check_metrics::<RustParser>(
            "fn f(opt: Option<i32>) { if let Some(_v) = opt { } }",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_while_let_counts_as_condition() {
        // `while let Some(y) = it.next() { ... }` is also a
        // `let_condition` (the `while` form). One condition; the
        // `it.next()` call adds one branch.
        check_metrics::<RustParser>(
            "fn f(mut it: std::vec::IntoIter<i32>) { while let Some(_y) = it.next() { } }",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_match_arms_count_conditions_wildcard_excluded() {
        // Three arms: `0 => 1`, `n if n > 0 => n`, `_ => -1`. The
        // bare wildcard is the `default:` equivalent and is skipped.
        // The guarded arm has a `n if n > 0` pattern (more than one
        // child in the match_pattern) and still counts. Two non-wildcard
        // arms → C = 2 from MatchArm. Plus the comparison `n > 0`
        // adds one more → C = 3.
        check_metrics::<RustParser>(
            "fn f(x: i32) -> i32 { match x { 0 => 1, n if n > 0 => n, _ => -1, } }",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_else_counts_as_condition() {
        // `if a > b { ... } else { ... }` → `a > b` is one condition,
        // `else` is one condition → C = 2.
        check_metrics::<RustParser>(
            "fn f(a: i32, b: i32) -> i32 { if a > b { a } else { b } }",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_let_chain2_hidden_rule_drift_marker() {
        // Drift marker (findings.md round-2 #3): `Rust::LetChain2`
        // maps to the hidden grammar rule `_let_chain`. At the
        // pinned tree-sitter-rust version it is never emitted as a
        // concrete node — the visible `LetChain` (= 352) carries
        // every let-chain. We list `LetChain2` defensively in
        // `rust_condition_scores_itself` and `rust_count_chain_operands`
        // (lesson 34); if a future grammar bump promotes
        // `_let_chain` to a visible rule, this assertion fails
        // loudly so the maintainer knows to verify the walker still
        // counts correctly for the new shape.
        let src = "fn f(a: bool, b: Option<i32>) {\n\
                   \x20   if a && let Some(_) = b { }\n\
                   }\n";
        let parser = RustParser::new(
            src.as_bytes().to_vec(),
            &std::path::PathBuf::from("foo.rs"),
            None,
        );
        assert!(!ast_has_kind_id(&parser, Rust::LetChain2 as u16));
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_scoped_identifier_condition_counts() {
        // Regression for findings.md round-2 #1 (Rust):
        // `if crate::FLAG {}` parses with `scoped_identifier` as the
        // condition node. Pre-fix, the former `rust_bool_terminal_kinds!()`
        // listed only `Identifier` so the walker reached the
        // `scoped_identifier` child, found it non-terminal /
        // non-paren / non-unary, and broke without counting.
        // Mirrors the C# fix in #372 (lesson 19) for
        // `MemberAccessExpression`.
        check_metrics::<RustParser>("fn f() { if crate::FLAG { } }\n", "foo.rs", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 1);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_await_expression_condition_counts() {
        // Regression for findings.md round-2 #2 (Rust):
        // `if ready().await {}` parses with `await_expression` as
        // the condition node. Adding `Rust::AwaitExpression` to the
        // former terminal-bool set closed the parity gap with the C#
        // reference (the former `csharp_bool_terminal_kinds!()`).
        check_metrics::<RustParser>(
            "async fn ready() -> bool { true }\n\
             async fn f() { if ready().await { } }\n",
            "foo.rs",
            |metric| {
                // ready() is a call (1 branch); `ready().await` is
                // the unary boolean condition (1).
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_complex_function_abc() {
        // Mixed-shape regression: assignments, calls, conditions, `?`,
        // `if let`, `match` in one body. Verified by hand:
        // - assignments: `let mut x = 0` (let init), `x = 5`, `x += 2`,
        //   `let _ = ...` (let init), `let r: ... = Err(())` (let init),
        //   `let _v = r?` (let init) → A = 6 (post-#393: every `=`
        //   initializer in a `let_declaration` is one assignment, in
        //   line with the literal Fitzpatrick reading).
        // - branches: `xs.iter()`, `.next()`, `Err(())`, `r?` → B = 4
        //   (3 calls + 1 try).
        // - conditions: `if let Some(v) = opt` → 1, `match x` arms
        //   `0`, `n if n>0` (wildcard excluded) → 2, `n > 0` → 1.
        //   Total C = 4.
        check_metrics::<RustParser>(
            "fn f(opt: Option<i32>, xs: Vec<i32>) -> Result<i32, ()> {\n\
             \x20   let mut x = 0;\n\
             \x20   x = 5;\n\
             \x20   x += 2;\n\
             \x20   if let Some(_v) = opt { }\n\
             \x20   let _ = xs.iter().next();\n\
             \x20   let r: Result<i32, ()> = Err(());\n\
             \x20   let _v = r?;\n\
             \x20   Ok(match x {\n\
             \x20       0 => 1,\n\
             \x20       n if n > 0 => n,\n\
             \x20       _ => -1,\n\
             \x20   })\n\
             }\n",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 6);
                // calls: xs.iter(), .next(), Err(()), Ok(...) → 4 calls
                // plus 1 try (`r?`) → 5 branches.
                assert_eq!(metric.abc.branches_sum(), 5);
                // 1 let_condition + 2 non-wildcard match_arms + 1
                // comparison (`n > 0`) → 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_let_chain_bare_identifier_operand_counts() {
        // Regression: pre-fix, `if a && let Some(_z) = y { }` reported
        // 1 condition (only the LetCondition). The bare-identifier
        // `a` operand was lost because Rust 2024 wraps let-chain
        // `&&` operands in a `LetChain` node (not `BinaryExpression`)
        // and the former `rust_count_unary_conditions` only counted
        // terminals under a `BinaryExpression` parent. Allowing `LetChain` /
        // `LetChain2` as known-bool list parents fixed the loss.
        // Expected: LetCondition (1) + walker on `a` (1) = 2.
        check_metrics::<RustParser>(
            "fn f(a: bool, y: Option<i32>) {\n\
             \x20   if a && let Some(_z) = y { }\n\
             }\n",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_if_multiple_conditions() {
        // Fitzpatrick Rule 7 / Listing 2 (issue #403): every operand of
        // a `&&` / `||` chain is one condition. Mirrors
        // `java_if_multiple_conditions`. Rust's `if` head has no
        // parentheses, but the walker fires on each `&&` / `||` token
        // and walks the parent `binary_expression` regardless.
        check_metrics::<RustParser>(
            "fn f(a: bool, b: bool, c: bool, d: bool) -> i32 {\n\
             \x20   if a || b || c || d { return 1; }    // +4c\n\
             \x20   if a && b && c { return 2; }         // +3c\n\
             \x20   if !a && !b { return 3; }            // +2c\n\
             \x20   0\n\
             }\n",
            "foo.rs",
            |metric| {
                // 4 + 3 + 2 = 9
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_while_conditions() {
        // Rust has no `do { ... } while(cond);` construct, so this
        // mirrors only the `while` half of `java_while_and_do_while_conditions`.
        // Each operand of the `&&` / `||` chain in the loop condition
        // counts as one Fitzpatrick condition (Rule 7).
        check_metrics::<RustParser>(
            "fn f(a: bool, b: bool) {\n\
             \x20   while a || b { break; }       // +2c\n\
             \x20   while a && !b { break; }      // +2c\n\
             }\n",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_if_boolean_literal_condition() {
        // Phase 2B (issue #403): a condition whose entire body is a
        // boolean literal counts as one Fitzpatrick condition.
        // `if true {}` → 1, `if !false {}` → 1 (unary unwrap), and
        // `while true { break }` → 1.
        check_metrics::<RustParser>(
            "fn f() {\n\
             \x20   if true { }                  // +1c\n\
             \x20   if !false { }                // +1c\n\
             \x20   while true { break; }        // +1c\n\
             }\n",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_methods_arguments_with_conditions() {
        // Phase 2B (issue #403): unary-conditional arguments to a
        // call each count once. `m(!a, !b)` → 2 conditions + 1
        // branch (the call itself). Bare identifier arguments do
        // NOT count (they reach the count_unary_conditions list with
        // list_kind = Arguments, not BinaryExpression).
        check_metrics::<RustParser>(
            "fn f(a: bool, b: bool) {\n\
             \x20   m(a, b);                     // +1b\n\
             \x20   m(!a, !b);                   // +1b +2c\n\
             \x20   m(!a, b, !a);                // +1b +2c\n\
             }\n",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 3);
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_return_with_conditions() {
        // Phase 2B (issue #403). Mirrors `java_return_with_conditions`
        // — `return !a` / `return x && y` count their unary
        // conditional operands. Per Fitzpatrick Rule 7, a `!`-wrapped
        // relational expression contributes ONE condition (the
        // relational op itself) — the `!` does not add a second
        // count when its operand is already a comparison.
        check_metrics::<RustParser>(
            "fn m1(z: i32) -> bool { return !(z >= 0); }\n\
             fn m2(x: bool) -> bool { return (((!x))); }\n\
             fn m3(x: bool, y: bool) -> bool { return x && y; }\n\
             fn m4(y: bool, z: i32) -> bool { return y || (z < 0); }\n",
            "foo.rs",
            |metric| {
                // m1: !(z >= 0) → the `>=` contributes 1; the unary
                //     `!` wraps a paren'd BinaryExpression, which
                //     inspect_container does not unwrap further →
                //     no walker count. Total: 1.
                // m2: (((!x))) → ReturnExpression arm walks (((!x))).
                //     inspect_container unwraps three parens and one
                //     unary, reaches Identifier `x`, has_boolean_content
                //     was seeded true by the unary-not flip. +1.
                // m3: x && y → `&&` walker counts both terminals → 2.
                // m4: y || (z < 0) → `||` walker counts `y` (terminal,
                //     +1); the `<` contributes 1 via its own arm; the
                //     paren'd BinaryExpression `(z < 0)` is not
                //     terminal under the walker → no extra count.
                //     Total: 2.
                // Sum: 1 + 1 + 2 + 2 = 6.
                assert_eq!(metric.abc.conditions_sum(), 6);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_short_circuit_with_boolean_literal_operand() {
        // `if a && true` reports 2 conditions: one for the identifier
        // operand, one for the boolean-literal operand. Confirms the
        // walker terminal set includes `BooleanLiteral`.
        check_metrics::<RustParser>(
            "fn f(a: bool) -> bool { a && true }\n",
            "foo.rs",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // ----- Go -----

    #[cfg(feature = "go")]
    #[test]
    fn go_empty_unit_zero() {
        // Package declaration only — no Fitzpatrick events. Confirms the
        // GoCode Abc trait is wired up and emits zero counts.
        check_metrics::<GoParser>("package main\n", "empty.go", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_assignments_count_plain_compound_short_var_and_incdec() {
        // `x := 0` (short var decl), `x = 5` and `x = 7` (plain `=`),
        // `x += 2` (compound), `x++` (inc), and the initialized
        // declaration `var y = 1` — which is counted, matching the Rust
        // and Java rules for `let y = 1` / `int y = 1` (both measured at
        // one assignment each). The comment here previously claimed the
        // opposite and pinned Go at 6 (#1278).
        check_metrics::<GoParser>(
            "package main\nfunc f() { var y = 1; _ = y; x := 0; x = 5; x += 2; x = 7; x++ }\n",
            "foo.go",
            |metric| {
                // `_ = y` is itself an assignment_statement → +1.
                // var y=1 + _=y + x:= + x=5 + x+=2 + x=7 + x++ → 7
                assert_eq!(metric.abc.assignments_sum(), 7);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_var_declarations_count_only_when_initialized() {
        // Regression for #1278: a `var` declaration with an initializer is
        // a `var_spec` carrying a `value` field, not an
        // `assignment_statement` or `short_var_declaration`, so it scored
        // zero — `var x = 5` and `x := 5` are the same binding spelled two
        // ways. Both typed and untyped initializers count; an
        // uninitialized `var z int` and a `const` do not.
        // expected: 3 assignments — `var x = 5`, `var y int = 6`, `z := 7`;
        // `var w int` and `const c = 1` contribute nothing.
        check_metrics::<GoParser>(
            "package main\nfunc f() int {\n\tvar x = 5\n\tvar y int = 6\n\tvar w int\n\tconst c = 1\n\tz := 7\n\treturn x + y + w + c + z\n}\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 3);
                assert_eq!(metric.abc.branches_sum(), 0);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_grouped_var_block_counts_each_initialized_spec() {
        // A grouped `var ( … )` block is one `var_declaration` holding one
        // `var_spec` per line, so matching the spec counts each initialized
        // line on its own. A multi-name spec is still one binding
        // statement, matching `p, q := 1, 2` (#1278).
        // expected: 3 assignments — `a = 1`, `p, q = 1, 2`, and `r := 0`;
        // the uninitialized `b int` contributes nothing.
        check_metrics::<GoParser>(
            "package main\nfunc f() {\n\tvar (\n\t\ta = 1\n\t\tb int\n\t)\n\tvar p, q = 1, 2\n\tr := 0\n\t_ = a + b + p + q + r\n}\n",
            "foo.go",
            |metric| {
                // The trailing `_ = …` is itself an assignment_statement.
                assert_eq!(metric.abc.assignments_sum(), 4);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_calls_are_branches() {
        // Three calls: free function `g()`, method call `r.Inc()`, and
        // builtin call `len(s)`. All parse as `call_expression` → B = 3.
        // Composite literal `Foo{}` is NOT a call.
        check_metrics::<GoParser>(
            "package main\n\
             type R struct{}\n\
             func (r R) Inc() {}\n\
             func g() {}\n\
             func f(s string) { g(); var r R = R{}; r.Inc(); _ = len(s) }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_comparisons_count_conditions() {
        // `<`, `>`, `<=`, `>=`, `==`, `!=` each count once. Six
        // comparisons → C = 6.
        check_metrics::<GoParser>(
            "package main\nfunc f(a, b int) bool { return a < b || a > b || a <= b || a >= b || a == b || a != b }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 6);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_generic_brackets_not_conditions() {
        // Generic instantiation `Min[int](a, b)` puts `int` inside
        // `TypeArguments`, not `BinaryExpression`. The parent guard on
        // `<` / `>` must not count these. Expected C = 0; B = 1 (one call).
        check_metrics::<GoParser>(
            "package main\nfunc Min[T int | float64](a, b T) T { return a }\nfunc f() { _ = Min[int](1, 2) }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_switch_arms_count_conditions_default_excluded() {
        // Four arms: `case 1:`, `case 2:`, `case 3:`, `default:`. The
        // bare `default` is the C/Java `default:` equivalent and is
        // excluded — 3 conditions from ExpressionCase. The switch
        // expression `x` is bare (no comparison), so no extra
        // condition from `==`-style operators.
        check_metrics::<GoParser>(
            "package main\nfunc f(x int) int { switch x { case 1: return 1; case 2: return 2; case 3: return 3; default: return 0 } }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_type_switch_arms_count_conditions() {
        // Type switch: `case int:`, `case string:`, `default:`. Two
        // non-default type-case arms → C = 2.
        check_metrics::<GoParser>(
            "package main\nfunc f(v interface{}) { switch v.(type) { case int: return; case string: return; default: return } }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_select_arms_count_conditions() {
        // `select { case <-ch: ...; case ch <- 1: ...; default: ... }`.
        // Two non-default communication cases → C = 2.
        check_metrics::<GoParser>(
            "package main\nfunc f(ch chan int) { select { case <-ch: return; case ch <- 1: return; default: return } }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Anchors the tag shape of a Go fixture before scoring its members:
    // `tagged` is how many expression switches carry a `value` field, so
    // a fixture edit that turns a tagless switch tagged (or back) fails
    // here rather than as a moved score.
    #[cfg(feature = "go")]
    fn assert_go_switch_members(
        src: &str,
        tagged: usize,
        kinds: &[(u16, usize, &str)],
        expected: &[(&str, u64, u64)],
    ) {
        let parser = GoParser::new(
            src.as_bytes().to_vec(),
            std::path::Path::new("foo.go"),
            None,
        );
        let found = parser
            .root()
            .preorder()
            .filter(|n| {
                n.kind_id() == Go::ExpressionSwitchStatement
                    && n.child_by_field_name("value").is_some()
            })
            .count();
        assert_eq!(found, tagged, "tagged switches — the fixture moved");
        assert_fixture_spells::<GoParser>(src, "foo.go", kinds);
        check_func_space::<GoParser, _>(src, "foo.go", |space| {
            assert_members_score(&space, expected);
        });
    }

    // #1523, transferring #1453's Ruby rule. A tagless switch is
    // `switch true`: each case expression is an ordinary boolean, so a
    // comparison in it is already paid by the token arm, and the case's
    // former blanket +1 counted `gt` twice against its `if` twin `iff`.
    // Every row now equals the `if` spelling of the same predicate.
    //
    // `bare`, `paren` and `neg` are the controls: no operator for any
    // other arm to count, so the case still pays through the `if` slot
    // (1 before the fix and after). `negcmp` peels to a comparison the
    // token arm owns. `init1` carries an `initializer` and no tag, and
    // `cmt` puts a comment where the tag would go: neither is the
    // `value` field, so both stay tagless. `nest2` is a tagless switch
    // inside a tagged one — each switch is judged by its own tag.
    #[cfg(feature = "go")]
    #[test]
    fn go_tagless_switch_case_counts_its_condition_once() {
        let src = "package main
func gt(x int) int { switch { case x > 5: return 1 }; return 0 }
func iff(x int) int { if x > 5 { return 1 }; return 0 }
func bare(b bool) int { switch { case b: return 1 }; return 0 }
func paren(b bool) int { switch { case (b): return 1 }; return 0 }
func neg(b bool) int { switch { case !b: return 1 }; return 0 }
func negcmp(x int) int { switch { case !(x > 5): return 1 }; return 0 }
func andd(a, b bool) int { switch { case a && b: return 1 }; return 0 }
func two(x int) int { switch { case x > 1: fallthrough; case x < 0: return 1; default: return 2 } }
func init1(s string) int { switch n := len(s); { case n > 1: return 1 }; return 0 }
func cmt(x int) int { switch /* no tag */ { case /* c */ x > 5: return 1 }; return 0 }
func nest(x, y int) int { switch { case x > 1: switch { case y > 1: return 1 } }; return 0 }
func nest2(x, y int) int { switch x { case 1: switch { case y > 1: return 1 } }; return 0 }
";
        assert_go_switch_members(
            src,
            1,
            &[
                (Go::ExpressionCase as u16, 14, "expression cases"),
                (Go::DefaultCase as u16, 1, "`two`'s `default`"),
                (Go::GT as u16, 9, "`>` comparisons"),
                (
                    Go::ParenthesizedExpression as u16,
                    2,
                    "`paren` / `negcmp` parens",
                ),
                (Go::Comment as u16, 2, "`cmt`'s comments"),
            ],
            &[
                // (member, abc.conditions, cyclomatic)
                // Was 2: the `>` and the case, for one decision.
                ("gt", 1, 2),
                ("iff", 1, 2),
                ("bare", 1, 2),
                ("paren", 1, 2),
                ("neg", 1, 2),
                // Was 2.
                ("negcmp", 1, 2),
                // Was 3: the Rule 9 walker owns both operands.
                ("andd", 2, 3),
                // Was 4. `default` stays +0 and `fallthrough` adds nothing.
                ("two", 2, 3),
                // Was 2.
                ("init1", 1, 2),
                // Was 2. A comparison, not a bare operand, so a misread
                // tag (+1 per case on top of the `>`) shows as 2.
                ("cmt", 1, 2),
                // Was 4.
                ("nest", 2, 3),
                // Was 3: the tagged outer case keeps its 1.
                ("nest2", 2, 3),
            ],
        );
    }

    // A pointer dereference or channel receive is a boolean operand the
    // way an identifier is: `*p` of a `*bool`, `<-ch` of a `chan bool`.
    // No operator arm counts either, so each slot pays for it — the `if`
    // slot, a tagless case (which #1523 routed through that slot, so
    // `swp` / `swr` fell from 1 to 0 until this), the `!` / paren peel,
    // and an `&&` operand. `neg` and `asg` are the controls: `-x`, `*&y`
    // and `b := *p` sit in no boolean slot and stay 0 (#1526).
    #[cfg(feature = "go")]
    #[test]
    fn go_deref_and_receive_are_boolean_operands() {
        let src = "package main
func ifp(p *bool) int { if *p { return 1 }; return 0 }
func ifr(ch chan bool) int { if <-ch { return 1 }; return 0 }
func swp(p *bool) int { switch { case *p: return 1 }; return 0 }
func swr(ch chan bool) int { switch { case <-ch: return 1 }; return 0 }
func andp(a bool, p *bool) int { if a && *p { return 1 }; return 0 }
func notp(p *bool) int { if !*p { return 1 }; return 0 }
func parp(p *bool) int { if (*p) { return 1 }; return 0 }
func neg(x int) int { y := -x; z := *&y; return z }
func asg(p *bool) bool { b := *p; return b }
";
        assert_go_switch_members(
            src,
            0,
            &[
                (Go::ExpressionCase as u16, 2, "`swp` / `swr` cases"),
                (Go::LTDASH as u16, 2, "`ifr` / `swr` receives"),
                (Go::ParenthesizedExpression as u16, 1, "`parp`'s parens"),
            ],
            &[
                // (member, abc.conditions, cyclomatic)
                ("ifp", 1, 2),
                ("ifr", 1, 2),
                ("swp", 1, 2),
                ("swr", 1, 2),
                ("andp", 2, 3),
                ("notp", 1, 2),
                ("parp", 1, 2),
                ("neg", 0, 1),
                ("asg", 0, 1),
            ],
        );
    }

    // A case listing several expressions is an implicit `||` — Go's spec
    // defines a tagless switch as `switch true`, so `case a, b:` holds
    // when `a == true || b == true` — and each expression is scored as an
    // operand of that chain: once, unless its own arm already counted it.
    // `ab` and `mix` therefore read 2, exactly their `if a || b` /
    // `if a || x > 1` twins, and `xim` shows the order cannot matter.
    // This is #1453's Ruby rule (`when a, b` reads 2) rather than
    // Kotlin's first-alternative-only rule, which scores the two orders
    // differently.
    //
    // Parity consequence: cyclomatic scores the case as one decision, so
    // these rows sit one above `conditions == cyclomatic - 1`, while the
    // `||` twins sit at it — the same trade Ruby's `when a, b` makes.
    #[cfg(feature = "go")]
    #[test]
    fn go_tagless_switch_case_lists_are_an_implicit_or() {
        let src = "package main
func ab(a, b bool) int { switch { case a, b: return 1 }; return 0 }
func ifab(a, b bool) int { if a || b { return 1 }; return 0 }
func mix(a bool, x int) int { switch { case a, x > 1: return 1 }; return 0 }
func xim(a bool, x int) int { switch { case x > 1, a: return 1 }; return 0 }
func ifmix(a bool, x int) int { if a || x > 1 { return 1 }; return 0 }
func cmts(a, b bool) int { switch { case a, /* c */ b: return 1 }; return 0 }
";
        assert_go_switch_members(
            src,
            0,
            &[
                (Go::ExpressionCase as u16, 4, "expression cases"),
                (Go::PIPEPIPE as u16, 2, "the `||` twins"),
                (Go::Comment as u16, 1, "`cmts`'s comment"),
            ],
            &[
                // Was 1: only the case, for two operands.
                ("ab", 2, 2),
                ("ifab", 2, 3),
                ("mix", 2, 2),
                ("xim", 2, 2),
                ("ifmix", 2, 3),
                // Was 1: the comment is no operand.
                ("cmts", 2, 2),
            ],
        );
    }

    // The controls that must not move. A tagged case lists values
    // compared with the tag, a comparison the source never spells, so the
    // case itself is the condition — `init2` carries an `initializer`
    // beside its tag, and `tagcmp`'s `x > 1` is a value compared with `b`
    // (`if b == (x > 1)` also scores 2). Type-switch and `select` cases
    // are not expression cases at all.
    #[cfg(feature = "go")]
    #[test]
    fn go_tagged_switch_keeps_the_per_case_count() {
        let src = "package main
func tag(x int) int { switch x { case 1, 2: return 1 }; return 0 }
func init2(s string) int { switch n := len(s); n { case 1: return 1 }; return 0 }
func tagcmp(b bool, x int) int { switch b { case x > 1: return 1 }; return 0 }
func ts(v any) int { switch v.(type) { case int: return 1 }; return 0 }
func sel(c chan int) int { select { case <-c: return 1 }; return 0 }
";
        assert_go_switch_members(
            src,
            3,
            &[
                (Go::ExpressionCase as u16, 3, "expression cases"),
                (Go::TypeCase as u16, 1, "`ts`'s type case"),
                (
                    Go::CommunicationCase as u16,
                    1,
                    "`sel`'s communication case",
                ),
            ],
            &[
                ("tag", 1, 2),
                ("init2", 1, 2),
                ("tagcmp", 2, 2),
                ("ts", 1, 2),
                ("sel", 1, 2),
            ],
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_else_counts_as_condition() {
        // `if a > b { ... } else { ... }` → `a > b` is one condition,
        // `else` is one condition → C = 2.
        check_metrics::<GoParser>(
            "package main\nfunc f(a, b int) int { if a > b { return a } else { return b } }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_complex_function_abc() {
        // Mixed shape, verified by hand:
        // - Assignments: `var x = 10` (an initialized declaration, #1278),
        //   `_ = x`, `n := 0`, `n = n + 1`, `n += 2`, `n++`,
        //   `_ = len(s)` → A = 7. Every `_ = ...` IS counted as an
        //   assignment_statement.
        // - Branches: `len(s)` → B = 1.
        // - Conditions: `n < 10` → 1, `else` → 1, switch arms `case 0:`
        //   and `case 1:` (default excluded) → 2 → total C = 4.
        check_metrics::<GoParser>(
            "package main\nfunc f(s string) int {\n\
             \x20   var x = 10\n\
             \x20   _ = x\n\
             \x20   n := 0\n\
             \x20   if n < 10 { n = n + 1 } else { n += 2 }\n\
             \x20   n++\n\
             \x20   _ = len(s)\n\
             \x20   switch n {\n\
             \x20   case 0: return 0\n\
             \x20   case 1: return 1\n\
             \x20   default: return n\n\
             \x20   }\n\
             }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 7);
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_if_multiple_conditions() {
        // Fitzpatrick Rule 7 walker fan-out (issue #403). Mirrors
        // `rust_if_multiple_conditions`.
        check_metrics::<GoParser>(
            "package p\n\
             func F(a, b, c, d bool) int {\n\
             \x20   if a || b || c || d { return 1 }    // +4c\n\
             \x20   if a && b && c { return 2 }         // +3c\n\
             \x20   if !a && !b { return 3 }            // +2c\n\
             \x20   return 0\n\
             }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_for_with_conditions() {
        // Go has no `while` or `do { … } while(…);` — the `for` loop
        // header is the sole condition slot. Each operand of the
        // `&&` / `||` chain in the for-condition counts as one
        // Fitzpatrick condition.
        check_metrics::<GoParser>(
            "package p\n\
             func F(a, b bool) {\n\
             \x20   for a || b { break }       // +2c\n\
             \x20   for a && !b { break }      // +2c\n\
             }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_for_bare_condition_counts() {
        // Regression for findings.md #1: `for true {}` / `for !ready {}`
        // are Go's only loop-condition slot. Pre-fix, the Phase-2B
        // dispatcher had no `G::ForStatement` arm, so bare-boolean
        // and `!`-wrapped `for` conditions silently reported zero.
        // `go_count_condition`'s terminal-bool / paren / unary filter
        // makes the walker safe across all three for-statement shapes:
        // bare condition, `for_clause` (init; cond; post) — whose own
        // `condition` field #1276 taught the walker to read — and
        // `range_clause`, which has no such field and contributes
        // nothing.
        check_metrics::<GoParser>(
            "package p\n\
             func F(ready bool) {\n\
             \x20   for true { break }      // +1c\n\
             \x20   for !ready { break }    // +1c\n\
             \x20   for i := 0; i < 3; i++ { _ = i }    // +1c (the `<`)\n\
             }\n",
            "foo.go",
            |metric| {
                // `for true`: walker counts True (+1).
                // `for !ready`: walker on unary unwraps to `ready`
                //   (+1).
                // `for_clause`'s condition is `i < 3`, a
                //   `binary_expression` that `go_count_condition`
                //   filters out; the `<` itself contributes 1 via the
                //   pre-existing LT/GT arm.
                // Total: 3.
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Issue #1276, Go's share. `for_statement`'s child(1) is the
    // condition only in the `for cond {}` spelling; the three-clause
    // form puts it one level down, in the `for_clause`'s `condition`
    // field. Letting the `for_clause` fall through — which the arm's
    // own comment used to call harmless — scored a bare three-clause
    // condition zero while `for a {}` scored one.
    #[cfg(feature = "go")]
    #[test]
    fn go_three_clause_for_condition_counts() {
        // Bare identifier in the three-clause header: no comparison
        // token, so only the `for_clause` lookup can count it.
        check_metrics::<GoParser>(
            "package p\n\
             func F(a bool) {\n\
             \x20   for i := 0; a; i++ { _ = i }\n\
             }\n",
            "foo.go",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
        // Negation, through `go_inspect_container`'s `!` unwrap.
        check_metrics::<GoParser>(
            "package p\n\
             func F(a bool) {\n\
             \x20   for i := 0; !a; i++ { _ = i }\n\
             }\n",
            "foo.go",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
        // Empty condition: the `for_clause` exposes no `condition`
        // field, so zero — the same answer as Go's bare `for {}` and
        // as every other language since #1276.
        check_metrics::<GoParser>(
            "package p\n\
             func F() {\n\
             \x20   for i := 0; ; i++ { break }\n\
             }\n",
            "foo.go",
            |metric| assert_eq!(metric.abc.conditions_sum(), 0),
        );
        // A `range_clause` carries no condition either, and the walker
        // must not mistake the clause itself for one.
        check_metrics::<GoParser>(
            "package p\n\
             func F(xs []int) {\n\
             \x20   for _, v := range xs { _ = v }\n\
             }\n",
            "foo.go",
            |metric| assert_eq!(metric.abc.conditions_sum(), 0),
        );
    }

    // Go's `for_statement` is the one grammar here that exposes no
    // `condition` field, so its header slot is located structurally and
    // has to skip what the field-addressed siblings get for free. Two
    // things it must skip, each of which `node.child(1)` got wrong:
    // a leading comment (tree-sitter counts comments among a node's
    // children — the #1181 failure), and the body of a bare `for {}`,
    // which IS child(1) and would otherwise be offered to
    // `go_count_condition` as though it were a condition.
    #[cfg(feature = "go")]
    #[test]
    fn go_for_header_slot_skips_comments_and_the_body() {
        // Each pair is (source, expected conditions). The commented
        // spelling must agree with its bare twin.
        let cases = [
            ("for a { break }", 1),
            ("for /* n */ a { break }", 1),
            ("for i := 0; a; i++ { _ = i }", 1),
            ("for /* n */ i := 0; a; i++ { _ = i }", 1),
            ("for i := 0; /* n */ a; i++ { _ = i }", 1),
            // Bare infinite loop: the body is child(1) and must not be
            // read as the condition.
            ("for { break }", 0),
            ("for /* n */ { break }", 0),
            ("for _, v := range xs { _ = v }", 0),
            ("for /* n */ _, v := range xs { _ = v }", 0),
        ];
        let mut ran = 0;
        for (body, expected) in cases {
            let src = format!("package p\nfunc F(a bool, xs []int) {{\n\t{body}\n}}\n");
            assert_eq!(abc_conditions(LANG::Go, &src), expected, "`{body}`");
            ran += 1;
        }
        // Non-vacuity, both halves: the loop must actually have run
        // every row, and the rows must carry both answers — a walker
        // stuck at 0 or at 1 would otherwise pass half the table
        // silently.
        assert_eq!(ran, cases.len());
        assert!(cases.iter().any(|&(_, n)| n == 1));
        assert!(cases.iter().any(|&(_, n)| n == 0));
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_if_init_statement_condition_counts() {
        // Regression for the code-review finding: Go's
        // `if x := f(); x { ... }` init-statement form puts the
        // short-var declaration at child(1) and the condition at
        // child(2). Pre-fix, the dispatcher used child(1) and
        // counted zero conditions for this idiomatic Go shape.
        // The fix uses `child_by_field_name("condition")` which
        // returns the condition regardless of init presence.
        check_metrics::<GoParser>(
            "package p\nfunc F() { if x := g(); x { } }\n",
            "foo.go",
            |metric| {
                // `x` bare-identifier condition contributes 1
                // (Rule 6 — bare boolean identifier in if-condition).
                // `g()` call contributes 1 branch but no condition.
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_if_boolean_literal_condition() {
        check_metrics::<GoParser>(
            "package p\n\
             func F() {\n\
             \x20   if true {}                  // +1c\n\
             \x20   if !false {}                // +1c\n\
             }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_methods_arguments_with_conditions() {
        check_metrics::<GoParser>(
            "package p\n\
             func F(a, b bool) {\n\
             \x20   m(a, b)                     // +1b\n\
             \x20   m(!a, !b)                   // +1b +2c\n\
             }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_return_with_conditions() {
        check_metrics::<GoParser>(
            "package p\n\
             func M1(z int) bool { return !(z >= 0) }\n\
             func M2(x bool) bool { return !x }\n\
             func M3(x, y bool) bool { return x && y }\n",
            "foo.go",
            |metric| {
                // M1: `>=` (1). `!(z >= 0)` walker on the unary
                //     doesn't reach a terminal — stops at the
                //     BinaryExpression z>=0 inside the parens. +1.
                // M2: walker on `!x` → 1.
                // M3: `&&` walker counts both → 2.
                // Sum: 1 + 1 + 2 = 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_short_circuit_with_boolean_literal_operand() {
        // `a && true` reports 2 conditions: one identifier, one
        // boolean literal. Confirms the terminal set includes
        // `True` / `False`.
        check_metrics::<GoParser>(
            "package p\nfunc F(a bool) bool { return a && true }\n",
            "foo.go",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // ----- Elixir -----

    // No top-level Calls and no operators → all three vectors are
    // zero. Uses a bare expression rather than a `defmodule` wrapper
    // (which would itself be a Call → 1 branch). Confirms the
    // ElixirCode Abc trait is wired up and the metric emits.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_empty_unit_zero() {
        check_metrics::<ElixirParser>(":ok\n", "foo.ex", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    // An empty `defmodule Foo do ... end` is itself ONE `Call` →
    // Documents that module-/function-defining macros (`defmodule`,
    // `def`, `defp`, `defmacro`, `defmacrop`) and declarative
    // directives (`alias`, `import`, `require`, `use`) are NOT
    // runtime dispatch and therefore do NOT inflate `branches`,
    // matching Cognitive's treatment.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_defmodule_is_zero_branches() {
        check_metrics::<ElixirParser>("defmodule Foo do\nend\n", "foo.ex", |metric| {
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    // Pattern-match `=` counts as an assignment. Two bindings → A = 2.
    // `defmodule` and `def` are declarative-Call wrappers and are
    // filtered out of branches; the assertion focuses on assignments
    // so we only pin that vector.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_pattern_match_is_assignment() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f do\n    x = 1\n    y = x + 1\n    y\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // `|>` pipeline operator: each `|>` token contributes one branch.
    // Two `|>` ops → +2 from the pipe operator itself. Each pipeline
    // step also dispatches a Call (`String.upcase(...)`,
    // `String.trim(...)`) — these are wrapped inside the outer
    // pipeline Call tree, contributing additional Call branches.
    // The headline assertion confirms (a) `|>` is detected and (b)
    // pipeline steps are not silently dropped.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_pipeline_each_step_is_branch() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def normalize(s) do\n    s |> String.trim() |> String.upcase()\n  end\nend\n",
            "foo.ex",
            |metric| {
                // Pipeline yields 2 `|>` branches plus Calls for
                // String.trim, String.upcase, and the outer pipeline
                // (which surfaces as a Call wrapping the binary
                // operator). `def` and `defmodule` are declarative
                // and excluded. Empirical total: B = 5.
                assert_eq!(metric.abc.branches_sum(), 5);
                assert_eq!(metric.abc.assignments_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Comparison operators all count as conditions. Six comparisons
    // (`==`, `!=`, `<`, `>`, `<=`, `>=`) → C = 6.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_comparisons_are_conditions() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(a, b) do\n    a == b or a != b or a < b or a > b or a <= b or a >= b\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 6);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Strict-equality operators `===` / `!==` count as conditions too.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_strict_equality_is_condition() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(a, b) do\n    a === b or a !== b\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // #1461 moved every relational construct a grammar spells as its own
    // production onto an unconditional arm — scored by use, Fitzpatrick
    // Rule 5 — in C#, Java, Groovy, Kotlin and Ruby. Elixir's membership
    // and type tests were the same class and were not in that sweep, so
    // `a in b` scored zero where `a == b` scored one. The gap stayed
    // invisible while the `when` arm paid a flat one for every guard,
    // and surfaced the moment the guard became a slot: an
    // operator-spelled guard is owned by its operator's arm, and `in`
    // had none.
    //
    // `bare` / `negbare` are the by-use claim; `slot` is the §5 check
    // that a boolean slot does not now score the same operator twice;
    // `cmp` is the control the two membership rows are levelled against.
    // `in` rides the `<` / `>` `binary_operator` gate rather than
    // standing alone — it has the same three grammar positions — and
    // `elixir_operator_identifier_is_not_a_condition` pins that gate.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_membership_is_a_condition_by_use() {
        check_func_space::<ElixirParser, _>(
            "defmodule Foo do\n\
               def bare(a, b), do: a in b\n\
               def negbare(a, b), do: a not in b\n\
               def slot(a, b) do\n\
                 if a in b do\n\
                   IO.puts(\"x\")\n\
                 end\n\
               end\n\
               def cmp(a, b), do: a == b\n\
             end\n",
            "foo.ex",
            |space| {
                assert_members_score(
                    &space.spaces[0],
                    &[
                        // Each was 0 before the arm.
                        ("bare", 1, 1),
                        ("negbare", 1, 1),
                        // `in` (1) only — the `if` predicate slot is
                        // already paid by the operator (#1527), exactly
                        // as `if a == b` scores.
                        ("slot", 1, 2),
                        ("cmp", 1, 1),
                    ],
                );
            },
        );
    }

    // Guard `when` clause counts as a condition — exactly one, and here
    // it is the `>` that supplies it. The guard is a condition *slot*
    // (#1454), so an operator-spelled guard scores through the operator
    // arm that owns it and the slot itself adds nothing; see
    // `elixir_guard_is_a_decision_however_spelled` for the four-spelling
    // agreement this is one row of.
    //
    // Was 2, on a flat `+1` for the `when` token laid on top of the `>`:
    // the §5 double count a whole-branch review of the #1454 batch
    // found.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_guard_when_is_condition() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) when x > 0 do\n    :pos\n  end\nend\n",
            "foo.ex",
            |metric| {
                // the guard slot (+0, the guard is an operator
                // application) + `>` (+1) = 1
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // A `case` pays one condition per clause (#1531) AND one branch for
    // the Call itself. The `_ ->` catch-all is the default arm and pays
    // nothing, so this two-clause `case` scores 1; the per-clause rule
    // is pinned by `elixir_clause_constructs_pay_per_clause`.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_case_is_condition_and_branch() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    case x do\n      1 -> :one\n      _ -> :other\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                // conditions: `1 ->` (+1) + `_ ->` default (+0) = 1
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // `cond` scores per clause, as its nested-`if` twin does (#1527): the
    // `x > 0` clause is a predicate slot its `>` already pays, and the
    // `true ->` catch-all is the default arm and pays nothing.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_cond_is_condition() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x) do\n    cond do\n      x > 0 -> :pos\n      true -> :other\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                // conditions: `x > 0` clause slot (+0) + `>` (+1) +
                // `true ->` default (+0) = 1, against cyclomatic 2
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // An `if` / `unless` predicate and each `cond` clause are condition
    // slots (#1527): one condition, unless an operator in the slot
    // already paid. Before, the keyword Call paid a flat one on top of
    // its predicate, so `if x > 5` scored 2 and `cond` paid once per
    // construct whatever its clause count.
    //
    // Expected values come from the twins, not the rule: each `if` row
    // is what Ruby and Java score for the same `if` (`if x > 5` 1,
    // `if b` 1, `if a && b` 2 — measured), every non-chain row sits at
    // `cyclomatic - 1`, and `cond3` equals Go's tagless
    // `switch { case x > 5: … case b: … default: … }` (2), whose
    // `default:` is as free as `cond`'s `true ->`. Its nested-`if` twin
    // `nested` pays Fitzpatrick Rule 5 for each `else` (#1531), as
    // Ruby's `if … elsif … else` and Java's `if … else if … else` do (4
    // against cyclomatic 3 — measured). The chain rows sit one under
    // parity exactly as Ruby's and Java's `if a && b` (2 / 3) do.
    //
    // Paths only one row exercises (§11): `cmp_comment` the comment
    // skip in a parenthesised peel, `assign` the match-`=` peel,
    // `negcmp` the `not` peel, `arith` a non-comparison operator the
    // slot pays for, `capture` a chain operand that no terminal list
    // held (`&f/1` scored one short of `a && b` on main), and the
    // `true ->` rows the default-arm gate shared with cyclomatic.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_if_and_cond_predicates_are_slots() {
        check_func_space::<ElixirParser, _>(
            "defmodule Foo do
  def cmp(x), do: (if x > 5 do 1 end)
  def bare(b), do: (if b do 1 end)
  def kw(x), do: if(x > 5, do: 1)
  def unless_cmp(x), do: (unless x > 5 do 1 end)
  def cmp_comment(x) do
    if (x > 5 # c
    ) do
      1
    end
  end
  def assign(x), do: (if (y = x > 5) do y end)
  def negcmp(x), do: (if not(x > 5) do 1 end)
  def arith(x), do: (if x + 1 do 1 end)
  def chain(a, b), do: (if a && b do 1 end)
  def capture(a), do: (if a && &f/1 do 1 end)
  def cond_cmp(x) do
    cond do
      x > 5 -> 1
      true -> 2
    end
  end
  def cond_bare(b) do
    cond do
      b -> 1
      true -> 2
    end
  end
  def cond3(x, b) do
    cond do
      x > 5 -> 1
      b -> 2
      true -> 3
    end
  end
  def nested(x, b) do
    if x > 5 do
      1
    else
      if b do 2 else 3 end
    end
  end
  def cond_no_default(a, b, c) do
    cond do
      a -> 1
      b -> 2
      c -> 3
    end
  end
end
",
            "foo.ex",
            |space| {
                assert_members_score(
                    &space.spaces[0],
                    &[
                        ("cmp", 1, 2),
                        ("bare", 1, 2),
                        ("kw", 1, 2),
                        ("unless_cmp", 1, 2),
                        ("cmp_comment", 1, 2),
                        ("assign", 1, 2),
                        ("negcmp", 1, 2),
                        ("arith", 1, 2),
                        ("chain", 2, 3),
                        ("capture", 2, 3),
                        ("cond_cmp", 1, 2),
                        ("cond_bare", 1, 2),
                        ("cond3", 2, 3),
                        ("nested", 4, 3),
                        ("cond_no_default", 3, 4),
                    ],
                );
            },
        );
    }

    // Every clause construct pays one condition per clause (#1531), as
    // `Cyclomatic` counts one decision per clause through the same gate.
    // `case` and `with` paid once per construct and the others not at
    // all, so a two-clause `case` scored 1 against Ruby's
    // `case x; when 1; when 2; end`, Go's `switch` and Rust's `match`
    // at 2 (measured).
    //
    // Expected values come from cyclomatic, which this fix did not move:
    // every row sits at `cyclomatic - 1`. Paths only one row exercises
    // (§11): `case_default` the free `_ ->`, `case_guard` a guarded
    // clause's flat one beside its `>`, `rescue_in` a sole pattern that
    // scores itself (the `in` arm), `rescue_alias` a sole pattern the
    // clause slot pays for, `catch_two` a multi-pattern clause, `recv` a
    // `receive`'s `after` timeout clause, and `with_else` the `else` of
    // a `with`, whose clauses pay rather than a Rule 5 `else`. Its `<-`
    // clause pays one more since #1535, in both metrics.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_clause_constructs_pay_per_clause() {
        check_func_space::<ElixirParser, _>(
            "defmodule Foo do
  def case2(x) do
    case x do
      1 -> :a
      2 -> :b
    end
  end
  def case_default(x) do
    case x do
      1 -> :a
      2 -> :b
      _ -> :c
    end
  end
  def case_guard(x) do
    case x do
      y when y > 0 -> :a
      _ -> :b
    end
  end
  def with_else(x) do
    with {:ok, a} <- g(x) do
      a
    else
      {:error, e} -> e
      _ -> nil
    end
  end
  def recv(x) do
    receive do
      {:a, y} -> y
      {:b, z} -> z
    after
      100 -> x
    end
  end
  def rescue_in() do
    try do
      g()
    rescue
      e in RuntimeError -> e
    end
  end
  def rescue_alias() do
    try do
      g()
    rescue
      RuntimeError -> 1
    end
  end
  def catch_two() do
    try do
      g()
    catch
      :exit, r -> r
    end
  end
end
",
            "foo.ex",
            |space| {
                assert_members_score(
                    &space.spaces[0],
                    &[
                        ("case2", 2, 3),
                        ("case_default", 2, 3),
                        ("case_guard", 2, 3),
                        ("with_else", 2, 3),
                        ("recv", 3, 4),
                        ("rescue_in", 1, 2),
                        ("rescue_alias", 1, 2),
                        ("catch_two", 1, 2),
                    ],
                );
            },
        );
    }

    // A multi-clause anonymous fn dispatches like a `case`, less its head
    // clause, which is the closure's definition (#776): `fn x -> x end`
    // has no decision and `fn 0 -> :a; _ -> :b end` one — the trailing
    // `_ ->` included, since the head already took the free path.
    // Expected: each total equals the closure's cyclomatic decisions.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_multi_clause_fn_pays_after_its_head() {
        for (source, conditions) in [
            ("f = fn x -> x end\n", 0),
            ("f = fn 0 -> :a; _ -> :b end\n", 1),
            ("f = fn 0 -> :a; 1 -> :b; _ -> :c end\n", 2),
        ] {
            let metrics =
                metrics_verbatim(LANG::Elixir, source.as_bytes(), MetricsOptions::default());
            assert_eq!(metrics.abc.conditions_sum(), conditions, "{source}");
        }
    }

    // A typespec's function type (`(any -> any)`) is a `stab_clause` too,
    // under a parenthesised `block`, and is type syntax with no decision
    // behind it. Cyclomatic counted each one; the shared clause gate
    // would have carried that into ABC (#1531). Expected: nothing but the
    // unit's base path, as for the typespec `when` in
    // `elixir_typespec_when_is_not_a_guard`.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_typespec_function_type_is_not_a_clause() {
        let metrics = metrics_verbatim(
            LANG::Elixir,
            b"@spec f(list, (any -> any)) :: list\n@type cb :: (integer, integer -> boolean)\n",
            MetricsOptions::default(),
        );
        assert_eq!(metrics.abc.conditions_sum(), 0);
        assert_eq!(metrics.cyclomatic.cyclomatic_sum(), 1);
    }

    // The keyword form of each clause construct holds its clauses in a
    // parenthesised `block` under a `do:` / `else:` / `rescue:` pair, the
    // shape a typespec function type also has. Excluding `block` for the
    // typespec dropped every keyword-form clause (`ck` read 1/4, and `rk`
    // 0/3); each `*k` row must equal its `*b` block-form twin, `dk`'s
    // `true ->` included (it was a decision in the keyword form).
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_keyword_form_clauses_match_block_form() {
        let src = "defmodule M do
  def ck(x), do: case(x, do: (1 -> :a; 2 -> :b; 3 -> :c))
  def cb(x) do
    case x do
      1 -> :a
      2 -> :b
      3 -> :c
    end
  end
  def dk(x), do: cond(do: (x > 1 -> :a; x < 0 -> :b; true -> :c))
  def db(x) do
    cond do
      x > 1 -> :a
      x < 0 -> :b
      true -> :c
    end
  end
  def rk(), do: receive(do: ({:a, y} -> y; {:b, z} -> z))
  def rb() do
    receive do
      {:a, y} -> y
      {:b, z} -> z
    end
  end
  def tk(), do: try(do: g(), rescue: (e in RuntimeError -> e; _ -> 2))
  def tb() do
    try do
      g()
    rescue
      e in RuntimeError -> e
      _ -> 2
    end
  end
  def wk(x), do: with({:ok, a} <- x, do: a, else: ({:error, e} -> e; _ -> 0))
  def wb(x) do
    with {:ok, a} <- x do
      a
    else
      {:error, e} -> e
      _ -> 0
    end
  end
end
";
        assert_fixture_spells::<ElixirParser>(
            src,
            "foo.ex",
            &[
                (Elixir::Block as u16, 5, "the five keyword-form sections"),
                (Elixir::StabClause as u16, 24, "clauses, 12 per spelling"),
            ],
        );
        check_func_space::<ElixirParser, _>(src, "foo.ex", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    ("ck", 3, 4),
                    ("cb", 3, 4),
                    ("dk", 2, 3),
                    ("db", 2, 3),
                    ("rk", 2, 3),
                    ("rb", 2, 3),
                    ("tk", 1, 2),
                    ("tb", 1, 2),
                    ("wk", 2, 3),
                    ("wb", 2, 3),
                ],
            );
        });
    }

    // Fitzpatrick Rule 5 counts the `else` of an `if` / `unless` (#1531),
    // in both of Elixir's spellings. Expected values are the twins':
    // Ruby's `if b … else … end`, Java's `if (b) {} else {}`, Python's
    // and Go's each score 2 against cyclomatic 2 (measured), one over
    // parity by the documented `else` arm. `kw_other` is the control
    // that the `else:` key is read only on an `if` / `unless`: on any
    // other call it is an ordinary keyword argument.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_if_else_pays_rule_5() {
        check_func_space::<ElixirParser, _>(
            "defmodule Foo do
  def block(b) do
    if b do
      1
    else
      2
    end
  end
  def kw(b), do: if(b, do: 1, else: 2)
  def unless_block(b) do
    unless b do
      1
    else
      2
    end
  end
  def cmp(x) do
    if x > 5 do
      1
    else
      2
    end
  end
  def no_else(b) do
    if b do
      1
    end
  end
  def kw_no_else(b), do: if(b, do: 1)
  def kw_other(b), do: g(b, else: 1)
end
",
            "foo.ex",
            |space| {
                assert_members_score(
                    &space.spaces[0],
                    &[
                        ("block", 2, 2),
                        ("kw", 2, 2),
                        ("unless_block", 2, 2),
                        ("cmp", 2, 2),
                        ("no_else", 1, 2),
                        ("kw_no_else", 1, 2),
                        ("kw_other", 0, 1),
                    ],
                );
            },
        );
    }

    // `for` is a comprehension/loop, NOT in the issue's condition
    // list. It is still a Call so it contributes one branch, but no
    // condition.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_for_is_branch_not_condition() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(xs) do\n    for x <- xs, do: x * 2\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Mixed shape, verified by hand: defmodule Call + def Call + if Call
    // + Call to side_effect/0 + assignment `x = 1` + comparison `x > 0`.
    // - Assignments: `x = 1` → A = 1.
    // - Branches: `defmodule` and `def` are declarative and excluded;
    //   `if` Call + `side_effect()` Call → 2 Calls, plus 0 `|>` → B = 2.
    // - Conditions: `x > 0` → 1; the `if` predicate slot it fills adds
    //   nothing more (#1527) → C = 1.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_mixed_abc() {
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f do\n    x = 1\n    if x > 0 do\n      side_effect()\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_unary_conditions_in_chain() {
        // Fitzpatrick Rule 9 (issue #557): each bare boolean operand of a
        // `&&` / `||` chain is one condition. For `if a && b || c` the
        // walker adds a, b, c → 3, and the `if` predicate slot adds
        // nothing because the chain already scored it (#1527). expected:
        // 3, as Ruby and Java score the same `if`, against cyclomatic 4
        // (base 1 + if + && + ||).
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(a, b, c) do\n    if a && b || c do\n      IO.puts(\"x\")\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    // Elixir spells negation two ways and the operand peel once
    // recognised only `!`, so `a && not b` scored 3 where `a && !b`
    // scored 4 — the `not` operand reached no terminal and vanished.
    // Both forms now read the same. `not` is the stricter of the two (it
    // raises on a non-boolean operand where `!` accepts any truthy
    // value), so it is at least as good a proof that what it wraps is
    // boolean, which is all the walker's flag claims.
    //
    // Both members in one fixture because the claim is that they agree:
    // asserting either alone says nothing about the pair (§11), and a
    // shared `check_metrics` total could not tell 3 + 4 from 4 + 3.
    //
    // `assert_members_score` rather than the parity-asserting sibling:
    // each member scores its two `&&` operands and nothing for the `if`
    // slot the chain fills (#1527) — 2 against cyclomatic
    // `base 1 + if + &&` = 3, as Ruby's `if a && !b` does.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_keyword_not_negates_like_bang() {
        check_func_space::<ElixirParser, _>(
            "defmodule Foo do\n  def kw(a, b) do\n    if a && not b do\n      IO.puts(\"x\")\n    end\n  end\n  def bang(a, b) do\n    if a && !b do\n      IO.puts(\"x\")\n    end\n  end\nend\n",
            "foo.ex",
            |space| {
                assert_members_score(&space.spaces[0], &[("kw", 2, 3), ("bang", 2, 3)]);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_comparison_operands_add_nothing() {
        // Isolation check: comparison operands of a `&&` chain are nested
        // `binary_operator` nodes, not bare boolean leaves, so the walker
        // adds nothing. expected: 2 = `>` (1) + `>` (1); the `&&` walker
        // and the `if` slot the chain fills contribute 0 (#1527).
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(x, y) do\n    if x > 0 && y > 0 do\n      IO.puts(\"x\")\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_keyword_and_or_chain_counts_operands() {
        // The keyword forms `and` / `or` get the same Rule 9 treatment as
        // `&&` / `||`. expected: 3 = operands a, b, c; the `if` slot the
        // chain fills adds nothing (#1527).
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def f(a, b, c) do\n    if a and b or c do\n      IO.puts(\"x\")\n    end\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
            },
        );
    }

    // Sigil delimiter choice must not move ABC: `~s<hi>` and `~s(hi)`
    // are the same value spelled differently, but the `<` / `>`
    // delimiter tokens carry the comparison kind ids, so the unguarded
    // condition arm scored `~s<hi>` as 2 conditions and `~s(hi)` as 0.
    // The parent-is-`Sigil` guard (mirroring the Halstead getter's,
    // #1256) suppresses the delimiter case. expected, for each
    // spelling: A = 1 (the `x =` pattern match), B = 0 (a bare sigil
    // is not a `Call` node — verified by AST dump: `binary_operator`
    // wrapping `identifier`, `=`, `sigil`), C = 0 (no comparison, no
    // guard, no keyword Call).
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_sigil_delimiter_choice_is_abc_invariant() {
        for src in ["x = ~s<hi>\n", "x = ~s(hi)\n"] {
            check_metrics::<ElixirParser>(src, "foo.ex", |metric| {
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
            });
        }
    }

    // Control for the guard above: `<` *outside* a sigil is a genuine
    // comparison and must keep counting even with a `<`-delimited
    // sigil in the same unit. expected: A = 2 (`x =`, `y =`), C = 1
    // (only `a < b`; the sigil's `<` / `>` delimiters are guarded).
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_lt_comparison_still_counts_beside_sigil() {
        check_metrics::<ElixirParser>("x = ~s<hi>\ny = a < b\n", "foo.ex", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 2);
            assert_eq!(metric.abc.conditions_sum(), 1);
        });
    }

    // #1297's sweep converted six grammars from a denylist of
    // non-comparison `<` / `>` parents to an allowlist and recorded
    // Elixir as already covered by its sigil guard. It was not: an
    // operator *named* rather than applied — the capture `&</2` and the
    // qualified call `Kernel.<(a, b)` — puts the bare token under an
    // `operator_identifier`, which no denylist entry mentioned, so each
    // scored a condition against zero decisions. Same shape as the C#
    // `operator <` declaration the sweep did fix.
    //
    // Each function is its own space and its own row, so a fix that
    // reached one spelling and not the other fails here. `max/2` is the
    // control: a qualified call whose name is not an operator was
    // always 0, so a guard that merely stopped counting `<` everywhere
    // would pass this row and fail the two below it.
    //
    // The six equality and ordering tokens share the gate (#1531): they
    // sat on an ungated arm, so `&==/2` and `Kernel.==(a, b)` scored a
    // condition each and `caps` five. `eq` is their applied control.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_operator_identifier_is_not_a_condition() {
        check_func_space::<ElixirParser, _>(
            "defmodule M do\n\
               def asc(l), do: Enum.sort(l, &</2)\n\
               def lt(a, b), do: Kernel.<(a, b)\n\
               def big(a, b), do: Kernel.max(a, b)\n\
               def cmp(a, b), do: a < b\n\
               def eq_cap(l), do: Enum.sort(l, &==/2)\n\
               def eq_remote(a, b), do: Kernel.==(a, b)\n\
               def caps(), do: {&===/2, &!=/2, &!==/2, &<=/2, &>=/2}\n\
               def eq(a, b), do: a == b\n\
             end\n",
            "foo.ex",
            |space| {
                let module = &space.spaces[0];
                let scored: Vec<(String, u64)> = module
                    .spaces
                    .iter()
                    .map(|f| {
                        (
                            f.name.clone().unwrap_or_default(),
                            f.metrics.abc.conditions(),
                        )
                    })
                    .collect();
                assert_eq!(
                    scored,
                    vec![
                        ("asc".to_owned(), 0),
                        ("lt".to_owned(), 0),
                        ("big".to_owned(), 0),
                        ("cmp".to_owned(), 1),
                        ("eq_cap".to_owned(), 0),
                        ("eq_remote".to_owned(), 0),
                        ("caps".to_owned(), 0),
                        ("eq".to_owned(), 1),
                    ],
                );
            },
        );
    }

    // ----- C++ -----

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_empty_unit_zero() {
        // No code → A=B=C=0. Wires up the trait and exercises the
        // per-language compute reachability.
        check_metrics::<CppParser>("", "empty.cpp", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_plain_and_compound_assignments_count() {
        // `int x = 0` is an `init_declarator` carrying an `=` token
        // and counts as 1 (post-#393: the literal Fitzpatrick rule
        // counts every `=` operator, matching the JS impl's
        // `let x = 5` treatment). `x = 5`, `x += 2`, `x = 7` all
        // parse as `assignment_expression` → 3. Total A = 4.
        check_metrics::<CppParser>(
            "void f() { int x = 0; x = 5; x += 2; x = 7; }",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 4);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_increment_and_decrement_count_as_assignment() {
        // `x++` / `--x` / prefix and postfix forms each parse as
        // `update_expression` and count as 1 assignment per
        // Fitzpatrick — 4. `int x = 0` (init_declarator with `=`)
        // adds 1 (post-#393). Total A = 5.
        check_metrics::<CppParser>(
            "void f() { int x = 0; x++; --x; ++x; x--; }",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 5);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_init_declarators_count_as_assignments() {
        // Issue #393 regression: `int a=1;`, `int b=2;`, `int c=a+b;`,
        // `int d=0;` are all `init_declarator` nodes with `=` → 4
        // assignments. `d=5;` is one plain `assignment_expression`,
        // `d+=1;` is one compound. Total A = 4 + 1 + 1 = 6.
        check_metrics::<CppParser>(
            "void f() { int a=1; int b=2; int c=a+b; int d=0; d=5; d+=1; }",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 6);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_declaration_without_initializer_does_not_count() {
        // `int a;` parses as a plain declarator inside `declaration`,
        // NOT an `init_declarator` (the latter only appears when an
        // initializer is present). Regression test for issue #393:
        // un-initialised declarations contribute zero to A.
        check_metrics::<CppParser>("void f() { int a; a = 5; }", "foo.cpp", |metric| {
            // Only `a = 5` (assignment_expression) → A = 1.
            assert_eq!(metric.abc.assignments_sum(), 1);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_init_declarator_brace_paren_init_does_not_count() {
        // `init_declarator` has two grammar forms: `declarator = value`
        // (the `=` form) and `declarator argument_list_or_initializer_list`
        // (the `int x(5);` / `int x{5};` direct-init forms). Only the
        // first form contains an `=` token, so only it should count.
        // Regression test pinning that distinction so that
        // refactorings of the init_declarator arm don't accidentally
        // start counting direct-init too.
        check_metrics::<CppParser>(
            "void f() { int x(5); int y{7}; x = 1; }",
            "foo.cpp",
            |metric| {
                // Only `x = 1` (assignment_expression) → A = 1.
                assert_eq!(metric.abc.assignments_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_calls_are_branches() {
        // Free call + member-fn call (parses as `call_expression` with
        // a `field_expression` callee) + `new` allocation. All three
        // are branches → B = 3. `auto* p = new int(5)` is also an
        // `init_declarator` with `=` so it contributes one assignment
        // (post-#393); the snapshot pins that magnitude.
        check_metrics::<CppParser>(
            "struct S { void m(); }; void g(); void f() { g(); S s; s.m(); auto* p = new int(5); }",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 3);
                assert_eq!(metric.abc.assignments_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_comparisons_count_conditions() {
        // `<`, `>`, `<=`, `>=`, `==`, `!=`, and the C++20 spaceship
        // `<=>` each contribute one condition. The `||` short-
        // circuits add 0 (Fitzpatrick Rule 5, issue #395). Six
        // comparisons in the `||` chain plus `<=>` (1) plus the
        // outer `== 0` (1) → C = 8.
        check_metrics::<CppParser>(
            "#include <compare>\n\
             bool f(int a, int b) {\n\
                 return a < b || a > b || a <= b || a >= b || a == b || a != b || (a <=> b) == 0;\n\
             }\n",
            "foo.cpp",
            |metric| {
                // `<`, `>`, `<=`, `>=`, `==`, `!=` → 6 comparisons
                // from the chained `||` expression. `(a <=> b) == 0`
                // adds the spaceship `<=>` (1) + the outer `== 0`
                // (1) → 8 total. The six `||` short-circuits add 0
                // (Fitzpatrick Rule 5; issue #395).
                assert_eq!(metric.abc.conditions_sum(), 8);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_short_circuit_ops_not_counted_directly() {
        // `&&` and `||` do NOT count on their own (see the
        // module-level `Stats` doc-comment; #395). Phase-2 walker
        // counts each operand of a logical chain once (#403), but
        // when every operand is itself a relational expression
        // (`a == b`, `a > 0`, `b < 0`) the walker doesn't add
        // anything on top of the existing comparison-token tally
        // — a relational sub-expression scores itself
        // (`cpp_condition_scores_itself`), so its chain slot pays
        // nothing on top.
        check_metrics::<CppParser>(
            "bool f(int a, int b) { return a == b && a > 0 || b < 0; }",
            "foo.cpp",
            |metric| {
                // == 1, > 1, < 1; the walker on && and || finds
                // BinaryExpression operands (not terminal-bool) and
                // adds nothing. Total: 3.
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_generic_brackets_not_conditions() {
        // `<` / `>` in `std::vector<int>` are `template_argument_list`
        // delimiters, NOT comparison operators. The `binary_expression`
        // parent check must filter them out → C = 0.
        check_metrics::<CppParser>(
            "#include <vector>\nstd::vector<int> f() { return std::vector<int>{}; }",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_else_and_ternary_count_conditions() {
        // `if (cond) ... else ...` + ternary `cond ? a : b`. The
        // `if`-keyword is NOT a condition (its condition is the
        // comparison inside, which counts separately). `else` adds 1,
        // `?` adds 1. Two comparisons (`a > b`, `b < 0`) → 2. Total = 4.
        check_metrics::<CppParser>(
            "int f(int a, int b) {\n\
                 if (a > b) { return a; } else { return b; }\n\
                 return (b < 0) ? -b : b;\n\
             }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Issue #1102. A ternary's condition and both branch operands are
    // Fitzpatrick Rule 9 unary conditions, exactly as `java_walk_ternary`
    // has always counted them. Before the fix the C family scored
    // `a ? !b : !c` as 1 — the `?` token alone — against Java's 4.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_ternary_operand_slots_count_as_unary_conditions() {
        // `?` (1) + condition `a` (1) + `!b` (1) + `!c` (1) = 4.
        check_metrics::<CppParser>("void f() { x = a ? !b : !c; }", "foo.cpp", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 4);
        });
        // No-double-count pin: `?` (1) + `>` (1) = 2, unchanged by the
        // fix. The parenthesised condition peels to a
        // `binary_expression`, which scores itself, and
        // neither branch is negated — the `!` is the type-free proxy for
        // "this operand is boolean", so an unnegated branch contributes
        // nothing.
        check_metrics::<CppParser>("void f() { x = (a > 0) ? b : -b; }", "foo.cpp", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
        });
        // Nested: outer `?` (1) + outer condition `a` (1) + inner `?`
        // (1) + inner condition `b` (1) = 4. The outer consequence is
        // the inner ternary — which scores itself, and is no
        // paren / `!` wrapper — so it adds nothing on its own and the
        // inner one is reached by the walk, not by descent.
        check_metrics::<CppParser>("void f() { x = a ? b ? c : d : e; }", "foo.cpp", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 4);
        });
        // A negated *condition* is the input where the slot must peel a
        // `!`: `cpp_wrapper_operand` takes `!a` down to `a`, which does
        // not score itself, so the slot pays once. Every other condition
        // fixture in this file wraps a comparison, which scores itself
        // and so pays 0 from the slot. `?` (1) + `!a` (1) = 2.
        check_metrics::<CppParser>("void f() { x = !a ? b : c; }", "foo.cpp", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
        });
    }

    // The GNU short-ternary `a ?: b` elides the consequence, so the
    // C-family grammar marks that field optional and the alternative
    // lands at child(3) rather than child(4). Addressing the operand
    // slots by grammar field name — never by index — is what keeps `!b`
    // counted here; a fixed `child(4)` reads `None` and scores 2.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_elided_ternary_consequence_still_walks_the_alternative() {
        // `?` (1) + condition `a` (1) + `!b` (1) = 3.
        check_metrics::<CppParser>("void f() { x = a ?: !b; }", "foo.cpp", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 3);
        });
    }

    // `cpp_walk_ternary` is shared by the C, ObjC, and Mozcpp ABC impls
    // exactly as `cpp_count_condition` is, so each needs its own
    // dispatcher arm. Mozcpp owns no file extension and so gets no
    // integration-snapshot coverage at all — this parity assertion is
    // its only guard.
    //
    // The expected value is *derived from the C++ run*, not hardcoded,
    // so the four languages cannot silently drift apart if the C++
    // expectation ever legitimately moves.
    #[cfg(all(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
    #[test]
    fn c_family_ternary_operand_slots_agree_with_cpp() {
        #[cfg(any(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
        const SRC: &str = "void f() { x = a ? !b : !c; }\n";
        let conditions = abc_conditions;

        let cpp = conditions(LANG::Cpp, SRC);
        // Non-degenerate: a zeroed reference would make every
        // comparison below vacuous.
        assert_eq!(cpp, 4, "C++ reference value for `a ? !b : !c`");

        assert_eq!(conditions(LANG::C, SRC), cpp, "C must match C++");
        assert_eq!(conditions(LANG::Mozcpp, SRC), cpp, "Mozcpp must match C++");
        assert_eq!(
            conditions(
                LANG::Objc,
                "@implementation Foo\n\
                 - (void)bar {\n\
                     x = a ? !b : !c;\n\
                 }\n\
                 @end\n",
            ),
            cpp,
            "ObjC must match C++"
        );
    }

    // Issue #1276, C-family half. `cpp_walk_for_statement` is the
    // `for` header's counterpart to the `if` / `while` arms: the slot
    // is a bare expression rather than a `condition_clause`, read by
    // the same slot rule `cpp_walk_ternary` uses. Every fixture is a
    // shape only that walker can classify —
    // a comparison-shaped condition proves nothing, the `<` token arm
    // counts it either way (grammar-dispatch §11).
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_for_condition_slot_counts_unary_conditions() {
        // Bare identifier: the whole condition, no operator token.
        check_metrics::<CppParser>("void f(int a) { for (; a; ) {} }", "foo.cpp", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 1);
        });
        // Negation: the slot peels the `!` (`cpp_wrapper_operand`) and
        // pays for the operand beneath it.
        check_metrics::<CppParser>("void f(int a) { for (; !a; ) {} }", "foo.cpp", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 1);
        });
        // Parentheses: counted because the slot peels them
        // (`cpp_wrapper_operand`) — the path #1276 found dead.
        check_metrics::<CppParser>("void f(int a) { for (; (a); ) {} }", "foo.cpp", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 1);
        });
        // No-double-count pin: the `<` token arm already counted this
        // shape before the fix and the walker must not add a second.
        // The two assignments confirm the header parsed as the
        // three-clause form rather than degenerating.
        check_metrics::<CppParser>(
            "void f(int n) { for (int i = 0; i < n; i++) {} }",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
        // Empty condition: no `condition` field, no decision, zero.
        check_metrics::<CppParser>("void f() { for (;;) { break; } }", "foo.cpp", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 0);
        });
    }

    // `cpp_walk_for_statement` is shared by the C, ObjC and Mozcpp ABC
    // impls the way `cpp_walk_ternary` is, so each needs its own
    // dispatcher arm — and Mozcpp, which owns no file extension, has no
    // integration-snapshot coverage at all, making this its only guard.
    // The expected value is derived from the C++ run rather than
    // hardcoded, so the four cannot silently drift apart.
    #[cfg(all(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
    #[test]
    fn c_family_for_condition_slot_agrees_with_cpp() {
        #[cfg(any(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
        const SRC: &str = "void f(int a) { for (; !a; ) {} }\n";
        let conditions = abc_conditions;

        let cpp = conditions(LANG::Cpp, SRC);
        // Non-degenerate: a zeroed reference makes every comparison
        // below vacuous.
        assert_eq!(cpp, 1, "C++ reference value for `for (; !a; )`");

        assert_eq!(conditions(LANG::C, SRC), cpp, "C must match C++");
        assert_eq!(conditions(LANG::Mozcpp, SRC), cpp, "Mozcpp must match C++");
        assert_eq!(
            conditions(
                LANG::Objc,
                "@implementation Foo\n\
                 - (void)bar {\n\
                     for (; !a; ) {}\n\
                 }\n\
                 @end\n",
            ),
            cpp,
            "ObjC must match C++"
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_switch_cases_count_default_excluded() {
        // `case 1`, `case 2` → 2 conditions. `default` is intentionally
        // excluded (the unconditional fallthrough, mirroring cyclomatic's
        // `Case`-only count). Since #469 every C-family language —
        // Java, C#, Groovy, JS, TS — agrees on this; C++ already did.
        // C = 2.
        check_metrics::<CppParser>(
            "void f(int x) {\n\
                 switch (x) {\n\
                     case 1: break;\n\
                     case 2: break;\n\
                     default: break;\n\
                 }\n\
             }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_try_catch_count_conditions() {
        // `try` and `catch` each add one condition (Fitzpatrick's rule;
        // Java's impl above counts them too).
        check_metrics::<CppParser>(
            "void f() { try { } catch (int) { } catch (...) { } }",
            "foo.cpp",
            |metric| {
                // 1 `try` + 2 `catch` arms = 3.
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_complex_function_abc() {
        // Mixed-shape regression: assignments, calls, conditions,
        // ternary, switch, new. Verified by hand:
        // - assignments: `int x = 0` (init_declarator with `=`),
        //   `x = 5`, `x += 2`, `x++`, `x = (a > b) ? a : b`, `x = b`,
        //   `auto* p = new int(5)` (init_declarator with `=`) → A = 7
        //   (post-#393: every `=` in an init_declarator counts).
        // - branches: `f(a, b)` self-call + `new int(5)` → B = 2.
        // - conditions: `a == b` (1) + `a > 0` (1) inside the if;
        //   `&&` itself is NOT a condition (Fitzpatrick Rule 5,
        //   issue #395). `a > b` (1) + `?` (1) in the ternary.
        //   `else` (1, from the `else if` keyword) + `a < b` (1)
        //   in the else-if. `!x` contributes 1 via the unary-
        //   conditional walker (Fitzpatrick Rule 9, issue #403):
        //   the `||` walker treats `!x` as a unary boolean operand
        //   and counts the wrapped Identifier once. `case 1`,
        //   `case 2` → 2. `default` excluded. Total C = 9.
        check_metrics::<CppParser>(
            "int f(int a, int b) {\n\
                 int x = 0;\n\
                 x = 5;\n\
                 x += 2;\n\
                 x++;\n\
                 if (a == b && a > 0) {\n\
                     x = (a > b) ? a : b;\n\
                 } else if (a < b || !x) {\n\
                     x = b;\n\
                 }\n\
                 switch (x) {\n\
                     case 1: break;\n\
                     case 2: break;\n\
                     default: break;\n\
                 }\n\
                 auto* p = new int(5);\n\
                 return f(a, b);\n\
             }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 7);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_if_multiple_conditions() {
        // Fitzpatrick Rule 9 walker (issue #403): each operand of a
        // `&&` / `||` chain is one condition.
        check_metrics::<CppParser>(
            "void f(bool a, bool b, bool c, bool d) {\n\
             \x20   if (a || b || c || d) {}        // +4c\n\
             \x20   if (a && b && c) {}             // +3c\n\
             \x20   if (!a && !b) {}                // +2c\n\
             }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_while_and_do_while_conditions() {
        // Exercise both the WhileStatement and DoStatement arms via
        // the walker on the `&&` / `||` tokens inside their parens.
        check_metrics::<CppParser>(
            "void f(bool a, bool b) {\n\
             \x20   while (a || b) {}              // +2c\n\
             \x20   do {} while (a && !b);         // +2c\n\
             }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_if_constexpr_condition_counts() {
        // Regression for the code-review finding: C++ `if constexpr
        // (cond)` puts the `constexpr` keyword at child(1) and the
        // condition_clause at child(2). Pre-fix, the dispatcher used
        // child(1) and counted zero conditions for the `constexpr`
        // form. The fix uses `child_by_field_name("condition")`
        // which returns the condition_clause regardless of the
        // optional `constexpr` keyword.
        check_metrics::<CppParser>(
            "template <int N> void f() {\n\
             \x20   if constexpr (true) { }      // +1c\n\
             \x20   if (false) { }               // +1c\n\
             }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_cast_expression_in_logical_chain_counts() {
        // Regression for findings.md round-2 #1 (C++):
        // `if ((bool)ptr && ready) {}` had the `||` walker missing
        // the `(bool)ptr` operand because `CastExpression` was not
        // in the former `cpp_bool_terminal_kinds!()`. Mirrors C#'s
        // former `csharp_bool_terminal_kinds!()`, which listed
        // `CastExpression` (lesson 19, #372).
        check_metrics::<CppParser>(
            "void f(void* ptr, bool ready) { if ((bool)ptr && ready) { } }\n",
            "foo.cpp",
            |metric| {
                // `&&` walker counts both operands: `(bool)ptr` (1)
                // and `ready` (1). Total: 2.
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_qualified_identifier_condition_counts() {
        // Regression for findings.md #3 (C++): tree-sitter-cpp emits
        // `qualified_identifier` under four kind_ids (573..576) per
        // the production-rule path; runtime kind for `ns::flag` is
        // 574 (`QualifiedIdentifier2`). Pre-fix the
        // former `cpp_bool_terminal_kinds!()` macro listed neither the
        // primary nor any alias, so `if (n::flag) {}` reported zero
        // conditions. The slot now pays for every variant, since none
        // scores itself (lesson #2).
        check_metrics::<CppParser>(
            "namespace n { extern bool flag; }\n\
             void f() { if (n::flag) { } }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_if_boolean_literal_condition() {
        check_metrics::<CppParser>(
            "void f() {\n\
             \x20   if (true) {}                 // +1c\n\
             \x20   if (!false) {}               // +1c\n\
             \x20   while (true) {}              // +1c\n\
             \x20   do {} while (false);         // +1c\n\
             }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_methods_arguments_with_conditions() {
        check_metrics::<CppParser>(
            "void f(bool a, bool b) {\n\
             \x20   m(a, b);                     // +1b\n\
             \x20   m(!a, !b);                   // +1b +2c\n\
             }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_return_with_conditions() {
        check_metrics::<CppParser>(
            "bool m1(int z) { return !(z >= 0); }\n\
             bool m2(bool x) { return (((!x))); }\n\
             bool m3(bool x, bool y) { return x && y; }\n",
            "foo.cpp",
            |metric| {
                // m1: !(z >= 0) → `>=` (1). `!` wraps a paren'd
                //     BinaryExpression — inspect_container reaches
                //     the inner BinaryExpression and stops, no
                //     walker count. +1.
                // m2: (((!x))) → ReturnStatement → inspect_container
                //     unwraps three parens + one unary → reaches `x`
                //     in has_boolean_content=true (seeded by the
                //     unary `!`). +1.
                // m3: x && y → `&&` walker counts both → +2.
                // Sum: 1 + 1 + 2 = 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // #1547: `co_return` is a coroutine's `return`, so ABC reads its value
    // the same way. Each row's expected value is its `return` twin's. A
    // `co_yield` hands a value back without returning, as the JS family's
    // `yield` does, and scores no value slot either.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    fn assert_co_return_scores_like_return(lang: LANG) {
        let source = |body: &str| format!("task f(bool a) {{ {body} }}\n");
        let rows = [
            ("co_return !a;", "return !a;", 1),
            ("co_return /*c*/ !a;", "return /*c*/ !a;", 1),
            ("co_return a;", "return a;", 0),
            ("co_return;", "return;", 0),
        ];
        for (coroutine, twin, expected) in rows {
            assert_eq!(
                abc_conditions(lang, &source(twin)),
                expected,
                "{lang:?} `{twin}`"
            );
            assert_eq!(
                abc_conditions(lang, &source(coroutine)),
                expected,
                "{lang:?} `{coroutine}`"
            );
        }
        assert_eq!(
            abc_conditions(lang, &source("co_yield !a;")),
            0,
            "{lang:?} co_yield"
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_co_return_value_scores_like_return_1547() {
        assert_co_return_scores_like_return(LANG::Cpp);
    }

    // Mozcpp owns no file extension, so this is its only coverage.
    #[cfg(feature = "mozcpp")]
    #[test]
    fn mozcpp_co_return_value_scores_like_return_1547() {
        assert_co_return_scores_like_return(LANG::Mozcpp);
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_short_circuit_with_boolean_literal_operand() {
        // `a && true` reports 2 conditions: one for the identifier
        // operand, one for the `True` literal operand.
        check_metrics::<CppParser>(
            "bool f(bool a) { return a && true; }\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_empty_unit_zero() {
        // No code → A=B=C=0. Wires up the trait and exercises the
        // per-language compute reachability.
        check_metrics::<JavascriptParser>("", "empty.js", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_plain_and_compound_assignments_count() {
        // `let` / `var` declarations behave like TypeScript: only a
        // `const` initializer is suppressed. So `let x = 0` does count as
        // A=+1; only `const PI = 3.14` would be elided. Plain `x = 5`,
        // `x += 2`, `x = 7` all count → A = 4 total here.
        check_metrics::<JavascriptParser>(
            "function f() { let x = 0; x = 5; x += 2; x = 7; }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 4);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_const_initializer_not_assignment() {
        // `const PI = 3.14` must NOT count as an assignment — its `=`
        // initialises a `const` binding. `let x = 1` and `var y = 2`
        // still count (matches the TS impl: only `const` suppresses).
        check_metrics::<JavascriptParser>(
            "function f() { const PI = 3.14; let x = 1; var y = 2; x = 9; }",
            "foo.js",
            |metric| {
                // `const PI` suppressed; `let x = 1`, `var y = 2`,
                // `x = 9` all count → A = 3.
                assert_eq!(metric.abc.assignments_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_asi_const_does_not_suppress_later_assignments() {
        // The issue #1277 reproducer verbatim. JavaScript half of the
        // cluster documented at
        // `typescript_asi_const_does_not_suppress_later_assignments`.
        check_metrics::<JavascriptParser>(
            "function f() {
                const a = 1
                x = 2
                return x
            }",
            "foo.js",
            |metric| {
                // Pre-#1277 this reported 0; the semicolon-terminated
                // spelling reported 1.
                assert_eq!(metric.abc.assignments_sum(), 1);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_nested_arrow_const_does_not_leak() {
        // The ASI leak beside a nested space: the arrow body opens its
        // own space, so `y = 1` was always counted there, but
        // `const f = () => …` has no `;`, so `h`'s sentinel stayed live
        // and suppressed `z = 2`. The stack was per-space state that
        // `Stats::merge` never carried, so this is the terminator defect
        // and not a second route.
        check_metrics::<JavascriptParser>(
            "function h() {
                const f = () => { y = 1 }
                z = 2
            }",
            "foo.js",
            |metric| {
                // `y = 1` and `z = 2`; the `const` initializer is
                // suppressed. Pre-#1277: 1.
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_non_declarator_equals_still_count() {
        // An `=` that does not belong to a `const` declarator is always
        // an assignment: a class `field_definition` initializer, a
        // default-parameter `assignment_pattern`, and a destructured
        // parameter's defaults, whose climb crosses the same pattern
        // layers as a `const` pattern's but ends at `formal_parameters`.
        // A predicate that accepted any pattern ancestor as a declarator
        // would zero the last three.
        check_metrics::<JavascriptParser>(
            "class K { f = 1; g(p = 2, {q = 3} = {}) { let d = 4 } }",
            "foo.js",
            |metric| {
                // `f = 1`, `p = 2`, `q = 3`, `= {}`, `let d = 4`.
                assert_eq!(metric.abc.assignments_sum(), 5);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_const_initializer_value_assignments_still_count() {
        // An `=` inside a `const` initializer's *value* is an
        // `assignment_expression`: its climb reaches no pattern layer and
        // no declarator, so it counts. The pre-#1277 sentinel
        // blanket-suppressed every `=` between `const` and `;`, which is
        // the shape that moved the pdf.js corpus snapshots
        // (`const bbox = (this.data.rect = …)`).
        check_metrics::<JavascriptParser>(
            "function m(o, a, b) { const x = (o.p = 1); const y = a || (b = 2); }",
            "foo.js",
            |metric| {
                // `o.p = 1` and `b = 2`; the two `const` initializers are
                // suppressed. Pre-#1277: 0.
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_const_declarator_shapes_stay_suppressed() {
        // JavaScript half of
        // `typescript_const_declarator_shapes_stay_suppressed`.
        check_metrics::<JavascriptParser>(
            "function f(o, xs) {
                const a = 1, b = 2
                const {c = 5, d: {e = 6} = {}} = o
                const [g = 7, ...[h = 8]] = xs
                let i = 3
                var j = 4
                for (const x of xs) { k(x) }
            }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_increment_and_decrement_count_as_assignment() {
        // `x++` (post) and `--x` (pre) both update an lvalue and so
        // count as assignments. Combined with the `let x = 0`
        // initializer (which counts under the JS/TS rule — only `const`
        // suppresses), A = 3.
        check_metrics::<JavascriptParser>(
            "function f() { let x = 0; x++; --x; }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_calls_are_branches() {
        // `g(1)` is a `call_expression` → B = 1. `new Foo(2)` is a
        // `new_expression` → B = 1. Total B = 2.
        check_metrics::<JavascriptParser>(
            "function f() { g(1); new Foo(2); }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_comparisons_count_conditions() {
        // `==`, `===`, `!=`, `!==`, `<`, `>`, `<=`, `>=` each count
        // once. The `&&` / `||` short-circuit operators are NOT
        // counted as conditions in this impl (matches the TS
        // precedent — short-circuit ops are folded into the
        // surrounding `if` / control-flow arm, not separately).
        // Total C = 8.
        check_metrics::<JavascriptParser>(
            "function f(a, b) { return a == b && a === b && a != b && a !== b && a < b && a > b && a <= b && a >= b; }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 8);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // #1297 in the `js_abc_compute!` expansion, where `LT` / `GT` had
    // no gate at all: plain JavaScript has no generics, but
    // tree-sitter-javascript parses JSX unconditionally, so the same
    // seven tag brackets that
    // `tsx_jsx_elements_are_not_conditions` covers scored seven
    // conditions in a `.js` file too. Same fixture minus the type
    // annotations, same discriminating numbers: 8 pre-fix, 1 after.
    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_jsx_elements_are_not_conditions() {
        check_metrics::<JavascriptParser>(
            "function f(a, b) {
                if (a < b) { return <div className=\"x\"><span>hi</span></div>; }
                return <br />;
            }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                // Fixture-presence anchor: the `className="x"` attribute
                // `=` is this fixture's only assignment, so the test
                // fails if a later edit drops the JSX. Without it the
                // surviving `a < b` alone also scores 1, and the
                // conditions assertion would pass while proving nothing.
                assert_eq!(metric.abc.assignments_sum(), 1);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_number_truthy_condition_counts() {
        // Regression for #772: JS treats every non-zero number as
        // truthy, so `while (5)` and `x && 5` should each count their
        // numeric literal as a Fitzpatrick unary condition. Pre-fix
        // the former `javascript_bool_terminal_kinds!()` listed `True` /
        // `False` but omitted `Number`, so the walker dropped every numeric-
        // truthy operand (mirrors the Lua `Number` fix).
        check_metrics::<JavascriptParser>(
            "function f(x) { while (5) {} return x && 5; }",
            "foo.js",
            |metric| {
                // `while (5)` → Number literal (+1). `x && 5` → both
                // operands count: identifier `x` (+1), Number `5` (+1).
                // Total: 3.
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_number_truthy_condition_counts() {
        // Regression for #772: TS shares the JS truthy semantics. The
        // numeric *literal* `5` (kind `Number`) counts; the type-keyword
        // `number` (kind `Number2`, the `predefined_type`) must not —
        // see the former `typescript_bool_terminal_kinds!`.
        check_metrics::<TypescriptParser>(
            "function f(x: number) { while (5) {} return x && 5; }",
            "foo.ts",
            |metric| {
                // `while (5)` → +1; `x && 5` → `x` (+1) + `5` (+1).
                // Total: 3. The `: number` annotation contributes 0.
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_nullish_coalescing_counts_condition() {
        // `a ?? b` is one nullish-coalescing operator → C = 1.
        check_metrics::<JavascriptParser>(
            "function f(a, b) { return a ?? b; }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_else_ternary_case_default_try_catch() {
        // `else`, `?` (ternary), `case`, `try`, `catch` all count.
        // `default` is the unconditional fallthrough → +0 (#469).
        // With the comparisons:
        //   - `a > 0` → 1
        //   - `else` opens an else_clause → 1
        //   - `?` ternary → 1
        //   - the ternary's bare-identifier condition `a` → 1 (#1102)
        //   - `case 1` → 1
        //   - `default` → 0 (fallthrough, #469)
        //   - `try` + `catch` → 2
        // Total C = 7.
        check_metrics::<JavascriptParser>(
            "function f(a) { if (a > 0) {} else {} let x = a ? 1 : 2; switch (x) { case 1: break; default: break; } try { } catch (e) { } }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 7);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Issue #1102, JS-family half. See
    // `cpp_ternary_operand_slots_count_as_unary_conditions` for the
    // rule; the two families were behind Java by the same three units.
    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_ternary_operand_slots_count_as_unary_conditions() {
        // `?` (1) + condition `a` (1) + `!b` (1) + `!c` (1) = 4.
        check_metrics::<JavascriptParser>(
            "function f() { x = a ? !b : !c; }",
            "foo.js",
            |metric| assert_eq!(metric.abc.conditions_sum(), 4),
        );
        // No-double-count pin: `?` (1) + `>` (1) = 2, unchanged by the
        // fix — the parenthesised condition unwraps to a
        // `binary_expression` (not a boolean terminal) and neither
        // branch is negated.
        check_metrics::<JavascriptParser>(
            "function f() { x = (a > 0) ? b : -b; }",
            "foo.js",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
        // Nested: two `?` tokens plus the two bare-identifier
        // conditions = 4.
        check_metrics::<JavascriptParser>(
            "function f() { x = a ? b ? c : d : e; }",
            "foo.js",
            |metric| assert_eq!(metric.abc.conditions_sum(), 4),
        );
        // A negated condition is the only input reaching the walker's
        // `else` fallback — see the C++ sibling for why. `?` (1) +
        // `!a` (1) = 2.
        check_metrics::<JavascriptParser>("function f() { x = !a ? b : c; }", "foo.js", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
        });
    }

    // TypeScript expands the same `ts_abc_compute!` arm from a separate
    // macro body than JavaScript's `js_abc_compute!`, so wiring one and
    // not the other is a live failure mode; TSX and Mozjs are clones of
    // these two.
    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_ternary_operand_slots_count_as_unary_conditions() {
        check_metrics::<TypescriptParser>(
            "function f() { x = a ? !b : !c; }",
            "foo.ts",
            |metric| assert_eq!(metric.abc.conditions_sum(), 4),
        );
        check_metrics::<TypescriptParser>(
            "function f() { x = (a > 0) ? b : -b; }",
            "foo.ts",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
    }

    // Issue #1276, JS-family half. See
    // `cpp_for_condition_slot_counts_unary_conditions` for the rule.
    // The JS grammar marks the `condition` field on both the expression
    // and the `;` closing it, so `child_by_field_name` is the only
    // addressing that lands on the expression for every header shape.
    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_for_condition_slot_counts_unary_conditions() {
        // Bare identifier: no operator token anywhere in the header.
        check_metrics::<JavascriptParser>("function f(a) { for (; a; ) {} }", "foo.js", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 1);
        });
        // Negation, through the `!` unwrap.
        check_metrics::<JavascriptParser>(
            "function f(a) { for (; !a; ) {} }",
            "foo.js",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
        // Parentheses: counts only via the `ForStatement`
        // boolean-context seed #1276 found dead.
        check_metrics::<JavascriptParser>(
            "function f(a) { for (; (a); ) {} }",
            "foo.js",
            |metric| assert_eq!(metric.abc.conditions_sum(), 1),
        );
        // No-double-count pin: the `<` arm already counted this shape.
        // `let i = 0` and `i++` are the two assignments, which also
        // confirms the header parsed as the three-clause form.
        check_metrics::<JavascriptParser>(
            "function f(n) { for (let i = 0; i < n; i++) {} }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
        // Empty condition: the slot holds an `empty_statement`, which
        // is neither a terminal nor a wrapper, so it counts nothing.
        check_metrics::<JavascriptParser>(
            "function f() { for (;;) { break; } }",
            "foo.js",
            |metric| assert_eq!(metric.abc.conditions_sum(), 0),
        );
    }

    // TypeScript expands the `ForStatement` arm from `ts_abc_compute!`,
    // a separate macro body from JavaScript's `js_abc_compute!`, so
    // wiring one and not the other is a live failure mode; TSX and
    // Mozjs are the clones of those two. The expected values are
    // derived from the JavaScript run rather than hardcoded.
    #[cfg(all(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    #[test]
    fn js_family_for_condition_slot_agrees_with_javascript() {
        #[cfg(any(feature = "javascript", feature = "mozjs", feature = "typescript"))]
        const BARE: &str = "function f(a) { for (; a; ) {} }\n";
        #[cfg(any(feature = "javascript", feature = "mozjs", feature = "typescript"))]
        const EMPTY: &str = "function f() { for (;;) { break; } }\n";
        let conditions = abc_conditions;

        let bare = conditions(LANG::Javascript, BARE);
        // Non-degenerate: a zeroed reference makes the comparisons
        // below vacuous.
        assert_eq!(bare, 1, "JavaScript reference value for `for (; a; )`");
        assert_eq!(
            conditions(LANG::Javascript, EMPTY),
            0,
            "JavaScript `for (;;)`"
        );

        for lang in [LANG::Mozjs, LANG::Typescript, LANG::Tsx] {
            assert_eq!(conditions(lang, BARE), bare, "{lang:?} bare for-condition");
            assert_eq!(conditions(lang, EMPTY), 0, "{lang:?} empty for-condition");
        }
    }

    #[cfg(all(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    #[test]
    fn js_family_ternary_operand_slots_agree_with_javascript() {
        // `a ? !b : !c` is the one shape that tells the ternary walker
        // from the `for`-header walker: both read the `condition` field
        // and share the `(&Node, &mut f64)` signature, so a transposed
        // pair in a `ts_abc_compute!` / `js_abc_compute!` invocation
        // compiles, passes every condition-slot test, and drops only the
        // two branch operands. TypeScript alone pinned those before; the
        // other three expansions now do too.
        #[cfg(any(feature = "javascript", feature = "mozjs", feature = "typescript"))]
        const SRC: &str = "function f(a, b, c) { x = a ? !b : !c; }\n";
        let javascript = abc_conditions(LANG::Javascript, SRC);
        // expected: 4 — the `?`, the `a` condition slot and both negated
        // branch operands; non-degenerate by construction.
        assert_eq!(
            javascript, 4,
            "JavaScript reference value for `a ? !b : !c`"
        );
        for lang in [LANG::Mozjs, LANG::Typescript, LANG::Tsx] {
            assert_eq!(
                abc_conditions(lang, SRC),
                javascript,
                "{lang:?} ternary operand slots"
            );
        }
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_instanceof_counts_condition() {
        // `x instanceof Foo` is a binary expression whose operator is
        // the `instanceof` keyword token → C = 1.
        check_metrics::<JavascriptParser>(
            "function f(x) { return x instanceof Foo; }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_complex_function_abc() {
        // Mixed-shape regression. Verified by hand:
        // - assignments: `let x = 0` (a `let` initializer counts)
        //   + `x = 5`, `x += 2`, `x++`, `x = (a>b)?a:b`, `x = b`,
        //   `let p = ...` (likewise) → A = 7.
        // - branches: `f(a, b)` self-call + `new Bar()` → B = 2.
        // - conditions: `a == b`, `a > 0` → 2 inside the if header
        //   (`&&` is not counted directly). `else` (1) + `a > b`,
        //   `?` → 2 in the ternary. `a < b` → 1 in the else-if.
        //   `!x` → 1 from the Fitzpatrick Rule 9 walker on `||`
        //   (issue #403): the wrapped Identifier counts once.
        //   `case 1` → 1 in the switch; `default` → 0 (fallthrough,
        //   #469). Total C = 8.
        check_metrics::<JavascriptParser>(
            "function f(a, b) {\n\
                 let x = 0;\n\
                 x = 5;\n\
                 x += 2;\n\
                 x++;\n\
                 if (a == b && a > 0) {\n\
                     x = (a > b) ? a : b;\n\
                 } else if (a < b || !x) {\n\
                     x = b;\n\
                 }\n\
                 switch (x) {\n\
                     case 1: break;\n\
                     default: break;\n\
                 }\n\
                 let p = new Bar();\n\
                 return f(a, b);\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 7);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 8);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_asi_const_does_not_suppress_later_assignments() {
        // Mozjs half of the #1277 cluster; the fork carries its own
        // kind-id numbering, so it needs its own fixture. See
        // `typescript_asi_const_does_not_suppress_later_assignments`.
        check_metrics::<MozjsParser>(
            "function f() {
                const a = 1
                x = 2
                y = 3
            }",
            "foo.jsm",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_const_declarator_shapes_stay_suppressed() {
        // Mozjs half of
        // `javascript_const_declarator_shapes_stay_suppressed`.
        check_metrics::<MozjsParser>(
            "function f(o, xs) {
                const a = 1, b = 2
                const {c = 5, d: {e = 6} = {}} = o
                const [g = 7, ...[h = 8]] = xs
                let i = 3
                var j = 4
                for (const x of xs) { k(x) }
            }",
            "foo.jsm",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 2);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_complex_function_abc() {
        // Mozjs shares JavaScript's expression / statement vocabulary;
        // the `js_abc_compute!` macro expands identical token-level
        // rules for both. This test pins parity against the JS impl.
        check_metrics::<MozjsParser>(
            "function f(a, b) {\n\
                 let x = 0;\n\
                 x = 5;\n\
                 x += 2;\n\
                 x++;\n\
                 if (a == b && a > 0) {\n\
                     x = (a > b) ? a : b;\n\
                 } else if (a < b || !x) {\n\
                     x = b;\n\
                 }\n\
                 switch (x) {\n\
                     case 1: break;\n\
                     default: break;\n\
                 }\n\
                 let p = new Bar();\n\
                 return f(a, b);\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 7);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 8);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // ----- JS / TS / Tsx / Mozjs Phase-2B condition slots -----

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_await_expression_condition_counts() {
        // Regression for findings.md round-2 #2 (JS):
        // `if (await ready()) {}` parses with `await_expression` as
        // the condition node inside the `parenthesized_expression`.
        // The former `javascript_inspect_container` unwrapped the paren
        // but the await child was not in the terminal-bool set, so the
        // walker broke without counting. Mirrors C# (lesson 19).
        check_metrics::<JavascriptParser>(
            "async function ready() { return true; }\n\
             async function f() { if (await ready()) { } }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_member_expression_condition_counts() {
        // Regression for findings.md #3 (JS-family): tree-sitter-
        // javascript emits `member_expression` under three kind_ids
        // (191 primary, 208, 228 — `MemberExpression2/3`) depending
        // on the production rule path. The verifier in this audit
        // confirmed runtime kind for `o.x` is 208. Pre-fix the
        // shared former `js_family_bool_terminal_kinds!()` macro listed
        // only the primary, so every `if (o.x) {}` / `o.x && o.y`
        // condition silently reported zero. The slot now pays for all
        // three aliases, none of which scores itself (lesson #2).
        check_metrics::<JavascriptParser>(
            "function f(o) {\n\
             \x20   if (o.x) {}                  // +1c\n\
             \x20   return o.x && o.y;           // +2c (walker on &&)\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_if_boolean_literal_condition() {
        check_metrics::<JavascriptParser>(
            "function f() {\n\
             \x20   if (true) {}                 // +1c\n\
             \x20   if (!false) {}               // +1c\n\
             \x20   while (true) {}              // +1c\n\
             \x20   do {} while (false);         // +1c\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_methods_arguments_with_conditions() {
        check_metrics::<JavascriptParser>(
            "function f(a, b) {\n\
             \x20   m(a, b);                     // +1b\n\
             \x20   m(!a, !b);                   // +1b +2c\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_return_with_conditions() {
        check_metrics::<JavascriptParser>(
            "function m1(z) { return !(z >= 0); }\n\
             function m2(x) { return (((!x))); }\n\
             function m3(x, y) { return x && y; }\n",
            "foo.js",
            |metric| {
                // m1: 1 (`>=`). m2: 1 (walker unwraps to `x`).
                // m3: 2 (`&&` walker counts both terminals).
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_if_boolean_literal_condition() {
        check_metrics::<TypescriptParser>(
            "function f() {\n\
             \x20   if (true) {}\n\
             \x20   if (!false) {}\n\
             \x20   while (true) {}\n\
             \x20   do {} while (false);\n\
             }\n",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_methods_arguments_with_conditions() {
        check_metrics::<TypescriptParser>(
            "function f(a: boolean, b: boolean) {\n\
             \x20   m(a, b);\n\
             \x20   m(!a, !b);\n\
             }\n",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_return_with_conditions() {
        check_metrics::<TypescriptParser>(
            "function m1(z: number): boolean { return !(z >= 0); }\n\
             function m2(x: boolean): boolean { return (((!x))); }\n\
             function m3(x: boolean, y: boolean): boolean { return x && y; }\n",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_if_boolean_literal_condition() {
        check_metrics::<TsxParser>(
            "function f() {\n\
             \x20   if (true) {}\n\
             \x20   if (!false) {}\n\
             \x20   while (true) {}\n\
             \x20   do {} while (false);\n\
             }\n",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_methods_arguments_with_conditions() {
        check_metrics::<TsxParser>(
            "function f(a: boolean, b: boolean) {\n\
             \x20   m(a, b);\n\
             \x20   m(!a, !b);\n\
             }\n",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_return_with_conditions() {
        check_metrics::<TsxParser>(
            "function m1(z: number): boolean { return !(z >= 0); }\n\
             function m2(x: boolean): boolean { return (((!x))); }\n\
             function m3(x: boolean, y: boolean): boolean { return x && y; }\n",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_jsx_elements_are_not_conditions() {
        // #1297 in the second expansion of `js_abc_compute!`. The
        // vendored mozjs fork carries the same three JSX productions as
        // upstream tree-sitter-javascript with its own `kind_id`s, so
        // the gate is a distinct instantiation and needs its own
        // fixture — a passing JavaScript test says nothing about the
        // macro's other expansion. Same shape and same discriminating
        // numbers as `javascript_jsx_elements_are_not_conditions`: 8
        // pre-fix, 1 after.
        check_metrics::<MozjsParser>(
            "function f(a, b) {
                if (a < b) { return <div className=\"x\"><span>hi</span></div>; }
                return <br />;
            }",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                // Fixture-presence anchor: the `className="x"` attribute
                // `=` is this fixture's only assignment, so the test
                // fails if a later edit drops the JSX. Without it the
                // surviving `a < b` alone also scores 1, and the
                // conditions assertion would pass while proving nothing.
                assert_eq!(metric.abc.assignments_sum(), 1);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_if_boolean_literal_condition() {
        check_metrics::<MozjsParser>(
            "function f() {\n\
             \x20   if (true) {}\n\
             \x20   if (!false) {}\n\
             \x20   while (true) {}\n\
             \x20   do {} while (false);\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_methods_arguments_with_conditions() {
        check_metrics::<MozjsParser>(
            "function f(a, b) {\n\
             \x20   m(a, b);\n\
             \x20   m(!a, !b);\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_return_with_conditions() {
        check_metrics::<MozjsParser>(
            "function m1(z) { return !(z >= 0); }\n\
             function m2(x) { return (((!x))); }\n\
             function m3(x, y) { return x && y; }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // ----- JS / TS / Tsx / Mozjs unary-conditional walker -----

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_if_multiple_conditions() {
        check_metrics::<JavascriptParser>(
            "function f(a, b, c, d) {\n\
             \x20   if (a || b || c || d) {}        // +4c\n\
             \x20   if (a && b && c) {}             // +3c\n\
             \x20   if (!a && !b) {}                // +2c\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_while_and_do_while_conditions() {
        check_metrics::<JavascriptParser>(
            "function f(a, b) {\n\
             \x20   while (a || b) {}              // +2c\n\
             \x20   do {} while (a && !b);         // +2c\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_short_circuit_with_boolean_literal_operand() {
        check_metrics::<JavascriptParser>(
            "function f(a) { return a && true; }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_if_multiple_conditions() {
        check_metrics::<TypescriptParser>(
            "function f(a: boolean, b: boolean, c: boolean, d: boolean) {\n\
             \x20   if (a || b || c || d) {}        // +4c\n\
             \x20   if (a && b && c) {}             // +3c\n\
             \x20   if (!a && !b) {}                // +2c\n\
             }\n",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_while_and_do_while_conditions() {
        check_metrics::<TypescriptParser>(
            "function f(a: boolean, b: boolean) {\n\
             \x20   while (a || b) {}              // +2c\n\
             \x20   do {} while (a && !b);         // +2c\n\
             }\n",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_short_circuit_with_boolean_literal_operand() {
        check_metrics::<TypescriptParser>(
            "function f(a: boolean): boolean { return a && true; }\n",
            "foo.ts",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_if_multiple_conditions() {
        check_metrics::<TsxParser>(
            "function f(a: boolean, b: boolean, c: boolean, d: boolean) {\n\
             \x20   if (a || b || c || d) {}        // +4c\n\
             \x20   if (a && b && c) {}             // +3c\n\
             \x20   if (!a && !b) {}                // +2c\n\
             }\n",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_while_and_do_while_conditions() {
        check_metrics::<TsxParser>(
            "function f(a: boolean, b: boolean) {\n\
             \x20   while (a || b) {}              // +2c\n\
             \x20   do {} while (a && !b);         // +2c\n\
             }\n",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_short_circuit_with_boolean_literal_operand() {
        check_metrics::<TsxParser>(
            "function f(a: boolean): boolean { return a && true; }\n",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_if_multiple_conditions() {
        check_metrics::<MozjsParser>(
            "function f(a, b, c, d) {\n\
             \x20   if (a || b || c || d) {}        // +4c\n\
             \x20   if (a && b && c) {}             // +3c\n\
             \x20   if (!a && !b) {}                // +2c\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_while_and_do_while_conditions() {
        check_metrics::<MozjsParser>(
            "function f(a, b) {\n\
             \x20   while (a || b) {}              // +2c\n\
             \x20   do {} while (a && !b);         // +2c\n\
             }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_short_circuit_with_boolean_literal_operand() {
        check_metrics::<MozjsParser>(
            "function f(a) { return a && true; }\n",
            "foo.js",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // ---------- Perl ABC tests ----------

    #[cfg(feature = "perl")]
    #[test]
    fn perl_empty_unit_zero() {
        // Empty source produces zero ABC magnitude — pins the trait
        // wiring without exercising any compute branch.
        check_metrics::<PerlParser>("", "empty.pl", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_plain_and_compound_assignments_count() {
        // `my $x = 0` parses as a `binary_expression` with an `=`
        // token, so the initialiser counts (Perl has no equivalent of
        // the JS `const` initialiser-suppression rule). Each
        // assignment operator token contributes one assignment:
        // `=`, `=`, `+=`, `.=`, `**=` → A = 5. Two of those `=` come
        // from the `my $x = 0` initialiser and the later `$x = 5`
        // reassignment.
        check_metrics::<PerlParser>(
            "sub f { my $x = 0; $x = 5; $x += 2; $x .= \"a\"; $x **= 3; }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 5);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_calls_are_branches() {
        // `foo()` parses as `call_expression_with_args_with_brackets`
        // wrapping an inner `call_expression_with_bareword(foo)`;
        // `bar 1, 2` wraps `bar` likewise under spaced-args; `shift`
        // appears as a standalone bareword. The bareword-inside-
        // wrapper case must NOT double-count — only the outer wrapper
        // contributes a branch. So B = 3 (foo, bar, shift), not 5.
        check_metrics::<PerlParser>(
            "sub f { foo(); bar 1, 2; my $a = shift; }",
            "foo.pl",
            |metric| {
                // shift's `my $a = shift` initialiser contributes one
                // assignment via the `=` token.
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 3);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_method_invocation_counts_as_branch() {
        // `$obj->method(...)` parses as `method_invocation`. Any
        // arrow-dispatch counts as one branch regardless of how the
        // arguments are passed.
        check_metrics::<PerlParser>(
            "sub f { my $obj = shift; $obj->run($x); $obj->ping; }",
            "foo.pl",
            |metric| {
                // `my $obj = shift` → A=1, B=1 (shift bareword).
                // `$obj->run($x)` and `$obj->ping` → 2 more branches.
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 3);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // #1297's own sweep cleared Perl, and it was wrong. `<STDIN>` does
    // lex as a single `standard_input` token and scores 0, which is
    // what the issue measured — but the filehandle and lexical-handle
    // readlines do not: `<FH>` is `standard_input_to_identifier` and
    // `<$fh>` is `standard_input_to_variable`, each a plain three-token
    // sequence whose brackets are the same bare `<` / `>` a comparison
    // uses, and the arm was ungated. Each scored two phantom
    // conditions.
    //
    // All three readline spellings against two genuine comparisons, so
    // every mis-aim lands on its own number: 6 pre-fix, 2 once the arm
    // allows `BinaryExpression`, 0 if it allows the wrong parent or the
    // fixture stops parsing. The assertion is also the grammar-dispatch
    // §8 pin — `cyclomatic()` is 3 on this space, so decisions is 2 and
    // the two counts agree exactly.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_readline_angle_brackets_are_not_conditions() {
        check_func_space::<PerlParser, _>(
            "sub g {\n\
                 my ($a, $b, $fh) = @_;\n\
                 my $l = <FH>;\n\
                 my $m = <$fh>;\n\
                 my $n = <STDIN>;\n\
                 if ($a < $b) { return 1; }\n\
                 if ($a > $b) { return 2; }\n\
                 return 0;\n\
             }",
            "foo.pl",
            |space| {
                assert_deepest_conditions_match_cyclomatic(&space, 2);
                // Fixture-presence anchor: the three readlines are
                // three of this sub's four assignments (the fourth is
                // the `my (...) = @_` unpack), so dropping them from
                // the fixture fails here rather than leaving a test
                // that still reports 2 conditions and proves nothing.
                assert_eq!(space.metrics.abc.assignments_sum(), 4);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_numeric_and_string_comparisons_count_conditions() {
        // Numeric ops `==`, `!=`, `<`, `>`, `<=`, `>=`, `<=>` and
        // string ops `eq`, `ne`, `lt`, `gt`, `le`, `ge`, `cmp` each
        // fire once per token. The sample below uses one of each →
        // C = 14. No assignments, no branches.
        check_metrics::<PerlParser>(
            "sub f {\n\
                 my $r;\n\
                 $r = $a == $b;\n\
                 $r = $a != $b;\n\
                 $r = $a <  $b;\n\
                 $r = $a >  $b;\n\
                 $r = $a <= $b;\n\
                 $r = $a >= $b;\n\
                 $r = $a <=> $b;\n\
                 $r = $a eq $b;\n\
                 $r = $a ne $b;\n\
                 $r = $a lt $b;\n\
                 $r = $a gt $b;\n\
                 $r = $a le $b;\n\
                 $r = $a ge $b;\n\
                 $r = $a cmp $b;\n\
             }",
            "foo.pl",
            |metric| {
                // 15 `=` tokens: one declaration `my $r` (no `=`),
                // then 14 `$r = …` plus there's no `=` in `my $r;`.
                // Actually: `my $r;` has no `=`; the 14 `$r = …` are
                // 14 `=` tokens. So A=14, C=14.
                assert_eq!(metric.abc.assignments_sum(), 14);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 14);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_short_circuit_not_counted_directly_ternary_counts() {
        // `&&`, `||`, `//`, low-precedence `and`, `or` are NOT
        // counted as conditions on their own (Fitzpatrick Rule 5;
        // #395) — instead each operand is counted as a unary
        // conditional by the walker (Rule 9; #403). `xor` evaluates
        // both operands, so it is a value like `^` and, outside a
        // slot, scores nothing (#1536). The pinned
        // tree-sitter-perl parses the low-precedence `and` as a
        // two-operand `unary_expression` rather than a
        // `binary_expression`; the walker reads the operands of either
        // since #1526, which is what moved this count from 10 to 14.
        // The low-precedence forms bind looser than `=`, so
        // `$r = $a and $b` is `($r = $a) and $b`, and its left operand
        // pays through the assignment's value.
        // Net: 5 chain lines × 2 operands + 0 for the `xor` line + 1
        // ternary node + 1 for the ternary's bare `$a` condition operand
        // (#1102) = 12.
        check_metrics::<PerlParser>(
            "sub f {\n\
                 my $r;\n\
                 $r = $a && $b;\n\
                 $r = $a || $b;\n\
                 $r = $a // $b;\n\
                 $r = $a and $b;\n\
                 $r = $a or  $b;\n\
                 $r = $a xor $b;\n\
                 $r = $a ? 1 : 2;\n\
             }",
            "foo.pl",
            |metric| {
                // 7 `=` tokens (one per reassignment line).
                assert_eq!(metric.abc.assignments_sum(), 7);
                assert_eq!(metric.abc.branches_sum(), 0);
                // 5 chain lines × 2 operands + 1 ternary node + 1 for
                // its bare `$a` condition operand = 12.
                assert_eq!(metric.abc.conditions_sum(), 12);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // Issue #1102, Perl half. See
    // `cpp_ternary_operand_slots_count_as_unary_conditions` for the
    // rule. Like PHP, Perl's ABC dispatcher has no `?`-token arm — the
    // grammar does emit the token, but the `ternary_expression` node is
    // what carries the tally's +1. tree-sitter-perl names the branch
    // fields `true` / `false` rather than the C-family `consequence` /
    // `alternative`, so a copied C-family gate would match nothing.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_ternary_operand_slots_count_as_unary_conditions() {
        // ternary (1) + condition `$a` (1) + `!$b` (1) + `!$c` (1) = 4.
        check_metrics::<PerlParser>("sub f { my $x = $a ? !$b : !$c; }", "foo.pl", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 4);
        });
        // No-double-count pin: ternary (1) + `>` (1) = 2, unchanged by
        // the fix.
        check_metrics::<PerlParser>(
            "sub f { my $x = ($a > 0) ? $b : -$b; }",
            "foo.pl",
            |metric| assert_eq!(metric.abc.conditions_sum(), 2),
        );
        // A negated *condition*: the slot peels the `!`
        // (`perl_wrapper_operand`) and pays for `$a`, which does not
        // score itself. ternary (1) + `!$a` (1) = 2.
        check_metrics::<PerlParser>("sub f { my $x = !$a ? $b : $c; }", "foo.pl", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
        });
        // Nested: two ternary nodes plus the two bare-variable
        // conditions = 4.
        check_metrics::<PerlParser>(
            "sub f { my $x = $a ? ($b ? $c : $d) : $e; }",
            "foo.pl",
            |metric| assert_eq!(metric.abc.conditions_sum(), 4),
        );
    }

    // Issue #1273. tree-sitter-perl 1.1.2 parses `$a > $b ? 1 : 2` as
    // `$a > ($b ? 1 : 2)`, and the ternary's condition slot then paid
    // for `$b`: 3 against JavaScript's 2 for `a > b ? 1 : 2`. Every
    // chaining comparison does it; each row must also equal its
    // parenthesised spelling, which parses correctly and so takes its
    // value from outside the fix.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_comparison_conditioned_ternary_counts_the_comparison_once() {
        let operators = [
            "<", ">", "<=", ">=", "lt", "gt", "le", "ge", "==", "!=", "eq", "ne",
        ];
        for op in operators {
            let bare = format!("sub f {{ my $m = $a {op} $b ? 1 : 2; }}\n");
            let grouped = format!("sub f {{ my $m = ($a {op} $b) ? 1 : 2; }}\n");
            // The ternary (1) and the comparison token (1).
            assert_eq!(abc_conditions(LANG::Perl, &bare), 2, "`{op}`");
            assert_eq!(abc_conditions(LANG::Perl, &grouped), 2, "`({op})`");
        }
    }

    // Issue #1273, the general shape: a chaining comparison swallows
    // every lower-precedence operator to its right, so a logical chain
    // misparses too — `$a > $b && $c` is `$a > ($b && $c)`, and the
    // chain walker paid for `$b`. Expected values are the JavaScript
    // twins (`a > b && c ? 1 : 2` = 3, …) or, where JavaScript has no
    // spelling, the parenthesised Perl one.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_misparsed_comparison_operand_is_not_a_condition() {
        let cases = [
            // `<` `<` `?`; `($a < $b < $c) ? 1 : 2` is 3.
            ("my $m = $a < $b < $c ? 1 : 2;", 3),
            // `>` `?` `>` `?`, as `a > b ? (c > d ? 1 : 2) : 3`.
            ("my $m = $a > $b ? $c > $d ? 1 : 2 : 3;", 4),
            // Two ternaries and two comparisons, as the JS twin.
            ("if ($a > $b ? $c : $d) { } return $a == $b ? 1 : 0;", 4),
            // The chain is the ternary's condition: `>` `?` `$c`.
            ("my $m = $a > $b && $c ? 1 : 2;", 3),
            // The ternary hangs off the chain's right comparison.
            ("my $m = $x > 0 && $y > 0 ? 1 : 2;", 3),
            ("my $m = $x && $a > $b ? 1 : 2;", 3),
            ("if ($a > $b && $c) { }", 2),
            ("if ($a eq $b && $c eq $d) { }", 2),
            // `&&` is the first operand of `||`: the climb crosses it.
            ("if ($a > $b && $c || $d) { }", 3),
            ("if ($a > $b && $c && $d) { }", 3),
            // `and` is a two-operand `unary_expression`, which the
            // climb crosses too: `(($a > $b) && $c) and $d` is 3.
            ("if ($a > $b and $c) { }", 2),
            ("if ($a > $b && $c and $d) { }", 3),
            // A comment between the operator and the ternary is an
            // `extra` sibling, not the operator.
            ("my $m = $a > # c\n $b ? 1 : 2;", 2),
        ];
        for (body, expected) in cases {
            let src = format!("sub f {{ {body} }}\n");
            assert_eq!(abc_conditions(LANG::Perl, &src), expected, "`{body}`");
        }
    }

    // Issue #1273: shapes the workaround must leave alone. The explicit
    // `$a > ($b ? 1 : 2)` puts an `array` between the comparison and
    // the ternary, so `$b` really is a condition: 3, as
    // `a > (b ? 1 : 2)` in JavaScript. `<=>`, `cmp` and `=~` do not
    // chain and parse correctly; those rows pin that grammar fact, not
    // the workaround's operator list — adding `<=>` to the list moves
    // nothing, since no tree ever puts a ternary straight after it.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_correctly_parsed_ternaries_keep_their_condition_slot() {
        let cases = [
            ("my $m = ($a > $b) ? 1 : 2;", 2),
            ("my $m = $a <=> $b ? 1 : 2;", 2),
            ("my $m = $a cmp $b ? 1 : 2;", 2),
            ("my $m = $a =~ /x/ ? 1 : 2;", 2),
            ("my $m = $a > ($b ? 1 : 2);", 3),
            ("my $m = $a ? !$b : !$c;", 4),
            ("my $m = $a && $b ? 1 : 2;", 3),
        ];
        for (body, expected) in cases {
            let src = format!("sub f {{ {body} }}\n");
            assert_eq!(abc_conditions(LANG::Perl, &src), expected, "`{body}`");
        }
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_elsif_and_else_count_conditions() {
        // `if (… == …) { … } elsif (… < …) { … } else { … }` →
        // 2 comparison tokens (`==`, `<`), plus `elsif_clause` and
        // `else_clause` each + 1 → C = 4. Branches: 0 (only
        // assignments). Assignments: just the `=` initialisers /
        // reassignments — there are 4 here (`$x` init plus three
        // `$x = …` reassigns).
        check_metrics::<PerlParser>(
            "sub f {\n\
                 my $x = 0;\n\
                 if ($a == $b) {\n\
                     $x = 1;\n\
                 } elsif ($a < $b) {\n\
                     $x = 2;\n\
                 } else {\n\
                     $x = 3;\n\
                 }\n\
             }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 4);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_regex_match_operators_count_conditions() {
        // `=~` and `!~` are pattern-match operators; we count both
        // as conditions because they evaluate the regex match in a
        // boolean context.
        check_metrics::<PerlParser>(
            "sub f { my $s = shift; my $m = $s =~ /foo/; my $n = $s !~ /bar/; }",
            "foo.pl",
            |metric| {
                // 3 `=` tokens, 0 branches except `shift` bareword.
                assert_eq!(metric.abc.assignments_sum(), 3);
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_complex_function_abc() {
        // Mixed program exercising every category. Computed
        // expected:
        //   Assignments: `my $i = 0` (1), `$i++` is a unary
        //     increment — Perl's grammar emits `PLUSPLUS` not an `=`
        //     operator, so it does NOT count under the operator-
        //     token rule. The for-loop's `$i++` is similarly
        //     uncounted.
        //     Total A: 1 from `my $i = 0`, 1 from `$total += $i`
        //     (the `+=` token) → A = 2.
        //   Branches: `do_work($i)` → 1; `print "done\n"` is a
        //     call_expression_with_spaced_args → 1; `return $total`
        //     uses the `return` keyword not a call → 0. B = 2.
        //   Conditions: `$i < 10` (`<`) → 1; `$i % 2 == 0` (`==`) →
        //     1; `else_clause` → 1. C = 3.
        check_metrics::<PerlParser>(
            "sub run {\n\
                 my $total = 0;\n\
                 for (my $i = 0; $i < 10; $i++) {\n\
                     if ($i % 2 == 0) {\n\
                         do_work($i);\n\
                     } else {\n\
                         $total += $i;\n\
                     }\n\
                 }\n\
                 print \"done\\n\";\n\
                 return $total;\n\
             }",
            "foo.pl",
            |metric| {
                // `my $total = 0` is one `=`; `my $i = 0` is another
                // `=`; `$total += $i` is one `+=`. Total = 3.
                assert_eq!(metric.abc.assignments_sum(), 3);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_if_multiple_conditions() {
        // Fitzpatrick Rule 9 walker (issue #403): each operand of a
        // `&&` / `||` / `//` / `and` / `or` chain is one
        // condition. ScalarVariable operands ($a, $b, …) qualify as
        // terminal-bool kinds for the walker.
        check_metrics::<PerlParser>(
            "sub f {\n\
                 my ($a, $b, $c, $d) = @_;\n\
                 if ($a || $b || $c || $d) { return 1; }    # +4c\n\
                 if ($a && $b && $c) { return 2; }          # +3c\n\
                 if (!$a && !$b) { return 3; }              # +2c\n\
                 return 0;\n\
             }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_while_and_until_conditions() {
        // Perl has no `do { ... } while(cond);` shape in this grammar
        // — `while` and `until` are the loop forms with a condition
        // slot. The walker fires on each `&&` / `||` token inside
        // those headers.
        check_metrics::<PerlParser>(
            "sub f {\n\
                 my ($a, $b) = @_;\n\
                 while ($a || $b) { last; }            # +2c\n\
                 until ($a && !$b) { last; }           # +2c\n\
             }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_for_header_condition_slot_counts_unary_conditions() {
        // The Perl half of #1276. The C-style `for` header's condition
        // slot is a Rule 9 unary condition like the `if` slot: a bare
        // `$ok`, a negated `!$ok` and a parenthesised `($ok)` each count
        // one, an empty header and a `foreach` count zero, and a
        // comparison-shaped `$i < $n` stays at the one the `<` arm
        // already counts. Every C-style row is the three-clause spelling
        // because tree-sitter-perl does not parse an empty initializer.
        let cases = [
            ("for (my $i = 0; $ok; $i++) { }", 1),
            ("for (my $i = 0; !$ok; $i++) { }", 1),
            ("for (my $i = 0; ($ok); $i++) { }", 1),
            ("for (my $i = 0; $i < $n; $i++) { }", 1),
            ("for (my $i = 0; $ok && $j; $i++) { }", 2),
            ("for (;;) { last; }", 0),
            ("for my $x (@l) { }", 0),
        ];
        let mut ran = 0;
        for (body, expected) in cases {
            let src = format!("sub f {{ {body} }}\n");
            assert_eq!(abc_conditions(LANG::Perl, &src), expected, "`{body}`");
            ran += 1;
        }
        assert_eq!(ran, cases.len());
        assert!(cases.iter().any(|&(_, n)| n == 0));
        assert!(cases.iter().any(|&(_, n)| n == 2));

        // The slot agrees with the `if` slot for every shape, which is
        // the property the fix restores; the reference is non-degenerate
        // by the table above.
        for condition in ["$ok", "!$ok", "($ok)", "$ok && $j"] {
            let in_for = format!("sub f {{ for (my $i = 0; {condition}; $i++) {{ }} }}\n");
            let in_if = format!("sub f {{ if ({condition}) {{ }} }}\n");
            assert_eq!(
                abc_conditions(LANG::Perl, &in_for),
                abc_conditions(LANG::Perl, &in_if),
                "`{condition}` must score alike in a `for` header and an `if`",
            );
        }
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_short_circuit_counts_scalar_variable_operands() {
        // `$a && $b` reports 2 conditions — one walker count per
        // `ScalarVariable` operand. Renamed from the cross-language
        // `_with_boolean_literal_operand` convention because Perl has
        // no readily-grammar-exposed boolean literal in an `&&`
        // operand slot at the pinned grammar version (the `Boolean`
        // kind only fires on the `boolean` pragma's named constants,
        // not bareword `1` / `0`). Two scalar variables are the
        // grammar-stable terminal-set witness for Perl.
        check_metrics::<PerlParser>(
            "sub f { my ($a) = @_; return $a && $b; }\n",
            "foo.pl",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_array_in_binary_operand_descends_to_scalar_context_value() {
        // Regression test for the code-review findings on the
        // Phase-2B Perl walker:
        //   - Pre-fix-A: the former `perl_inspect_container` descended `Array`
        //     via `node.child(1)` — the FIRST element — wrongly
        //     attributing `$x` for `($x, $y)` (semantically `$y`
        //     is the scalar-context value).
        //   - Fix-A (the `array_is_paren` guard, 5db8078): dropped
        //     Array-as-paren entirely in `BinaryExpression` operand
        //     contexts to avoid the wrong attribution — but
        //     regressed `$a || ($x)` (single paren-grouped operand)
        //     to C=1 instead of 2.
        //   - Fix-B (this change): keeps Array-as-paren unconditional
        //     but descends via the LAST named child. `$a || ($x)`
        //     reaches `$x` (count both operands → 2);
        //     `$a || ($x, $y)` reaches `$y` (count `$a` + `$y` →
        //     still 2, matching Fitzpatrick Rule 7 "one per
        //     operand"); `if ($a)` still reaches `$a` (single-
        //     element grouping → 1).
        check_metrics::<PerlParser>(
            "sub f { my ($a, $x, $y) = @_;\n\
             \x20   my $r = $a || ($x, $y);    # +2c: $a + last-named $y\n\
             \x20   my $s = $a || ($x);        # +2c: $a + only-named $x\n\
             \x20   $r + $s;\n\
             }\n",
            "foo.pl",
            |metric| {
                // 2 + 2 = 4 unary conditions from the two `||`s.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_if_scalar_variable_condition() {
        // Renamed from the cross-language
        // `_if_boolean_literal_condition` convention because
        // Perl has no readily-grammar-exposed boolean literal in
        // an `if (cond)` slot at the pinned grammar version:
        // tree-sitter-perl's `Boolean` kind only fires for the
        // `boolean` pragma's named constants (not bareword `1` /
        // `0`, which surface as `Integer` / not in the
        // terminal-bool set). A scalar-variable condition is the
        // grammar-stable witness — `if ($a)` reaches
        // `scalar_variable` via the `Array` paren unwrap.
        check_metrics::<PerlParser>(
            "sub f { my ($a) = @_; if ($a) { return 1; } }\n",
            "foo.pl",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_methods_arguments_with_conditions() {
        // `call(!$a, !$b)` — argument list walker counts each
        // unary-conditional argument once. Cannot use `m(...)` as
        // the function name — tree-sitter-perl parses `m(...)` as
        // the regex-match operator, not a function call.
        check_metrics::<PerlParser>(
            "sub f { my ($a, $b) = @_; call($a, $b); call(!$a, !$b); }\n",
            "foo.pl",
            |metric| {
                // Two calls × 1 branch each = 2 branches.
                // `call(!$a, !$b)` contributes 2 walker conditions
                // (one per `!`-wrapped scalar-variable argument);
                // `call($a, $b)` contributes 0 (bare-args don't
                // count via the Arguments walker — list_kind !=
                // BinaryExpression).
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_return_with_conditions() {
        // `return !$a` reports 1 condition via the walker (unary
        // unwrap to scalar-variable terminal). `return $a` reports
        // 0 (no paren / unary wrap, has_boolean_content stays
        // false from ReturnExpression parent).
        check_metrics::<PerlParser>(
            "sub m1 { my ($z) = @_; return !($z); }\n\
             sub m2 { my ($x) = @_; return (((!$x))); }\n\
             sub m3 { my ($x, $y) = @_; return $x && $y; }\n",
            "foo.pl",
            |metric| {
                // m1: !($z) → walker on `!` unwraps paren to $z (1).
                // m2: (((!$x))) → walker unwraps three parens + one
                //     unary to $x (1).
                // m3: $x && $y → walker on `&&` counts both (2).
                // Sum: 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // A bare `/re/` or `m{re}` is a match against `$_`, a relational
    // operator spelled with no operator token, so it scores by use
    // (#1467, the rule #1461 applied to five other languages). Each
    // `*_out` member and `ret` / `notm` / `grp` / `arg` / `smart` was 0
    // before the arm: only a boolean slot reached the pattern, through
    // the former `perl_bool_terminal_kinds!()`. `mbare_out` is the `m{}` spelling, a
    // sibling kind rather than an alias. `smart` levels a smartmatch
    // with its `=~` sibling: no arm counts `~~`, so the pattern does.
    //
    // The in-slot members are the §5 check that the slot stopped
    // counting the pattern in the change that gave it an arm: each
    // reads what it read before. `bound_out` / `nbound` pin the gate on
    // `=~` / `!~` — the operator token scores, the pattern under it does
    // not — and `ctrl_out` is the `==` control the rest level with.
    // `s///`, `tr///` and `qr//` are not matches and stay at 0; the
    // bound `s///` / `tr///` agree (#1540, the test below).
    #[cfg(feature = "perl")]
    #[test]
    fn perl_bare_match_is_a_condition_by_use() {
        check_func_space::<PerlParser, _>(
            "sub bare_out { my $r = /^#/; return $r; }\n\
             sub mbare_out { my $r = m{^#}; return $r; }\n\
             sub ret { return /x/; }\n\
             sub notm { my $r = !/x/; return $r; }\n\
             sub grp { my @a = @_; return grep { /x/ } @a; }\n\
             sub arg { foo(/x/); }\n\
             sub smart { my ($x) = @_; my $r = $x ~~ /re/; return $r; }\n\
             sub bare_in { if (/^#/) { return 1; } return 0; }\n\
             sub mbare_in { unless (m{^#}) { return 1; } return 0; }\n\
             sub modif { return 0 unless /x/; return 1; }\n\
             sub andy { my ($y) = @_; return /x/ && $y; }\n\
             sub oror { return /a/ || /b/; }\n\
             sub tern { return /x/ ? 1 : 0; }\n\
             sub forc { for (my $i = 0; /x/; $i++) { } }\n\
             sub bound_out { my ($x) = @_; my $r = ($x =~ /^#/); return $r; }\n\
             sub nbound { my ($x) = @_; my $r = ($x !~ /^#/); return $r; }\n\
             sub ctrl_out { my ($x) = @_; my $r = ($x == 1); return $r; }\n\
             sub subst { my $n = s/x/y/; return $n; }\n\
             sub tr1 { my $n = tr/a/b/; return $n; }\n\
             sub qrx { my $q = qr/x/; return $q; }\n",
            "foo.pl",
            |space| {
                assert_members_score(
                    &space,
                    &[
                        ("bare_out", 1, 1),
                        ("mbare_out", 1, 1),
                        ("ret", 1, 1),
                        // `!` adds nothing outside a slot; the match is
                        // the one condition.
                        ("notm", 1, 1),
                        ("grp", 1, 1),
                        ("arg", 1, 1),
                        ("smart", 1, 1),
                        ("bare_in", 1, 2),
                        ("mbare_in", 1, 2),
                        ("modif", 1, 2),
                        // One per `&&` / `||` operand, the match included.
                        ("andy", 2, 2),
                        ("oror", 2, 2),
                        // The ternary node plus its condition.
                        ("tern", 2, 2),
                        ("forc", 1, 2),
                        ("bound_out", 1, 1),
                        ("nbound", 1, 1),
                        ("ctrl_out", 1, 1),
                        ("subst", 0, 1),
                        ("tr1", 0, 1),
                        ("qrx", 0, 1),
                    ],
                );
            },
        );
    }

    // A substitution or transliteration bound with `=~` / `!~` is the
    // same edit as its bare form on `$_`, so it scores by use exactly as
    // that twin does: 0 (#1540). Each `*_s` / `*_tr` / `*_y` row below
    // was 1 through the operator token before the gate; `count` (an
    // assigned count) and `sr` (a `/r` copy, a value) are uses too. A
    // match keeps its 1 whatever spells it — a pattern, `qr//`, or a
    // variable holding one. The `if_*` rows are the slot side: each pays
    // once, as its bare twin `if_s` does, because
    // `perl_condition_scores_itself` stops claiming a rewrite binding in
    // the same change; `tern_s` and `neg_s` reach that predicate through
    // a ternary condition and a `!`-proved `return` operand.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_bound_rewrite_scores_like_its_bare_twin() {
        check_func_space::<PerlParser, _>(
            "sub ctrl { my ($x) = @_; $x; return $x; }\n\
             sub m_bare { my ($x) = @_; /re/; return $x; }\n\
             sub m_bound { my ($x) = @_; $x =~ /re/; return $x; }\n\
             sub m_nbound { my ($x) = @_; $x !~ /re/; return $x; }\n\
             sub m_qr { my ($x) = @_; $x =~ qr/re/; return $x; }\n\
             sub m_var { my ($x, $q) = @_; $x =~ $q; return $x; }\n\
             sub s_bare { my ($x) = @_; s/a/b/; return $x; }\n\
             sub s_bound { my ($x) = @_; $x =~ s/a/b/; return $x; }\n\
             sub s_nbound { my ($x) = @_; $x !~ s/a/b/; return $x; }\n\
             sub tr_bare { my ($x) = @_; tr/a/b/; return $x; }\n\
             sub tr_bound { my ($x) = @_; $x =~ tr/a/b/; return $x; }\n\
             sub tr_nbound { my ($x) = @_; $x !~ tr/a/b/; return $x; }\n\
             sub y_bound { my ($x) = @_; $x =~ y/a/b/; return $x; }\n\
             sub count { my ($x) = @_; my $n = ($x =~ s/a/b/g); return $x; }\n\
             sub sr { my ($x) = @_; my $r = $x =~ s/a/b/r; return $r; }\n\
             sub if_s { my ($x) = @_; if (s/a/b/) { g(); } return $x; }\n\
             sub if_m { my ($x) = @_; if ($x =~ /re/) { g(); } return $x; }\n\
             sub if_bs { my ($x) = @_; if ($x =~ s/a/b/) { g(); } return $x; }\n\
             sub if_nbs { my ($x) = @_; if ($x !~ s/a/b/) { g(); } return $x; }\n\
             sub if_btr { my ($x) = @_; if ($x =~ tr/a/b/) { g(); } return $x; }\n\
             sub if_by { my ($x) = @_; if ($x =~ y/a/b/) { g(); } return $x; }\n\
             sub if_bsr { my ($x) = @_; if ($x =~ s/a/b/r) { g(); } return $x; }\n\
             sub tern_s { my ($x) = @_; return ($x =~ s/a/b/) ? 1 : 0; }\n\
             sub neg_s { my ($x) = @_; return !($x =~ s/a/b/); }\n",
            "foo.pl",
            |space| {
                assert_members_score(
                    &space,
                    &[
                        ("ctrl", 0, 1),
                        ("m_bare", 1, 1),
                        ("m_bound", 1, 1),
                        ("m_nbound", 1, 1),
                        ("m_qr", 1, 1),
                        ("m_var", 1, 1),
                        ("s_bare", 0, 1),
                        ("s_bound", 0, 1),
                        ("s_nbound", 0, 1),
                        ("tr_bare", 0, 1),
                        ("tr_bound", 0, 1),
                        ("tr_nbound", 0, 1),
                        ("y_bound", 0, 1),
                        ("count", 0, 1),
                        ("sr", 0, 1),
                        ("if_s", 1, 2),
                        ("if_m", 1, 2),
                        ("if_bs", 1, 2),
                        ("if_nbs", 1, 2),
                        ("if_btr", 1, 2),
                        ("if_by", 1, 2),
                        ("if_bsr", 1, 2),
                        // The ternary node plus its condition slot.
                        ("tern_s", 2, 2),
                        ("neg_s", 1, 1),
                    ],
                );
            },
        );
    }

    // The pattern `split` takes first is its delimiter, not a match
    // against `$_`, so it is no condition (#1467) in any spelling: the
    // spaced and parenthesised call forms, the `m{}` pattern, and the
    // `CORE::` qualifier. Three discriminating members keep the exclusion
    // narrow: `spl2` puts the pattern in `split`'s *second* slot, where
    // it is an ordinary match whose result `split` receives, `grpe`
    // puts one first in a call that is not `split`, and `tsplit` puts
    // one first in a list whose grandparent holds a bare `split` without
    // being that call — the ternary node plus `$c` plus the match.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_split_delimiter_is_not_a_condition() {
        use crate::{ParserTrait, Perl};

        let src = "sub spl { my ($s) = @_; my @p = split /,/, $s; return @p; }\n\
                   sub splp { my ($s) = @_; my @p = split(/,/, $s); return @p; }\n\
                   sub splm { my ($s) = @_; my @p = split m{,}, $s; return @p; }\n\
                   sub splc { my ($s) = @_; my @p = CORE::split(/,/, $s); return @p; }\n\
                   sub spl2 { my @p = split ' ', /x/; return @p; }\n\
                   sub grpe { my @a = @_; return grep /x/, @a; }\n\
                   sub tsplit { my ($c) = @_; my @r = $c ? split : (/x/); return @r; }\n";

        // Fixture census: each member but `tsplit` holds exactly one
        // pattern, as a direct argument of its call — so a zero below
        // is the exclusion at work and not a pattern the fixture lost.
        let parser = PerlParser::new(
            src.as_bytes().to_vec(),
            &std::path::PathBuf::from("foo.pl"),
            None,
        );
        let call_arguments = parser
            .root()
            .preorder()
            .filter(|n| {
                matches!(
                    n.kind_id().into(),
                    Perl::PatternMatcher | Perl::PatternMatcherM
                )
            })
            .filter(|n| {
                n.parent()
                    .and_then(|list| list.parent())
                    .is_some_and(|call| {
                        matches!(
                            call.kind_id().into(),
                            Perl::CallExpressionWithSpacedArgs
                                | Perl::CallExpressionWithArgsWithBrackets
                        )
                    })
            })
            .count();
        assert_eq!(call_arguments, 6, "one call-argument pattern per member");

        check_func_space::<PerlParser, _>(src, "foo.pl", |space| {
            assert_members_score(
                &space,
                &[
                    ("spl", 0, 1),
                    ("splp", 0, 1),
                    ("splm", 0, 1),
                    ("splc", 0, 1),
                    ("spl2", 1, 1),
                    ("grpe", 1, 1),
                    ("tsplit", 3, 2),
                ],
            );
        });
    }

    // tree-sitter-perl names its separators, so a trailing `,` or `=>`
    // was read as the last element of a condition list and paid a slot
    // of its own: `if ($a > 1,)` scored 2. `perl -MO=Deparse` reduces
    // every `*_sep` row to its `*_twin`, which is where the expected
    // values come from; the chain rows put the list inside a `&&`
    // operand, which reaches the same peel through
    // `perl_count_chain_operands`.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_trailing_separator_scores_like_its_bare_twin() {
        check_func_space::<PerlParser, _>(
            "sub cmp_twin { my ($a) = @_; if ($a > 1) { g(); } }\n\
             sub cmp_comma { my ($a) = @_; if ($a > 1,) { g(); } }\n\
             sub cmp_fat { my ($a) = @_; if ($a > 1 =>) { g(); } }\n\
             sub var_twin { my ($a) = @_; if ($a) { g(); } }\n\
             sub var_comma { my ($a) = @_; if ($a,) { g(); } }\n\
             sub chain_twin { my ($a, $b) = @_; if (($a > 1) && $b) { g(); } }\n\
             sub chain_comma { my ($a, $b) = @_; if (($a > 1,) && $b) { g(); } }\n",
            "foo.pl",
            |space| {
                assert_members_score(
                    &space,
                    &[
                        ("cmp_twin", 1, 2),
                        ("cmp_comma", 1, 2),
                        ("cmp_fat", 1, 2),
                        ("var_twin", 1, 2),
                        ("var_comma", 1, 2),
                        ("chain_twin", 2, 3),
                        ("chain_comma", 2, 3),
                    ],
                );
            },
        );
    }

    // A pattern's role is read on the outermost `( … )` around it, which
    // is the value inside it, so each `*_paren` row scores as its bare
    // `*_twin` (#1467, #1540); `perl -MO=Deparse` prints each pair
    // identically. The reversed binding is the other direction: in
    // `/foo/ =~ $x` the pattern is the *left* operand, so it first
    // matches `$_` and that result is bound (Deparse: `/foo/ =~ /$x/`) —
    // the match and the `=~` both pay, as in the explicit `rev_twin`.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_pattern_role_reads_through_parentheses() {
        check_func_space::<PerlParser, _>(
            "sub bind_twin { my ($x) = @_; return $x =~ /foo/; }\n\
             sub bind_paren { my ($x) = @_; return $x =~ (/foo/); }\n\
             sub bind_parens_m { my ($x) = @_; return $x =~ (((m{foo}))); }\n\
             sub bind_list { my ($x, $y) = @_; return $x =~ (/foo/, $y); }\n\
             sub bind_list_twin { my ($x, $y) = @_; /foo/; return $x =~ $y; }\n\
             sub split_twin { my ($x) = @_; my @p = split(/foo/, $x); return @p; }\n\
             sub split_paren { my ($x) = @_; my @p = split((/foo/), $x); return @p; }\n\
             sub split_sole { my @p = split(/foo/); return @p; }\n\
             sub subst_twin { my ($x) = @_; $x =~ s/a/b/; return $x; }\n\
             sub subst_paren { my ($x) = @_; $x =~ (s/a/b/); return $x; }\n\
             sub rev { my ($x) = @_; return /foo/ =~ $x; }\n\
             sub rev_twin { my ($x) = @_; my $m = /foo/; return $m =~ $x; }\n",
            "foo.pl",
            |space| {
                assert_members_score(
                    &space,
                    &[
                        ("bind_twin", 1, 1),
                        ("bind_paren", 1, 1),
                        ("bind_parens_m", 1, 1),
                        // A comma operator: `/foo/` matches `$_` and `$y`
                        // is what binds, so the match pays as in the twin.
                        ("bind_list", 2, 1),
                        ("bind_list_twin", 2, 1),
                        ("split_twin", 0, 1),
                        ("split_paren", 0, 1),
                        // The pattern is the whole argument list, which is
                        // the call's own and no wrapper to climb through.
                        ("split_sole", 0, 1),
                        ("subst_twin", 0, 1),
                        ("subst_paren", 0, 1),
                        ("rev", 2, 1),
                        ("rev_twin", 2, 1),
                    ],
                );
            },
        );
    }

    // Only the builtin `split` takes its first pattern as a delimiter:
    // `My::split` is a user sub, so the pattern it is handed is an
    // ordinary match, as it is for `My::other` (#1467). `CORE::split`
    // is the builtin by its full name.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_split_exemption_is_the_builtin_only() {
        check_func_space::<PerlParser, _>(
            "sub mine { my ($x) = @_; my @p = My::split(/foo/, $x); return @p; }\n\
             sub other { my ($x) = @_; my @p = My::other(/foo/, $x); return @p; }\n\
             sub core { my ($x) = @_; my @p = CORE::split(/foo/, $x); return @p; }\n",
            "foo.pl",
            |space| {
                assert_members_score(&space, &[("mine", 1, 1), ("other", 1, 1), ("core", 0, 1)]);
            },
        );
    }

    // ---------- Lua ABC tests ----------

    #[cfg(feature = "lua")]
    #[test]
    fn lua_empty_unit_zero() {
        check_metrics::<LuaParser>("", "empty.lua", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_assignments_count_locals_and_plain() {
        // `local x = 0` wraps an `assignment_statement` under a
        // `variable_declaration`; the inner wrapper still counts.
        // Multi-target assignment `a, b = 1, 2` is a single
        // `assignment_statement` and contributes 1, NOT 2 — the
        // wrapper is the unit of counting (matches the Python rule:
        // one `Assignment` node, one assignment).
        check_metrics::<LuaParser>(
            "function f()\n\
                 local x = 0\n\
                 x = 1\n\
                 local a, b = 1, 2\n\
                 a, b = b, a\n\
             end",
            "foo.lua",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 4);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_calls_are_branches() {
        // `print(x)`, `obj.m(x)`, `obj:m(x)`, `f(g(1))` — every
        // call form is a `function_call` node. The nested
        // `f(g(1))` counts as 2 branches (one per dispatch).
        check_metrics::<LuaParser>(
            "function r(x)\n\
                 print(x)\n\
                 obj.m(x)\n\
                 obj:m(x)\n\
                 return f(g(1))\n\
             end",
            "foo.lua",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 5);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_comparisons_count_logical_ops_do_not() {
        // Each comparison token contributes one condition; `and` /
        // `or` are NOT counted on their own (Fitzpatrick Rule 5;
        // #395) — instead each operand is counted as a unary
        // conditional by the walker (Rule 9; #403). The two
        // `a and b` / `a or b` lines add 2 walker conditions each.
        check_metrics::<LuaParser>(
            "function f(a, b)\n\
                 local r\n\
                 r = a == b\n\
                 r = a ~= b\n\
                 r = a <  b\n\
                 r = a >  b\n\
                 r = a <= b\n\
                 r = a >= b\n\
                 r = a and b\n\
                 r = a or  b\n\
             end",
            "foo.lua",
            |metric| {
                // 8 `r = …` reassignments, plus `local r` (no `=`).
                assert_eq!(metric.abc.assignments_sum(), 8);
                assert_eq!(metric.abc.branches_sum(), 0);
                // 6 comparisons (+6) + 2 logical lines × 2 walker
                // operands (+4) = 10.
                assert_eq!(metric.abc.conditions_sum(), 10);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // #1297: Lua 5.4 brackets a variable attribute with the same two
    // bare tokens a comparison uses, and the `<` / `>` arm had no gate,
    // so `local x <const> = 1` scored two conditions. Two attributes
    // against one genuine `a < b` separate every mis-aim: 5 pre-fix, 1
    // once the arm allows `BinaryExpression`, 0 if it allows the wrong
    // parent or the fixture stops parsing.
    //
    // No fixture-presence anchor is available, unlike the JSX and Perl
    // fixtures: once excluded, a Lua attribute contributes to no ABC
    // axis at all (`local x <const> = 1` and `local x = 1` score
    // identically on assignments, branches and conditions), and it
    // opens no space. Deleting the two attributes would leave this test
    // passing on the `a < b` alone. The coverage that the attributes
    // are reaching the arm is the revert test: removing the gate makes
    // this the only failing test in the suite.
    #[cfg(feature = "lua")]
    #[test]
    fn lua_variable_attributes_are_not_conditions() {
        check_metrics::<LuaParser>(
            "local function f(a, b)\n\
                 local x <const> = 1\n\
                 local y <close> = nil\n\
                 if a < b then return x end\n\
                 return y\n\
             end",
            "foo.lua",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_elseif_and_else_count_conditions() {
        // Each elseif / else arm of the if contributes one
        // condition, mirroring the Python rule.
        check_metrics::<LuaParser>(
            "function f(x)\n\
                 if x > 0 then\n\
                     return 1\n\
                 elseif x < 0 then\n\
                     return -1\n\
                 else\n\
                     return 0\n\
                 end\n\
             end",
            "foo.lua",
            |metric| {
                // Comparisons: `>`, `<` → 2; elseif_statement → 1;
                // else_statement → 1. C = 4. No branches (no calls).
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_complex_function_abc() {
        // Combines every category to pin the metric.
        check_metrics::<LuaParser>(
            "function run(n)\n\
                 local total = 0\n\
                 for i = 1, n do\n\
                     if i % 2 == 0 then\n\
                         do_work(i)\n\
                     else\n\
                         total = total + i\n\
                     end\n\
                 end\n\
                 print(\"done\")\n\
                 return total\n\
             end",
            "foo.lua",
            |metric| {
                // Assignments: `local total = 0` (1), `total = total + i` (1) → 2.
                // Branches: `do_work(i)` (1), `print(\"done\")` (1) → 2.
                // Conditions: `==` (1), `else_statement` (1) → 2.
                assert_eq!(metric.abc.assignments_sum(), 2);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_if_multiple_conditions() {
        // Fitzpatrick Rule 9 walker (issue #403). Lua's `and` / `or`
        // are keyword tokens inside a `binary_expression`.
        check_metrics::<LuaParser>(
            "function f(a, b, c, d)\n\
                 if a or b or c or d then return 1 end       -- +4c\n\
                 if a and b and c then return 2 end          -- +3c\n\
                 if not a and not b then return 3 end        -- +2c\n\
                 return 0\n\
             end",
            "foo.lua",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_while_conditions() {
        // Lua has no `do { ... } while(cond);` — `while cond do …
        // end` and `repeat … until cond` are the loop forms.
        check_metrics::<LuaParser>(
            "function f(a, b)\n\
                 while a or b do break end                   -- +2c\n\
                 repeat break until a and not b              -- +2c\n\
             end",
            "foo.lua",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_short_circuit_with_boolean_literal_operand() {
        // `a and true` reports 2 conditions: one Identifier, one
        // True keyword literal.
        check_metrics::<LuaParser>("function f(a) return a and true end", "foo.lua", |metric| {
            assert_eq!(metric.abc.conditions_sum(), 2);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_number_truthy_condition_counts() {
        // Regression for findings.md #2: Lua treats every non-nil,
        // non-false value as truthy, so `if 1 then ... end` and
        // `return a and 2` should each count their numeric literal
        // as a Fitzpatrick Rule 6 / 7 unary condition. Pre-fix,
        // the former `lua_bool_terminal_kinds!()` listed `True` /
        // `False` / `Nil` but omitted `Number`, so the walker dropped
        // every numeric-truthy operand. The walker comment at the top
        // of the former `lua_inspect_container` already promised
        // numbers were terminal-bool kinds; this commit closed the gap.
        check_metrics::<LuaParser>(
            "function f(a)\n\
             \x20   if 1 then return 1 end\n\
             \x20   return a and 2\n\
             end",
            "foo.lua",
            |metric| {
                // `if 1 then` → walker counts the Number literal (+1).
                // `a and 2` → `and` walker counts both operands:
                //   identifier `a` (+1), Number `2` (+1).
                // Total: 3.
                assert_eq!(metric.abc.conditions_sum(), 3);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_if_boolean_literal_condition() {
        check_metrics::<LuaParser>(
            "function f()\n\
                 if true then end                  -- +1c\n\
                 if not false then end             -- +1c\n\
                 while true do break end           -- +1c\n\
                 repeat break until false          -- +1c\n\
             end",
            "foo.lua",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_methods_arguments_with_conditions() {
        // `m(not a, not b)` — argument list walker counts each
        // unary-conditional argument once. Bare-identifier args
        // (`m(a, b)`) do not count (list_kind != BinaryExpression).
        check_metrics::<LuaParser>(
            "function f(a, b) m(a, b); m(not a, not b) end",
            "foo.lua",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_return_with_conditions() {
        // `return not (z >= 0)` → walker on `not` unwraps the paren
        // chain and reaches the inner BinaryExpression; the inner
        // `>=` comparison is the actual Fitzpatrick condition.
        check_metrics::<LuaParser>(
            "function m1(z) return not (z >= 0) end\n\
             function m2(x) return (((not x))) end\n\
             function m3(x, y) return x and y end",
            "foo.lua",
            |metric| {
                // m1: `>=` (1). `not` wraps a paren'd
                //     BinaryExpression — `lua_count_negated` peels it
                //     to the comparison, which scores itself, so the
                //     return value pays nothing extra. +1.
                // m2: ReturnStatement → iterate expression_list →
                //     `lua_count_negated` peels the parens and the
                //     `not` (which proves boolean) down to `x`, which
                //     does not score itself. +1.
                // m3: x and y → `and` walker counts both → +2.
                // Sum: 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    // ---------- Tcl ABC tests ----------

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_empty_unit_zero() {
        check_metrics::<TclParser>("", "empty.tcl", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
            insta::assert_json_snapshot!(metric.abc);
        });
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_set_command_counts_assignment() {
        // `set` has its own grammar production; each invocation is
        // one assignment.
        check_metrics::<TclParser>(
            "proc f {} {\n\
                 set x 1\n\
                 set y 2\n\
                 set x [expr {$x + $y}]\n\
             }",
            "foo.tcl",
            |metric| {
                // 3 `set` invocations → A=3. The inner `expr` is a
                // sub-command (`command_substitution` + `expr_cmd`),
                // not a `command` node, so it doesn't add a branch.
                assert_eq!(metric.abc.assignments_sum(), 3);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_incr_append_lappend_count_assignment() {
        // Variable-mutation commands (`incr`, `append`, `lappend`)
        // are recognised by name and count as assignments, not
        // branches.
        check_metrics::<TclParser>(
            "proc f {} {\n\
                 set x 0\n\
                 incr x\n\
                 append s \"hi\"\n\
                 lappend lst 1\n\
             }",
            "foo.tcl",
            |metric| {
                // `set` (1) + `incr` (1) + `append` (1) + `lappend`
                // (1) → A=4. No branches, no conditions.
                assert_eq!(metric.abc.assignments_sum(), 4);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_qualified_mutator_commands_count_assignment() {
        // `::incr` is `incr` through the global namespace. Anchored on
        // `branches_sum() == 0` as well as the assignment total: an
        // unresolved name falls to the branch arm, so the two columns
        // move in opposite directions and no single total can mask the
        // regression (#1381 review).
        check_metrics::<TclParser>(
            "proc f {} {\n\
                 ::incr x\n\
                 ::append s \"hi\"\n\
                 ::lappend lst 1\n\
             }",
            "foo.tcl",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 3);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 0);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_namespaced_mutator_command_stays_a_branch() {
        // Control: only the *leading* qualifier names the core command,
        // so `ns::incr` is a user proc and keeps the branch column — the
        // direction `BRACED_WORD_VALUE_CASES` pins for `ns::eval`.
        check_metrics::<TclParser>(
            "proc f {} {\n\
                 ns::incr x\n\
             }",
            "foo.tcl",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 1);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_computed_command_name_is_not_an_assignment() {
        // A command whose leading word is computed (`$cmd args`) names no
        // builtin the parser can resolve, so it stays a branch. Pins the
        // field-addressed, `simple_word`-gated read the classifier shares
        // with the Cognitive / Cyclomatic detectors (grammar-dispatch §3):
        // the earlier `child(0)` byte-slice addressed the slot by position
        // and compared whatever literal text sat there, which agrees with
        // the gated read on today's grammar only because no mutator name is
        // spelled with a leading `$`. A grammar that moved the name out of
        // `child(0)`, or a mutator list that grew a computed-looking entry,
        // would diverge — this fixture is where that surfaces.
        check_metrics::<TclParser>(
            "proc f {cmd x} {\n\
                 $cmd $x\n\
                 incr x\n\
             }",
            "foo.tcl",
            |metric| {
                // `incr x` is the only assignment; `$cmd $x` is a branch.
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 0);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_generic_commands_are_branches() {
        // Anything that isn't `set` or a known mutator command
        // counts as a branch — including builtins like `puts` and
        // `return`.
        check_metrics::<TclParser>(
            "proc f {} {\n\
                 puts \"hello\"\n\
                 do_work 1 2\n\
                 return 0\n\
             }",
            "foo.tcl",
            |metric| {
                // 3 commands, all branches.
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 3);
                assert_eq!(metric.abc.conditions_sum(), 0);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_comparisons_count_logical_ops_do_not() {
        // `expr` predicates expose comparison / logical tokens at
        // the leaf level. Each comparison token contributes one
        // condition; `&&` and `||` are NOT counted on their own
        // (Fitzpatrick Rule 5; #395) — instead each operand is
        // counted as a unary conditional by the walker (Rule 9;
        // #403). The two logical lines add 2 walker conditions
        // each (variable-substitution operands).
        check_metrics::<TclParser>(
            "proc f {a b} {\n\
                 set r [expr {$a == $b}]\n\
                 set r [expr {$a != $b}]\n\
                 set r [expr {$a <  $b}]\n\
                 set r [expr {$a >  $b}]\n\
                 set r [expr {$a <= $b}]\n\
                 set r [expr {$a >= $b}]\n\
                 set r [expr {$a eq $b}]\n\
                 set r [expr {$a ne $b}]\n\
                 set r [expr {$a && $b}]\n\
                 set r [expr {$a || $b}]\n\
             }",
            "foo.tcl",
            |metric| {
                // 10 `set` assignments.
                assert_eq!(metric.abc.assignments_sum(), 10);
                assert_eq!(metric.abc.branches_sum(), 0);
                // 8 comparisons (+8) + 2 logical lines × 2 walker
                // operands (+4) = 12.
                assert_eq!(metric.abc.conditions_sum(), 12);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_ternary_counts_condition() {
        // The `ternary_expr` node is one condition and its condition
        // slot `$a` — a bare truthy test — is another, matching C++'s
        // `int r = a ? b : c;` (also 2). The two branch operands are
        // unnegated and so contribute nothing (#1180).
        check_metrics::<TclParser>(
            "proc f {a b c} {\n\
                 set r [expr {$a ? $b : $c}]\n\
             }",
            "foo.tcl",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.branches_sum(), 0);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    /// The Tcl half of the ternary slot-location guard (#1180).
    ///
    /// `ternary_expr` exposes no grammar fields, so the slots are found
    /// relative to the `?` and `:` tokens. A *parenthesised* condition is
    /// the input that discriminates that from a fixed-index reading:
    /// `_expr` inlines `( … )` as anonymous children of `ternary_expr`,
    /// so `($a) ? !$b : !$c` shifts every operand right by one and
    /// `child(0)` / `child(2)` / `child(4)` land on `(`, `)` and `?`.
    /// Without this case the whole fixed-index revert passes.
    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_parenthesised_ternary_condition_matches_the_bare_form() {
        let conditions = |source: &str| {
            crate::test_support::metrics_verbatim(
                crate::LANG::Tcl,
                source.as_bytes(),
                crate::MetricsOptions::default(),
            )
            .abc
            .conditions_sum()
        };
        let bare = conditions("proc f {a b c} {\n set r [expr {$a ? !$b : !$c}]\n}");
        assert_eq!(bare, 4, "the bare form is the documented reference value");
        assert_eq!(
            conditions("proc f {a b c} {\n set r [expr {($a) ? !$b : !$c}]\n}"),
            bare,
            "parenthesising the condition must not change the count"
        );
    }

    /// A parenthesised operand under `!` counts the same as a bare one.
    ///
    /// `_expr` inlines `( … )` as anonymous children, so `!($a)` puts
    /// `(` where a positional read expects the operand. The walker's
    /// negation branch kept a fixed `child(1)` through the first draft of
    /// #1180 and scored these 0 while the unparenthesised forms scored 1
    /// — an inconsistency the fix itself introduced, since before it
    /// neither form counted. Found in review, not by the tests: the
    /// parenthesised fixtures added with #1180 covered the ternary
    /// *condition* slot only.
    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_parenthesised_negated_operands_match_the_bare_form() {
        let conditions = |source: &str| {
            crate::test_support::metrics_verbatim(
                crate::LANG::Tcl,
                source.as_bytes(),
                crate::MetricsOptions::default(),
            )
            .abc
            .conditions_sum()
        };
        for (bare, parenthesised) in [
            (
                "proc f {a} {\n if {!$a} { puts x }\n}",
                "proc f {a} {\n if {!($a)} { puts x }\n}",
            ),
            (
                "proc f {a b} {\n if {$a && !$b} { puts x }\n}",
                "proc f {a b} {\n if {$a && !($b)} { puts x }\n}",
            ),
            (
                "proc f {a b c} {\n set r [expr {$a ? !$b : !$c}]\n}",
                "proc f {a b c} {\n set r [expr {$a ? !($b) : !$c}]\n}",
            ),
        ] {
            let want = conditions(bare);
            assert!(want > 0, "the bare form must count something: {bare}");
            assert_eq!(
                conditions(parenthesised),
                want,
                "parenthesising the negated operand changed the count\n  bare:  {bare}\n  paren: {parenthesised}"
            );
        }
    }

    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_parenthesised_negated_operands_match_the_bare_form() {
        let conditions = |source: &str| {
            crate::test_support::metrics_verbatim(
                crate::LANG::Irules,
                source.as_bytes(),
                crate::MetricsOptions::default(),
            )
            .abc
            .conditions_sum()
        };
        let want = conditions("when X {\n    if { !$a } { log local0. hi }\n}\n");
        assert_eq!(want, 1);
        assert_eq!(
            conditions("when X {\n    if { !($a) } { log local0. hi }\n}\n"),
            want
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_bare_truthy_and_negated_predicates_count_one_condition() {
        // The headline #1180 fix, on the Tcl side: both were 0 before.
        let conditions = |source: &str| {
            crate::test_support::metrics_verbatim(
                crate::LANG::Tcl,
                source.as_bytes(),
                crate::MetricsOptions::default(),
            )
            .abc
            .conditions_sum()
        };
        assert_eq!(conditions("proc f {a} {\n if {$a} { puts x }\n}"), 1);
        assert_eq!(conditions("proc f {a} {\n if {!$a} { puts x }\n}"), 1);
        assert_eq!(conditions("proc f {a} {\n while {$a} { puts x }\n}"), 1);
        assert_eq!(conditions("proc f {a} {\n while {!$a} { puts x }\n}"), 1);
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_bare_truthy_elseif_predicate_counts_one_condition() {
        // The `Tcl::Elseif` arm routes its predicate through
        // `tcl_condition_expr` exactly as `If` / `While` do (#1180), but
        // a comparison predicate is counted by its leaf operator, so it
        // cannot tell the routing from its absence. Only a bare truthy
        // predicate can: `$b` scores through the routed walker or not at
        // all.
        let conditions = |source: &str| {
            crate::test_support::metrics_verbatim(
                crate::LANG::Tcl,
                source.as_bytes(),
                crate::MetricsOptions::default(),
            )
            .abc
            .conditions_sum()
        };
        // `$a` truthy (1) + `elseif` clause (1) + `$b` truthy (1).
        assert_eq!(
            conditions("proc f {a b} {\n if {$a} { puts x } elseif {$b} { puts y }\n}"),
            3
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_elseif_and_else_count_conditions() {
        // `if` / `elseif` / `else` clause productions each
        // contribute one condition. The leaf comparison inside the
        // predicate is counted independently.
        check_metrics::<TclParser>(
            "proc f {x} {\n\
                 if {$x > 0} {\n\
                     return 1\n\
                 } elseif {$x < 0} {\n\
                     return -1\n\
                 } else {\n\
                     return 0\n\
                 }\n\
             }",
            "foo.tcl",
            |metric| {
                // Branches: three `return` commands → 3.
                // Conditions: `>` (1), `<` (1), `elseif` (1), `else`
                // (1) → 4.
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 3);
                assert_eq!(metric.abc.conditions_sum(), 4);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_if_multiple_conditions() {
        // Fitzpatrick Rule 9 walker (issue #403). Tcl's `expr` slot
        // exposes `&&` / `||` operands as variable substitutions
        // (`$a`, `$b`, …) inside a `binop_expr`.
        check_metrics::<TclParser>(
            "proc f {a b c d} {\n\
                 if {[expr {$a || $b || $c || $d}]} { return 1 }    \n\
                 if {[expr {$a && $b && $c}]} { return 2 }          \n\
                 return 0\n\
             }",
            "foo.tcl",
            |metric| {
                // The two chains feed the walker: 4 + 3 = 7. Each `if`
                // predicate is additionally a bare truthy test of a
                // command substitution — `{[expr {…}]}` is structurally
                // `if {[somecmd]}`, which counts 1 exactly as `if {$a}`
                // does — so 7 + 2 = 9 (#1180). Written without the
                // redundant `[expr …]` wrapper, `if {$a || $b}` scores
                // 2, matching C++'s `if (a || b)`.
                assert_eq!(metric.abc.conditions_sum(), 9);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_while_conditions() {
        // Tcl has no `do { ... } while(cond);` — `while {…} {…}` is
        // the standard loop. The walker fires on `&&` / `||` tokens
        // inside the `expr` predicate.
        check_metrics::<TclParser>(
            "proc f {a b} {\n\
                 while {[expr {$a || $b}]} { break }    \n\
                 while {[expr {$a && $b}]} { break }    \n\
             }",
            "foo.tcl",
            |metric| {
                // 2 + 2 from the chains, plus one bare truthy test per
                // `while` predicate — see `tcl_if_multiple_conditions`
                // (#1180).
                assert_eq!(metric.abc.conditions_sum(), 6);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_short_circuit_with_boolean_literal_operand() {
        // `$a && 1` reports 2 conditions: a VariableSubstitution
        // operand plus a Number-literal operand. Confirms `Number`
        // is in the walker terminal set. `true` / `false` Tcl
        // keywords are not literal tokens in tree-sitter-tcl —
        // they're emitted as the operator-context word, which is
        // captured separately by the `Tcl::Boolean` kind for
        // dedicated `expr {true}` predicates but not as a `&&`
        // operand at this iteration; using a numeric literal keeps
        // the assertion grammar-stable.
        check_metrics::<TclParser>(
            "proc f {a} { return [expr {$a && 1}] }\n",
            "foo.tcl",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_complex_function_abc() {
        // Mixed program covering every category. Tcl's grammar
        // re-parses braced content that looks command-shaped as a
        // nested `command` node, which inflates the branch count
        // relative to a naive read of the source — see breakdown.
        check_metrics::<TclParser>(
            "proc run {n} {\n\
                 set total 0\n\
                 for {set i 0} {$i < $n} {incr i} {\n\
                     if {$i % 2 == 0} {\n\
                         do_work $i\n\
                     } else {\n\
                         incr total $i\n\
                     }\n\
                 }\n\
                 puts \"done\"\n\
                 return $total\n\
             }",
            "foo.tcl",
            |metric| {
                // Assignments: `set total 0` (1), `set i 0` (1),
                // `incr i` (1), `incr total $i` (1) → A = 4.
                // Branches: the outer `for …` is one `command` node;
                // the `{$i < $n}` predicate ALSO re-parses as a
                // `command` node (tree-sitter-tcl treats braced
                // predicates as nested commands at the pinned
                // grammar version); plus `do_work $i`, `puts
                // "done"`, and `return $total`. The for-loop body's
                // `incr` and `incr total $i` are assignment commands
                // and don't add branches. Total B = 5.
                // Conditions: `==` (1) and `else` (1) → C = 2. The
                // `<` inside `{$i < $n}` is NOT `Tcl::LT`: because
                // that predicate re-parses as a `command`, the `<`
                // is emitted as `simple_word`. Only `<` inside a
                // real `expr` production becomes `Tcl::LT`.
                assert_eq!(metric.abc.assignments_sum(), 4);
                assert_eq!(metric.abc.branches_sum(), 5);
                assert_eq!(metric.abc.conditions_sum(), 2);
                insta::assert_json_snapshot!(metric.abc);
            },
        );
    }

    /// The dedicated `set name value` production counts as one assignment.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_set_assignment() {
        check_metrics::<IrulesParser>("when X {\n    set x 1\n}\n", "foo.irule", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 1);
            assert_eq!(metric.abc.branches_sum(), 0);
            assert_eq!(metric.abc.conditions_sum(), 0);
        });
    }

    /// Mutator commands (`incr` / `append` / `lappend`) count as
    /// assignments, not branches — iRules has no assignment operators, so
    /// mutation is always a command invocation.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_mutator_commands() {
        check_metrics::<IrulesParser>(
            "when X {\n    incr x\n    append s \"y\"\n    lappend l 1\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 3);
                assert_eq!(metric.abc.branches_sum(), 0);
            },
        );
    }

    /// `::incr` is `incr` through the global namespace. iRules resolves
    /// the leading word in `irules_command_is_assignment` rather than
    /// through `tcl_command_name`, so this pins the strip on that second
    /// path (#1381 review).
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_qualified_mutator_commands() {
        check_metrics::<IrulesParser>(
            "when X {\n    ::incr x\n    ::append s \"y\"\n    ::lappend l 1\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 3);
                assert_eq!(metric.abc.branches_sum(), 0);
            },
        );
    }

    /// Control: `ns::incr` is a proc in `ns`, so it stays a branch.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_namespaced_mutator_command_stays_a_branch() {
        check_metrics::<IrulesParser>("when X {\n    ns::incr x\n}\n", "foo.irule", |metric| {
            assert_eq!(metric.abc.assignments_sum(), 0);
            assert_eq!(metric.abc.branches_sum(), 1);
        });
    }

    /// Generic (non-mutator) commands count as branches.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_branch_commands() {
        check_metrics::<IrulesParser>(
            "when X {\n    log local0. hi\n    pool p1\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 0);
                assert_eq!(metric.abc.branches_sum(), 2);
                assert_eq!(metric.abc.conditions_sum(), 0);
            },
        );
    }

    /// A numeric comparison (`==`) is one condition; the `log` inside the
    /// `if` body is one branch.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_comparison_condition() {
        check_metrics::<IrulesParser>(
            "when X {\n    if { $a == 1 } { log local0. hi }\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    /// A word-form string comparator (`contains`) is a condition just like
    /// `==` — iRules-specific (Tcl has only `eq`/`ne`/`in`/`ni`). If
    /// `contains` were dropped from the condition set this would report 0.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_string_op_condition() {
        check_metrics::<IrulesParser>(
            "when X {\n    if { $a contains \"x\" } { log local0. hi }\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    /// Each `elseif` / `else` clause is one condition; the three `set`s are
    /// assignments. The leading `if` is not itself a condition.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_elseif_else_conditions() {
        check_metrics::<IrulesParser>(
            "when X {\n    if { $a } { set r 1 } elseif { $b } { set r 2 } else { set r 3 }\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 3);
                // The `elseif` and `else` clauses are one condition each,
                // as before; #1180 adds the two bare truthy predicates
                // (`{ $a }`, `{ $b }`). C++'s
                // `if(a){} else if(b){} else {}` also scores 4.
                assert_eq!(metric.abc.conditions_sum(), 4);
            },
        );
    }

    /// A ternary contributes its own condition plus the `>` comparison in
    /// its test: conditions 2; the `set` is one assignment.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_ternary_condition() {
        check_metrics::<IrulesParser>(
            "when X {\n    set y [expr { $a > 0 ? 1 : 0 }]\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.assignments_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    /// Fitzpatrick Rule 9: the short-circuit `&&` is not itself a condition,
    /// but each negated bare operand (`!$a`, `!$b`) in the chain is. Guards
    /// the `irules_count_condition` chain-operand walk — conditions 2.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_negated_operands_in_chain() {
        check_metrics::<IrulesParser>(
            "when X {\n    if { !$a && !$b } { log local0. hi }\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    /// A bare-truthy `if {$a}` predicate is one condition (#1180).
    ///
    /// It carries no comparison, ternary or short-circuit operator, so
    /// before the Phase 2B slot routing landed nothing invoked the
    /// unary-conditional walker and the whole predicate scored 0 — this
    /// test previously pinned that absence, and the metrics book's ABC
    /// deviation table said so. Now the `if` node routes its `expr`
    /// predicate and the count matches C++'s `if (a)`, which is also 1.
    /// The `log` command remains the single branch.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_bare_truthy_counts_one_condition() {
        check_metrics::<IrulesParser>(
            "when X {\n    if { $a } { log local0. hi }\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    /// The negated form of the same predicate, which was *also* 0 before
    /// #1180: `!$a` reached the walker but no parent seeded boolean
    /// context, so the terminal operand was never counted. Distinct from
    /// `irules_abc_negated_operands_in_chain`, whose `&&` supplied the
    /// seed the bare form lacked.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_negated_bare_truthy_counts_one_condition() {
        check_metrics::<IrulesParser>(
            "when X {\n    if { !$a } { log local0. hi }\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.branches_sum(), 1);
                assert_eq!(metric.abc.conditions_sum(), 1);
            },
        );
    }

    /// The ternary's three operand slots, located relative to the `?`
    /// and `:` tokens because the grammar exposes no fields (#1180).
    ///
    /// `$a ? !$b : !$c` is four: the `ternary_expr` node, the bare
    /// truthy condition, and one per negated branch — the same value
    /// Java, C#, Groovy, the C family, the JS family, PHP, Perl, Ruby
    /// and Python report for the identical expression.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_ternary_routes_its_operand_slots() {
        check_metrics::<IrulesParser>(
            "when X {\n    set y [expr { $a ? !$b : !$c }]\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 4);
            },
        );
    }

    /// The #1161 control: a ternary whose condition is a *comparison*
    /// must not move. The `>` already supplied its condition and the
    /// branches are unnegated, so routing the slots adds nothing.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_comparison_ternary_is_unchanged_by_slot_routing() {
        check_metrics::<IrulesParser>(
            "when X {\n    set y [expr { $a > 0 ? 1 : 0 }]\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.abc.conditions_sum(), 2);
            },
        );
    }

    /// A parenthesised ternary condition scores the same as a bare one.
    ///
    /// The grammar inlines `( … )` as anonymous children of
    /// `ternary_expr` rather than wrapping them in a node, so a
    /// fixed-index reading of the slots would shift right by one and
    /// mis-assign every operand. This is the input that discriminates
    /// the token-relative location the fix uses.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_abc_parenthesised_ternary_condition_matches_the_bare_form() {
        // `check_metrics` takes a bare `fn`, so it cannot carry the
        // first measurement into the second comparison; `metrics_verbatim`
        // returns a value instead.
        let conditions = |source: &str| {
            crate::test_support::metrics_verbatim(
                crate::LANG::Irules,
                source.as_bytes(),
                crate::MetricsOptions::default(),
            )
            .abc
            .conditions_sum()
        };
        let bare = conditions("when X {\n    set y [expr { $a ? !$b : !$c }]\n}\n");
        assert_eq!(bare, 4, "the bare form is the documented reference value");
        assert_eq!(
            conditions("when X {\n    set y [expr { ($a) ? !$b : !$c }]\n}\n"),
            bare,
            "parenthesising the condition must not change the count"
        );
    }

    // #1454's five-language sweep of #1422's C# rule: a pattern-match
    // guard is a condition *slot*, so every spelling of one contributes
    // exactly one condition, and the guard is a cyclomatic decision the
    // arm it guards does not already pay for.
    //
    // Each fixture is the §11 triple — an operator guard (`> 5`, whose
    // comparison token already counted before the fix), a call guard,
    // and a bare-identifier guard (the two that counted nothing) —
    // plus a parenthesised guard, which is the only member that
    // exercises the boolean-context seed, plus an unguarded control
    // that must stay where it was. A single-spelling fixture cannot
    // show the slot works: before the fix the operator member already
    // read the right number.
    //
    // The controls are load-bearing twice over. `none` pins that the
    // slot fires on the guard and not on the arm — a `+1` on every arm
    // would satisfy every guarded row and break this one — and the
    // helper (`is_even` / `isEven`) pins that the call-guard row is
    // scoring its guard rather than its call, since a call is an ABC
    // *branch* everywhere and a condition nowhere.
    //
    // `assert_members_score` rather than `assert_every_member_scores`:
    // the guarded members and their control sit at different values,
    // which is the comparison these tests exist to make.

    #[cfg(feature = "rust")]
    #[test]
    fn rust_match_guard_scores_one_condition_however_spelled() {
        let src = "fn is_even(n: i32) -> bool {
                n == 0
            }
            fn tok(x: i32) -> i32 {
                match x { n if n > 5 => 1, _ => 0 }
            }
            fn call(x: i32) -> i32 {
                match x { n if is_even(n) => 1, _ => 0 }
            }
            fn bare(x: i32, b: bool) -> i32 {
                match x { _ if b => 1, _ => 0 }
            }
            fn paren(x: i32, b: bool) -> i32 {
                match x { n if (b) => n, _ => 0 }
            }
            fn none(x: i32) -> i32 {
                match x { 1 => 1, _ => 0 }
            }";
        assert_fixture_spells::<RustParser>(
            src,
            "foo.rs",
            &[
                // The guard's own `if` keyword, one per guarded member.
                // It is also how Rust cyclomatic already saw the guard,
                // which is why only the ABC half moved here.
                (Rust::If as u16, 4, "match guards"),
                (Rust::GT as u16, 1, "`tok`'s `>`"),
                (Rust::CallExpression as u16, 1, "the `is_even` call"),
                (
                    Rust::ParenthesizedExpression as u16,
                    1,
                    "`paren`'s parenthesised guard",
                ),
                // Two arms per member: the guarded one and its bare `_`.
                (Rust::MatchPattern as u16, 10, "match arms"),
            ],
        );
        check_func_space::<RustParser, _>(src, "foo.rs", |space| {
            assert_members_score(
                &space,
                &[
                    ("is_even", 1, 1),
                    ("tok", 2, 3),
                    // Was 1 — the guard spelling nothing counted.
                    ("call", 2, 3),
                    ("bare", 2, 3),
                    ("paren", 2, 3),
                    ("none", 1, 2),
                ],
            );
        });
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_pattern_switch_guard_scores_one_condition_however_spelled() {
        let src = "class T {
                static boolean isEven(int i) { return i == 0; }
                int tok(Object o) { return switch (o) { case Integer i when i > 5 -> 1; default -> 0; }; }
                int call(Object o) { return switch (o) { case Integer i when isEven(i) -> 1; default -> 0; }; }
                int bare(Object o, boolean b) { return switch (o) { case Integer i when b -> 1; default -> 0; }; }
                int paren(Object o, boolean b) { return switch (o) { case Integer i when (b) -> 1; default -> 0; }; }
                int none(Object o) { return switch (o) { case Integer i -> 1; default -> 0; }; }
            }";
        assert_fixture_spells::<JavaParser>(
            src,
            "foo.java",
            &[
                (Java::Guard as u16, 4, "`when` guards"),
                (Java::GT as u16, 1, "`tok`'s `>`"),
                (Java::MethodInvocation as u16, 1, "the `isEven` call"),
                // Five `switch (o)` subjects plus `paren`'s `when (b)`.
                // Java wraps a switch subject in the same kind, so this
                // count moves if either is edited out.
                (
                    Java::ParenthesizedExpression as u16,
                    6,
                    "the switch subjects and `paren`'s guard",
                ),
            ],
        );
        check_func_space::<JavaParser, _>(src, "foo.java", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    ("isEven", 1, 1),
                    // Was 2 conditions against a *flat* cyclomatic of 2:
                    // Java had neither half of the rule, so the guard
                    // was invisible to cyclomatic and visible to ABC
                    // only through whatever operator it spelled.
                    ("tok", 2, 3),
                    ("call", 2, 3),
                    ("bare", 2, 3),
                    ("paren", 2, 3),
                    ("none", 1, 2),
                ],
            );
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_case_guard_scores_one_condition_however_spelled() {
        let src = "def is_even(n):
    return n == 0
def tok(x):
    match x:
        case n if n > 5:
            return 1
        case _:
            return 0
def call(x):
    match x:
        case n if is_even(x):
            return 1
        case _:
            return 0
def bare(x, b):
    match x:
        case _ if b:
            return 1
        case _:
            return 0
def paren(x, b):
    match x:
        case n if (b):
            return n
        case _:
            return 0
def none(x):
    match x:
        case 1:
            return 1
        case _:
            return 0
";
        assert_fixture_spells::<PythonParser>(
            src,
            "foo.py",
            &[
                // The `case` guard clause. A comprehension filter is the
                // same kind in a different role, and the `guard` field
                // is what keeps it out of the slot — there is none in
                // this fixture, and `python_comprehension_if_clause_is_not_a_case_guard`
                // is where that separation is pinned.
                (Python::IfClause as u16, 4, "`case` guards"),
                (
                    Python::ComparisonOperator as u16,
                    2,
                    "`tok`'s `>` and `is_even`'s `==`",
                ),
                (Python::Call as u16, 1, "the `is_even` call"),
                (
                    Python::ParenthesizedExpression as u16,
                    1,
                    "`paren`'s parenthesised guard",
                ),
            ],
        );
        check_func_space::<PythonParser, _>(src, "foo.py", |space| {
            assert_members_score(
                &space,
                &[
                    ("is_even", 1, 1),
                    ("tok", 2, 3),
                    ("call", 2, 3),
                    ("bare", 2, 3),
                    ("paren", 2, 3),
                    ("none", 1, 2),
                ],
            );
        });
    }

    // A comprehension's `if` filter is an `if_clause` too, and it is not
    // a `case` guard: the slot reads `case_clause`'s `guard` field, so
    // the two cannot be confused by construction. Python cyclomatic does
    // count the filter (through the same `If` keyword token it counts a
    // guard by), and ABC does not — a pre-existing divergence this
    // change deliberately leaves where it found it. The test is here so
    // that a later `IfClause` arm added without the field read fails
    // loudly rather than moving comprehensions silently.
    #[cfg(feature = "python")]
    #[test]
    fn python_comprehension_if_clause_is_not_a_case_guard() {
        let src = "def m(xs):
    return [x for x in xs if x]
";
        assert_fixture_spells::<PythonParser>(
            src,
            "foo.py",
            &[(Python::IfClause as u16, 1, "the comprehension filter")],
        );
        check_func_space::<PythonParser, _>(src, "foo.py", |space| {
            assert_members_score(&space, &[("m", 0, 3)]);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_in_clause_guard_scores_one_condition_however_spelled() {
        let src = "def is_even(x)
  x == 0
end
def tok(x)
  case x
  in [n] if n > 5 then 1
  in _ then 0
  end
end
def call(x)
  case x
  in [n] if n.even? then 1
  in _ then 0
  end
end
def bare(x, b)
  case x
  in [n] if b then 1
  in _ then 0
  end
end
def unguard(x, b)
  case x
  in [n] unless b then 1
  in _ then 0
  end
end
def paren(x, b)
  case x
  in [n] if (b) then 1
  in _ then 0
  end
end
def none(x)
  case x
  in [n] then 1
  in _ then 0
  end
end
";
        assert_fixture_spells::<RubyParser>(
            src,
            "foo.rb",
            &[
                (Ruby::IfGuard as u16, 4, "`if` guards"),
                (Ruby::UnlessGuard as u16, 1, "the `unless` guard"),
                (Ruby::GT as u16, 1, "`tok`'s `>`"),
                (
                    Ruby::ParenthesizedStatements as u16,
                    1,
                    "`paren`'s parenthesised guard",
                ),
            ],
        );
        // `Ruby::Guard` (210) is the hidden `_guard` supertype: the two
        // dispatchers list it beside the concrete kinds so a grammar
        // that starts emitting it keeps working, and this pins that it
        // does not emit it today — otherwise the defensive arm is
        // indistinguishable from a dead one
        // (`.claude/rules/grammar-dispatch.md` §2).
        let parser = RubyParser::new(
            src.as_bytes().to_vec(),
            &std::path::PathBuf::from("foo.rb"),
            None,
        );
        assert!(
            !ast_has_kind_id(&parser, Ruby::Guard as u16),
            "`_guard` stopped being hidden — the defensive arms now fire"
        );
        check_func_space::<RubyParser, _>(src, "foo.rb", |space| {
            assert_members_score(
                &space,
                &[
                    ("is_even", 1, 1),
                    // Was 2 / 2: Ruby had neither half either, and the
                    // arm's own condition supplied the 2 that made the
                    // operator spelling look correct.
                    ("tok", 2, 3),
                    ("call", 2, 3),
                    ("bare", 2, 3),
                    ("unguard", 2, 3),
                    ("paren", 2, 3),
                    ("none", 1, 2),
                ],
            );
        });
    }

    // Elixir is the inverse of the four above: ABC counted the `when`
    // token from the start and cyclomatic had no arm at all, so a guard
    // read as a condition with no decision behind it. #1454 adds the
    // decision, which is why `tok` / `call` / `bare` move on the
    // cyclomatic axis here and on the ABC axis everywhere else.
    //
    // Elixir was also the one language of the six that #1454 left
    // *without* the slot. Its `when` arm added a flat one on top of
    // whatever the guard's sub-structure already scored, so `tok` came
    // back 3 against `call` and `bare`'s 2 — the spelling-dependence the
    // batch exists to remove, and a `.claude/rules/grammar-dispatch.md`
    // §5 double count with the `>` token arm. A whole-branch review of
    // the batch found it; all three rows now read 2, level with the
    // sibling fixtures above and with their own decision counts.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_guard_is_a_decision_however_spelled() {
        let src = "defmodule T do
  def is_even(x) do
    x == 0
  end
  def tok(x) do
    case x do
      n when n > 5 -> 1
      _ -> 0
    end
  end
  def call(x) do
    case x do
      n when is_integer(n) -> 1
      _ -> 0
    end
  end
  def bare(x, b) do
    case x do
      _n when b -> 1
      _ -> 0
    end
  end
  def none(x) do
    case x do
      1 -> 1
      _ -> 0
    end
  end
end
";
        assert_fixture_spells::<ElixirParser>(
            src,
            "foo.ex",
            &[
                (Elixir::When as u16, 3, "`when` guards"),
                (Elixir::GT as u16, 1, "`tok`'s `>`"),
            ],
        );
        check_func_space::<ElixirParser, _>(src, "foo.ex", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    ("is_even", 1, 1),
                    // All three guarded members were cyclomatic 2 —
                    // level with `none` — before the decision arm, and
                    // `tok` was abc 3 before the slot.
                    ("tok", 2, 3),
                    ("call", 2, 3),
                    ("bare", 2, 3),
                    ("none", 1, 2),
                ],
            );
        });
    }

    // A statement modifier's `condition` is the same boolean slot as the
    // block form's, so `g if (b)` must score what `if (b) then g end`
    // does. The modifier kinds were missing from the peel's seed, so a
    // parenthesised operand unwrapped into a context only a negation
    // could mark boolean and scored 0 (#1521). Every member here is one
    // decision, so each reads `conditions == cyclomatic - 1`; `bare` and
    // `block` are the analogues the modifier rows must match.
    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_parenthesised_modifier_condition_scores_one() {
        let src = "def bare(b)
  g if b
end
def block(b)
  if (b) then g end
end
def if1(b)
  g if (b)
end
def if2(b)
  g if ((b))
end
def unless1(b)
  g unless (b)
end
def unless2(b)
  g unless ((b))
end
def while1(b)
  g while (b)
end
def while2(b)
  g while ((b))
end
def until1(b)
  g until (b)
end
def until2(b)
  g until ((b))
end
";
        assert_fixture_spells::<RubyParser>(
            src,
            "foo.rb",
            &[
                (Ruby::IfModifier as u16, 3, "`if` modifiers"),
                (Ruby::UnlessModifier as u16, 2, "`unless` modifiers"),
                (Ruby::WhileModifier as u16, 2, "`while` modifiers"),
                (Ruby::UntilModifier as u16, 2, "`until` modifiers"),
                (
                    Ruby::ParenthesizedStatements as u16,
                    13,
                    "one layer per `(b)`, two per `((b))`",
                ),
            ],
        );
        check_func_space::<RubyParser, _>(src, "foo.rb", |space| {
            assert_members_score(
                &space,
                &[
                    ("bare", 1, 2),
                    ("block", 1, 2),
                    ("if1", 1, 2),
                    ("if2", 1, 2),
                    ("unless1", 1, 2),
                    ("unless2", 1, 2),
                    ("while1", 1, 2),
                    ("while2", 1, 2),
                    ("until1", 1, 2),
                    ("until2", 1, 2),
                ],
            );
        });
    }

    // The slot's whole claim, on every spelling the Elixir grammar gives
    // a guard — and on `assert_every_member_scores`, which asserts §8
    // parity where the fixture above cannot (its unguarded control and
    // its bare-comparison member legitimately sit off their decision
    // counts, which is why that one takes a per-member table).
    //
    // Nine members, nine routes to the same 2:
    //
    //   * `tok` / `eq` — the guard is an operator application, so the
    //     slot adds nothing and the `>` / `==` token arm supplies the
    //     one. These were 3 before the slot.
    //   * `call` / `bare` — no operator counts a `Call` or an
    //     `Identifier`, so the slot supplies the one directly.
    //   * `paren` / `negated` — `block` and `unary_operator` are
    //     wrappers, peeled by `elixir_wrapper_operand` before the slot
    //     asks whether an operator already paid. `negated` covers the
    //     keyword `not`, which the peel once did not recognise as a
    //     negation.
    //   * `membership` / `nonmembership` — `in` / `not in` are
    //     relational operators, given the by-use arm #1461 gave the
    //     other five languages. Without it these two would score zero,
    //     since the slot correctly declines an operator application.
    //
    // A repeated guard (`when a when b`) is deliberately absent: it is
    // an or-chain and scores one per alternative, so it belongs with
    // `elixir_repeated_guard_matches_the_or_chain` below rather than in
    // a table whose every row reads 2.
    //
    // §11: each bullet is an independent path, and no other member can
    // stand in for it — deleting the `in` arm leaves `membership` and
    // `nonmembership` alone failing, deleting the `not` recognition
    // leaves `negated` alone failing.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_guard_scores_one_however_spelled() {
        let src = "defmodule T do
  def tok(x) do
    case x do
      n when n > 5 -> 1
      _ -> 0
    end
  end
  def eq(x) do
    case x do
      n when n == 5 -> 1
      _ -> 0
    end
  end
  def call(x) do
    case x do
      n when is_integer(n) -> 1
      _ -> 0
    end
  end
  def bare(x, b) do
    case x do
      _n when b -> 1
      _ -> 0
    end
  end
  def paren(x, b) do
    case x do
      _n when (b) -> 1
      _ -> 0
    end
  end
  def negated(x, b) do
    case x do
      _n when not b -> 1
      _ -> 0
    end
  end
  def membership(x) do
    case x do
      n when n in [1, 2] -> 1
      _ -> 0
    end
  end
  def nonmembership(x) do
    case x do
      n when n not in [1, 2] -> 1
      _ -> 0
    end
  end
end
";
        assert_fixture_spells::<ElixirParser>(
            src,
            "foo.ex",
            &[
                (Elixir::When as u16, 8, "one `when` guard per member"),
                (Elixir::GT as u16, 1, "`tok`'s `>`"),
                (Elixir::EQEQ as u16, 1, "`eq`'s `==`"),
                (Elixir::Block as u16, 1, "`paren`'s parenthesised guard"),
                (Elixir::Not as u16, 1, "`negated`'s `not`"),
                (Elixir::In as u16, 1, "`membership`'s `in`"),
                (Elixir::Notin as u16, 1, "`nonmembership`'s `not in`"),
            ],
        );
        check_func_space::<ElixirParser, _>(src, "foo.ex", |space| {
            assert_every_member_scores(
                &space.spaces[0],
                8,
                2,
                "one for the `case` arm and one for the guard, however the guard is spelled",
            );
        });
    }

    // Elixir's repeated guard is an or-chain, not a longer spelling of
    // one guard: each `when` expression is tried in turn and evaluation
    // moves to the next when the previous one is false *or raises*. So
    // `when a when b` carries the alternatives `when a or b` does, and
    // the two spellings have to score alike.
    //
    // They did not. The nesting is right-associative
    // (`head when (a when (b when c))`), only the outermost `when` sat
    // on the anchor `elixir_when_is_guard` tests, and the `Abc` slot
    // peeled to the last alternative and scored that one — so a
    // repeated guard read *identically to a single guard* on both axes
    // while the `or` form read one higher per alternative.
    //
    // Asserted as an equality against the `or` spelling rather than
    // against separate literals, so neither row can drift alone; the
    // literals are here too, because a pair of equal wrong numbers
    // would satisfy the equality on its own.
    //
    // Both anchors, because the climb has to reach each: a definition
    // `Call`'s `arguments` (`repeated` / `ored`) and a `stab_clause`'s
    // `left` (`clause` / `clause_or`). `single` is the control the
    // repeated rows must sit *above*, which is the comparison that
    // failed before.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_repeated_guard_matches_the_or_chain() {
        let src = "defmodule T do
  def repeated(n) when is_integer(n) when is_float(n) when is_atom(n) do
    n
  end
  def ored(n) when is_integer(n) or is_float(n) or is_atom(n) do
    n
  end
  def single(n) when is_integer(n) do
    n
  end
  def clause(x) do
    case x do
      n when is_integer(n) when is_float(n) -> 1
      _ -> 0
    end
  end
  def clause_or(x) do
    case x do
      n when is_integer(n) or is_float(n) -> 1
      _ -> 0
    end
  end
end
";
        assert_fixture_spells::<ElixirParser>(
            src,
            "foo.ex",
            &[
                (
                    Elixir::When as u16,
                    8,
                    "three repeated, one `or`-spelled, one single, two \
                     repeated and one `or`-spelled in a clause",
                ),
                (Elixir::Or as u16, 3, "the two `or` spellings' operators"),
            ],
        );
        check_func_space::<ElixirParser, _>(src, "foo.ex", |space| {
            // Positional: a `def` whose head carries a guard parses its
            // name out of a `binary_operator` rather than a plain
            // `Call`, so `repeated`, `ored` and `single` all come back
            // `<anonymous>` (the same naming gap
            // `elixir_typespec_when_is_not_a_guard` reads around).
            let members: Vec<(u64, u64)> = space.spaces[0]
                .spaces
                .iter()
                .map(|m| {
                    (
                        m.metrics.abc.conditions(),
                        m.metrics.cyclomatic.cyclomatic(),
                    )
                })
                .collect();
            assert_eq!(
                members,
                vec![(3, 4), (3, 4), (1, 2), (3, 4), (3, 4)],
                "a repeated guard scores one alternative per `when`; the \
                 single guard is the control one alternative lower"
            );
            assert_eq!(
                members[0], members[1],
                "`when a when b when c` is the or-chain `when a or b or c`"
            );
            assert_eq!(
                members[3], members[4],
                "and the same holds on a `stab_clause` anchor"
            );
        });
    }

    // The gate that makes the Elixir arm safe. Elixir has no dedicated
    // guard production, and a typespec's binding clause spells the same
    // `when` token — so an ungated arm would have made type syntax a
    // decision. It was already an ABC condition against no decision
    // anywhere, which this removes.
    //
    // Both members carry the same `@spec`; only `guarded` carries a real
    // head guard, so the difference between the two rows is the guard
    // and nothing else.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_typespec_when_is_not_a_guard() {
        let src = "defmodule T do
  @spec plain(a) :: a when a: integer
  def plain(x) do
    x
  end
  @spec guarded(a) :: a when a: integer
  def guarded(x) when is_integer(x) do
    x
  end
end
";
        assert_fixture_spells::<ElixirParser>(
            src,
            "foo.ex",
            &[(
                Elixir::When as u16,
                3,
                "two typespec `when`s and one head guard",
            )],
        );
        check_func_space::<ElixirParser, _>(src, "foo.ex", |space| {
            let module = &space.spaces[0];
            // Positional rather than by name: a `def` whose head carries
            // a guard parses its name out of a `binary_operator` instead
            // of a plain `Call` target, and the space comes back
            // `<anonymous>`. That naming gap predates this change and is
            // why `assert_members_score` cannot serve here.
            let members: Vec<(u64, u64)> = module
                .spaces
                .iter()
                .map(|m| {
                    (
                        m.metrics.abc.conditions(),
                        m.metrics.cyclomatic.cyclomatic(),
                    )
                })
                .collect();
            assert_eq!(
                members,
                vec![(0, 1), (1, 2)],
                "`plain` scores nothing; `guarded` scores its head guard \
                 in both metrics"
            );
            // The typespecs sit in the module body, outside either
            // member, so their (non-)contribution has to be read off
            // the container. Was 2 before the gate: one per `@spec`.
            assert_eq!(
                module.metrics.abc.conditions(),
                0,
                "a typespec `when` is type syntax, not a guard"
            );
        });
    }

    // The other half of that gate's allowlist. `elixir_when_is_guard`
    // accepts a definition `Call`'s `arguments` anchor when the call's
    // keyword is a method macro *or* one of `defguard` / `defguardp`,
    // and the second disjunct is its own path: `elixir_is_method_macro`
    // spells only `def` / `defp` / `defmacro` / `defmacrop`, so a
    // `defguard` head reaches the anchor test solely through the
    // `matches!`. Nothing in the suite spelled `defguard` before this,
    // which left the disjunct scored by no fixture at all.
    //
    // `defguard` is where a guard is most obviously a decision — the
    // macro exists to name one — so an ungated head would have scored
    // the construct zero on both axes while the `def f(x) when g`
    // spelling it expands into scores one.
    //
    // Read off the *module*, not off a member: `defguard` is not a
    // method macro, so it opens no function space and its guard lands
    // in the container's body. `plain` is the control that pins the
    // module's rows to the two guards and nothing else, and the guard
    // bodies are calls (`is_integer/1`, `is_atom/1`) rather than
    // comparisons so neither can supply a condition of its own.
    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_defguard_head_is_a_guard() {
        let src = "defmodule T do
  defguard is_int(x) when is_integer(x)
  defguardp is_at(x) when is_atom(x)
  def plain(x) do
    x
  end
end
";
        assert_fixture_spells::<ElixirParser>(
            src,
            "foo.ex",
            &[(
                Elixir::When as u16,
                2,
                "one per `defguard` / `defguardp` head",
            )],
        );
        check_func_space::<ElixirParser, _>(src, "foo.ex", |space| {
            let module = &space.spaces[0];
            assert_eq!(
                (
                    module.metrics.abc.conditions(),
                    module.metrics.cyclomatic.cyclomatic()
                ),
                (2, 3),
                "each of `defguard` and `defguardp` carries one guard, on \
                 both axes (cyclomatic counts from its base of 1)"
            );
            let members: Vec<(u64, u64)> = module
                .spaces
                .iter()
                .map(|m| {
                    (
                        m.metrics.abc.conditions(),
                        m.metrics.cyclomatic.cyclomatic(),
                    )
                })
                .collect();
            assert_eq!(
                members,
                vec![(0, 1)],
                "`defguard` opens no function space, so `plain` is the \
                 module's only member and scores nothing"
            );
        });
    }

    // #1461's structural half: a relational operator scores by *use*,
    // a value-bearing operand scores in a boolean *slot*.
    //
    // Until this, the relational constructs a grammar spells as their
    // own production — C#'s two `is` tests, Java's and Groovy's
    // `instanceof`, Groovy's `in`, Kotlin's `is` / `in`, Ruby's
    // one-line `in` — reached `stats.conditions` only through
    // `<lang>_bool_terminal_kinds!()`, which every walker consults
    // inside a boolean slot and nowhere else. The comparison token
    // beside each of them carried no such gate, so one language scored
    // two spellings of the same relational test differently by
    // position:
    //
    //     val b = a == c        // 1 condition
    //     val b = a is String   // 0 conditions
    //
    // Fitzpatrick Rule 5 scores a relational operator wherever it is
    // written, so the asymmetry was in the mechanism. Each construct
    // now has an unconditional arm in its language's `compute` and has
    // left the terminal set; listing it in both would score it twice
    // (`.claude/rules/grammar-dispatch.md` §5).
    //
    // Every fixture below carries the same four shapes, because they
    // are structurally independent paths and covering one says nothing
    // about the others (§11):
    //
    // - `out*` — the construct with no boolean slot above it. This is
    //   the case the change exists for, and the one no prior fixture
    //   covered: measured against the pre-change binary, every `out*`
    //   member here scored **0**.
    // - `outCtl` — the same member spelling `==`. It read 1 before and
    //   after, so it is the anchor that makes `out*`'s 1 a claim about
    //   the construct rather than about the member shape
    //   (`.claude/rules/testing.md`, "Perturb the fixture as well as
    //   the production line").
    // - `in*` / `inAnd` — the predicate slot and the `&&`-chain walker,
    //   the two paths that already owned the count. They must be
    //   *unchanged*; a §5 double count surfaces here as a 2 against the
    //   control's 1, which is how #1459 caught the Kotlin `as?`
    //   collision.
    // - `forIn` (Kotlin / Groovy / Ruby) — the `for … in …` header,
    //   which spells the same keyword from a different production and
    //   must stay at 0. It is the reason those three count the node and
    //   not the token.

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_is_tests_score_outside_a_boolean_slot() {
        let src = "class A {
                bool outIs(object x) => x is int;
                bool outPat(object x) => x is null;
                bool outCtl(int x) => x == 1;
                int inIs(object x) { if (x is int) { return 1; } return 0; }
                int inAnd(object x, bool b) { if (x is int && b) { return 1; } return 0; }
            }";
        assert_csharp_fixture_spells(
            src,
            &[
                (Csharp::IsExpression as u16, 3, "the bare `is` type tests"),
                (
                    Csharp::IsPatternExpression as u16,
                    1,
                    "`outPat`'s null pattern",
                ),
                (Csharp::EQEQ as u16, 1, "`outCtl`'s comparison"),
            ],
        );
        check_func_space::<CsharpParser, _>(src, "foo.cs", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    // Both were 0, against `outCtl`'s 1 on the same
                    // expression-bodied shape.
                    ("outIs", 1, 1),
                    ("outPat", 1, 1),
                    ("outCtl", 1, 1),
                    // Unchanged: the slot no longer counts the test, the
                    // new arm does, and the total stays put.
                    ("inIs", 1, 2),
                    ("inAnd", 2, 3),
                ],
            );
        });
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_instanceof_scores_outside_a_boolean_slot() {
        let src = "class A {
                boolean outOf(Object x) { return x instanceof String; }
                boolean outCtl(int x) { return x == 1; }
                int inOf(Object x) { if (x instanceof String) { return 1; } return 0; }
                int inAnd(Object x, boolean b) { if (x instanceof String && b) { return 1; } return 0; }
            }";
        assert_fixture_spells::<JavaParser>(
            src,
            "foo.java",
            &[
                (
                    Java::InstanceofExpression as u16,
                    3,
                    "the `instanceof` tests",
                ),
                (Java::EQEQ as u16, 1, "`outCtl`'s comparison"),
            ],
        );
        check_func_space::<JavaParser, _>(src, "foo.java", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    // Was 0, against `outCtl`'s 1 on the same
                    // `return`-a-predicate shape.
                    ("outOf", 1, 1),
                    ("outCtl", 1, 1),
                    ("inOf", 1, 2),
                    ("inAnd", 2, 3),
                ],
            );
        });
    }

    // Groovy carries item 4 as well as the structural pass. `<=>`
    // yields -1 / 0 / 1 rather than a boolean, which is why it never
    // belonged in the terminal set — that set holds operands — but it
    // is a relational operator, and `LTEQGT` is already a condition
    // token in Ruby, PHP, C++ and Mozcpp. Groovy was the outlier at 0.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_relational_productions_score_outside_a_boolean_slot() {
        let src = "class A {
                def outIs(x) { def b = x instanceof String; return b }
                def outIn(x, l) { def b = x in l; return b }
                def outShip(a, c) { def r = a <=> c; return r }
                def outCtl(x) { def b = x == 1; return b }
                def inIs(x) { if (x instanceof String) { return 1 }; return 0 }
                def inIn(x, l) { if (x in l) { return 1 }; return 0 }
                def forIn(l) { for (q in l) { }; return 0 }
            }";
        assert_fixture_spells::<GroovyParser>(
            src,
            "foo.groovy",
            &[
                (
                    Groovy::InstanceofExpression as u16,
                    2,
                    "the `instanceof` tests",
                ),
                (Groovy::MembershipExpression as u16, 2, "the `in` tests"),
                (Groovy::SpaceshipExpression as u16, 1, "`outShip`'s `<=>`"),
                (
                    Groovy::ForInStatement as u16,
                    1,
                    "`forIn`'s loop header, which spells the same `in`",
                ),
                (Groovy::EQEQ as u16, 1, "`outCtl`'s comparison"),
            ],
        );
        check_func_space::<GroovyParser, _>(src, "foo.groovy", |space| {
            assert_members_score(
                &space.spaces[0],
                &[
                    // All three were 0, against `outCtl`'s 1 on the
                    // identical declare-and-return shape.
                    ("outIs", 1, 1),
                    ("outIn", 1, 1),
                    ("outShip", 1, 1),
                    ("outCtl", 1, 1),
                    ("inIs", 1, 2),
                    ("inIn", 1, 2),
                    // The loop header is not a membership test and
                    // stays at 0 — counting the `in` *token* would have
                    // scored it.
                    ("forIn", 0, 2),
                ],
            );
        });
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_is_and_in_score_outside_a_boolean_slot() {
        let src = "class K {
                fun outIs(a: Any): Boolean { val b = a is String; return b }
                fun outIn(a: Int): Boolean { val b = a in 1..2; return b }
                fun outCtl(a: Int): Boolean { val b = a == 1; return b }
                fun inIs(a: Any): Int { if (a is String) { return 1 }; return 0 }
                fun forIn(l: List<Int>): Int { for (q in l) { }; return 0 }
            }";
        assert_kotlin_class_members(
            src,
            &[
                (Kotlin::IsExpression as u16, 2, "the `is` tests"),
                (Kotlin::InExpression as u16, 1, "`outIn`'s `in` test"),
                (
                    Kotlin::ForStatement as u16,
                    1,
                    "`forIn`'s loop header, which spells the same `in`",
                ),
                (Kotlin::EQEQ as u16, 1, "`outCtl`'s comparison"),
            ],
            &[
                // Both were 0, against `outCtl`'s 1 on the identical
                // `val`-and-return shape.
                ("outIs", 1, 1),
                ("outIn", 1, 1),
                ("outCtl", 1, 1),
                ("inIs", 1, 2),
                ("forIn", 0, 2),
            ],
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_test_pattern_scores_outside_a_boolean_slot() {
        let src = "def out_in(a)
  b = a in Integer
  b
end
def out_ctl(a)
  b = a == 1
  b
end
def in_in(a)
  if a in Integer
    return 1
  end
  0
end
def for_in(l)
  for q in l do end
  0
end
";
        assert_fixture_spells::<RubyParser>(
            src,
            "foo.rb",
            &[
                (Ruby::TestPattern as u16, 2, "the one-line `in` tests"),
                (
                    Ruby::For as u16,
                    1,
                    "`for_in`'s loop header, which spells the same `in`",
                ),
                (Ruby::EQEQ as u16, 1, "`out_ctl`'s comparison"),
            ],
        );
        check_func_space::<RubyParser, _>(src, "foo.rb", |space| {
            assert_members_score(
                &space,
                &[
                    // Was 0, against `out_ctl`'s 1 on the identical
                    // assign-and-return shape.
                    ("out_in", 1, 1),
                    ("out_ctl", 1, 1),
                    ("in_in", 1, 2),
                    ("for_in", 0, 2),
                ],
            );
        });
    }

    // #1461 item 1. The walrus is an *operand*, not an operator, so it
    // joined the former `python_bool_terminal_kinds!()` and stays slot-scoped —
    // `b = (n := g())` outside a predicate is a binding, not a
    // decision. Inside one the slot tests `g()`'s truth, and
    // `if (n := g()):` scored 0 where the `if g():` it is a
    // refactoring of scored 1.
    //
    // `assignments` is asserted beside `conditions` because the walrus
    // is the one construct in the survey that pays on two axes, and
    // that is deliberate rather than a §5 double count: ABC's axes are
    // independent measurements of the same source, and `if (n := g()):`
    // genuinely both binds a name and decides a branch. Without this
    // row a later reader has no way to tell the intent from an
    // oversight.
    #[cfg(feature = "python")]
    #[test]
    fn python_walrus_is_a_unary_condition() {
        let src = "def in_slot(g):
    if (n := g()):
        return 1
    return 0

def chain(g, b):
    return b and (n := g())

def ctrl(g):
    if g():
        return 1
    return 0
";
        assert_fixture_spells::<PythonParser>(
            src,
            "foo.py",
            &[(Python::NamedExpression as u16, 2, "the walrus bindings")],
        );
        check_func_space::<PythonParser, _>(src, "foo.py", |space| {
            assert_members_score(
                &space,
                &[
                    // Was 0, against `ctrl`'s 1 for the same predicate
                    // without the binding.
                    ("in_slot", 1, 2),
                    // The `and`-chain walker is the second, independent
                    // path (§11): was 1, the bare `b` operand alone.
                    ("chain", 2, 2),
                    ("ctrl", 1, 2),
                ],
            );
            for (name, assignments) in [("in_slot", 1u64), ("chain", 1), ("ctrl", 0)] {
                assert_eq!(
                    child_space(&space, name).metrics.abc.assignments(),
                    assignments,
                    "{name}: the walrus also pays on the A axis, on purpose"
                );
            }
        });
    }

    // #1461 item 2. A macro in a boolean slot expands to a boolean
    // expression, and `if matches!(x, Some(_))` scored 0 against a
    // cyclomatic decision of 1.
    //
    // `cfg_slot` is in the fixture because the arm's *breadth* is the
    // decision, not a side effect: these sets discriminate on slot and
    // never on return type, so `cfg!` counts exactly as `matches!`
    // does. It is also the construct the corpus actually moves —
    // serde's one changed snapshot is `if cfg!(no_underscore_consts)`,
    // not a `matches!` — so asserting only `matches!` would leave the
    // measured case uncovered.
    #[cfg(feature = "rust")]
    #[test]
    fn rust_macro_invocation_is_a_unary_condition() {
        let src = "fn in_slot(x: Option<u8>) -> u8 { if matches!(x, Some(_)) { 1 } else { 0 } }
fn cfg_slot() -> u8 { if cfg!(unix) { 1 } else { 0 } }
fn chain(x: Option<u8>, b: bool) -> bool { b && matches!(x, Some(_)) }
fn ctrl(x: Option<u8>) -> u8 { if x.is_some() { 1 } else { 0 } }
";
        assert_fixture_spells::<RustParser>(
            src,
            "foo.rs",
            &[(
                Rust::MacroInvocation as u16,
                3,
                "the `matches!` / `cfg!` predicates",
            )],
        );
        check_func_space::<RustParser, _>(src, "foo.rs", |space| {
            assert_members_score(
                &space,
                &[
                    // Each was 1 — the `else` alone — against `ctrl`'s
                    // 2 for the same shape with a method call in the
                    // predicate.
                    ("in_slot", 2, 2),
                    ("cfg_slot", 2, 2),
                    // The `&&`-chain walker, the second independent
                    // path (§11): was 1, the bare `b` operand alone.
                    ("chain", 2, 2),
                    ("ctrl", 2, 2),
                ],
            );
        });
    }
}

/// A comment inside a ternary must not change its ABC conditions
/// (#1181).
///
/// Two opposite defects, one cause: tree-sitter counts a comment among a
/// node's children, so it is the operand's previous sibling *and* it
/// shifts every positional index.
///
/// * Languages whose seed asked "is my previous sibling `?` or `:`"
///   (C family, PHP, Perl, JS family) read the comment as "not a
///   ternary token", flipped the boolean-context seed on for a *branch*
///   slot, and **over**-counted: `a ? /*n*/ (b) : c` scored 3 where
///   `a ? (b) : c` scores 2.
/// * Languages whose branch walk read `child(2)` / `child(4)` (Java,
///   C#, Groovy) landed on the comment instead of the operand, never
///   inspected it, and **under**-counted: `a ? /*n*/ !b : c` scored 2
///   where `a ? !b : c` scores 3.
///
/// Both slots are now addressed by grammar field. The parenthesised
/// operand is the only input that discriminates the first defect and
/// the negated operand the only one that discriminates the second —
/// existing ternary fixtures use neither.
// Gated on the union of the features [`ternary_comment_invariance::cases`]
// has a row for, so a build enabling none of them — `--no-default-features
// --features go` — drops both tests rather than tripping their
// `checked > 0` guards (`.claude/rules/testing.md`, #1286). Both tests
// read the same table, so one gate on the module is exact for each.
#[cfg(test)]
#[cfg(any(
    feature = "c",
    feature = "cpp",
    feature = "csharp",
    feature = "groovy",
    feature = "java",
    feature = "javascript",
    feature = "mozcpp",
    feature = "mozjs",
    feature = "objc",
    feature = "perl",
    feature = "php",
    feature = "typescript"
))]
mod ternary_comment_invariance {
    use crate::test_support::metrics_verbatim;
    use crate::{LANG, MetricsOptions};

    fn conditions(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .abc
            .conditions_sum()
    }

    /// `(base, with_comment)` for a parenthesised and a negated branch
    /// operand, per language.
    fn cases(lang: LANG) -> Option<[(String, String); 2]> {
        // `{}` marks the consequence slot; `/*n*/` the inserted comment.
        let (template, paren, negated, comment) = match lang {
            LANG::Cpp | LANG::C | LANG::Objc | LANG::Mozcpp => {
                ("int f(){ int x = a ? {} : c; }", "(b)", "!b", "/*n*/ ")
            }
            LANG::Java => (
                "class K{ void f(){ int x = a ? {} : c; } }",
                "(b)",
                "!b",
                "/*n*/ ",
            ),
            LANG::Csharp => (
                "class K{ void f(){ var x = a ? {} : c; } }",
                "(b)",
                "!b",
                "/*n*/ ",
            ),
            LANG::Groovy => ("def f(){ def x = a ? {} : c }", "(b)", "!b", "/*n*/ "),
            LANG::Javascript | LANG::Typescript | LANG::Tsx | LANG::Mozjs => {
                ("function f(){ var x = a ? {} : c; }", "(b)", "!b", "/*n*/ ")
            }
            LANG::Php => (
                "<?php function f(){ $x = $a ? {} : $c; }",
                "($b)",
                "!$b",
                "/*n*/ ",
            ),
            // Perl has no block comment: `#` runs to end of line, so the
            // comment must carry its own newline.
            LANG::Perl => ("sub f { my $x = $a ? {} : $c; }", "($b)", "!$b", "# n\n "),
            _ => return None,
        };
        let build = |operand: &str, with_comment: bool| {
            let slot = if with_comment {
                format!("{comment}{operand}")
            } else {
                operand.to_owned()
            };
            template.replace("{}", &slot)
        };
        Some([
            (build(paren, false), build(paren, true)),
            (build(negated, false), build(negated, true)),
        ])
    }

    #[test]
    fn a_comment_before_a_branch_operand_changes_nothing() {
        let mut checked = 0;
        for lang in LANG::into_enum_iter() {
            if !lang.is_enabled() {
                continue;
            }
            let Some(pairs) = cases(lang) else { continue };
            checked += 1;
            for (base, commented) in pairs {
                assert_eq!(
                    conditions(lang, &commented),
                    conditions(lang, &base),
                    "{lang:?}: a comment changed the ABC conditions of a ternary\n  \
                     without: {base}\n  with:    {commented}"
                );
            }
        }
        assert!(
            checked > 0,
            "no ternary language enabled; this test asserted nothing"
        );
    }

    /// The absolute values the invariance test compares against, so a
    /// regression that moved *both* sides equally still fails.
    ///
    /// expected: `a ? (b) : c` counts the `?` marker plus the condition
    /// `a` in boolean context = 2. Negating the consequence adds one
    /// more, since `!b` establishes boolean content for that slot = 3.
    #[test]
    fn the_baseline_values_are_two_and_three() {
        let mut checked = 0;
        for lang in LANG::into_enum_iter() {
            if !lang.is_enabled() {
                continue;
            }
            let Some([(paren, _), (negated, _)]) = cases(lang) else {
                continue;
            };
            assert_eq!(
                conditions(lang, &paren),
                2,
                "{lang:?}: parenthesised branch"
            );
            assert_eq!(conditions(lang, &negated), 3, "{lang:?}: negated branch");
            checked += 1;
        }
        assert!(
            checked > 0,
            "no ternary language enabled; this test asserted nothing"
        );
    }
}

/// A keyword negation must score like its symbolic twin (#1182).
///
/// `not b` and `!b` are the same negation — they differ in precedence,
/// not in meaning, and ABC counts the negation rather than the parse.
/// Ruby and Perl tested only the `!` token, so `if not b` scored 0
/// against `if !b`'s 1, and a `not` ternary scored 2 against the `!`
/// form's 4.
///
/// Lua and Elixir were checked in the same sweep and were already
/// correct: Lua's only negation keyword *is* `not` and it was the token
/// being tested, and Elixir reaches the same count by another path.
/// They are exercised here so a future edit cannot regress them
/// silently. Python counts `not` through its own dispatcher arm and has
/// no `!` spelling to compare against.
// Gated on the union of every row below — the three `pairs` languages
// plus Lua, whose test is separate — so a build enabling none of them
// drops the module instead of failing its guards
// (`.claude/rules/testing.md`, #1286 / #1411). The three tests do *not*
// share a row set, so each carries its own narrower gate: a Lua-only
// build must not be asked to run the Ruby/Perl baselines.
#[cfg(test)]
#[cfg(any(
    feature = "elixir",
    feature = "lua",
    feature = "perl",
    feature = "ruby"
))]
mod keyword_negation_parity {
    use crate::test_support::metrics_verbatim;
    use crate::{LANG, MetricsOptions};

    fn conditions(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .abc
            .conditions_sum()
    }

    /// `(bang_form, keyword_form)` pairs that must score identically.
    #[cfg(any(feature = "elixir", feature = "perl", feature = "ruby"))]
    fn pairs(lang: LANG) -> Option<Vec<(String, String)>> {
        let build =
            |t: &str| -> (String, String) { (t.replace("{NOT}", "!"), t.replace("{NOT}", "not ")) };
        let templates: &[&str] = match lang {
            LANG::Ruby => &[
                "def f(b)\n  if {NOT}b\n    1\n  end\nend\n",
                "def f(a, b, c)\n  x = a ? ({NOT}b) : ({NOT}c)\nend\n",
                "def f(a, b, c)\n  x = a ? b : ({NOT}c)\nend\n",
            ],
            LANG::Perl => &[
                "sub f { if ({NOT}$b) { 1; } }",
                "sub f { my $x = $a ? ({NOT}$b) : ({NOT}$c); }",
                "sub f { my $x = $a ? $b : ({NOT}$c); }",
            ],
            // Already correct before #1182; pinned so they stay that way.
            LANG::Elixir => &["def f(b) do\n  if {NOT}b do\n    1\n  end\nend\n"],
            _ => return None,
        };
        Some(templates.iter().map(|t| build(t)).collect())
    }

    #[test]
    #[cfg(any(feature = "elixir", feature = "perl", feature = "ruby"))]
    fn the_not_keyword_scores_like_bang() {
        let mut checked = 0;
        for lang in LANG::into_enum_iter() {
            if !lang.is_enabled() {
                continue;
            }
            let Some(pairs) = pairs(lang) else { continue };
            checked += 1;
            for (bang, keyword) in pairs {
                assert_eq!(
                    conditions(lang, &keyword),
                    conditions(lang, &bang),
                    "{lang:?}: `not` and `!` scored differently\n  bang:    {bang}\n  keyword: {keyword}"
                );
            }
        }
        assert!(
            checked > 0,
            "no language enabled; this test asserted nothing"
        );
    }

    /// The absolute values, so a regression that moved both spellings
    /// equally still fails.
    ///
    /// expected: `if !b` is one condition — the negated bare operand.
    /// `a ? (!b) : (!c)` is four: the `?` marker, the condition `a` in
    /// boolean context, and one per negated branch operand.
    #[test]
    #[cfg(any(feature = "perl", feature = "ruby"))]
    fn the_baseline_values_are_one_and_four() {
        let mut checked = 0;
        for (lang, guard, ternary) in [
            (
                LANG::Ruby,
                "def f(b)\n  if not b\n    1\n  end\nend\n",
                "def f(a, b, c)\n  x = a ? (not b) : (not c)\nend\n",
            ),
            (
                LANG::Perl,
                "sub f { if (not $b) { 1; } }",
                "sub f { my $x = $a ? (not $b) : (not $c); }",
            ),
        ] {
            if !lang.is_enabled() {
                continue;
            }
            assert_eq!(conditions(lang, guard), 1, "{lang:?}: `if not b`");
            assert_eq!(conditions(lang, ternary), 4, "{lang:?}: `not` ternary");
            checked += 1;
        }
        assert!(
            checked > 0,
            "no language enabled; this test asserted nothing"
        );
    }

    /// Lua's only negation keyword is `not`, so it has no `!` twin to
    /// compare against — its guard is that the keyword counts at all.
    #[test]
    #[cfg(feature = "lua")]
    fn lua_counts_its_only_negation_keyword() {
        // Was a silent `if !is_enabled() { return; }`, which made the
        // whole test a no-op rather than absent whenever the runtime
        // check and the feature disagreed. The `cfg` above is the
        // absence half; this is the loud residual half (#1286).
        assert!(
            LANG::Lua.is_enabled(),
            "compiled under `feature = \"lua\"` but `LANG::Lua` reports disabled; \
             this test asserted nothing"
        );
        assert_eq!(
            conditions(
                LANG::Lua,
                "function f(b)\n  if not b then return 1 end\nend\n"
            ),
            1
        );
    }
}

/// A numeric literal used as a bare `&&` / `||` operand is a Fitzpatrick
/// Rule 9 unary condition in every truthy-valued language (#1379).
///
/// Ruby's terminal-bool set named `integer` and none of `float` /
/// `rational` / `complex`, Elixir's named `integer` and not `float`, and
/// Perl's named no numeric kind at all — so `a && 1.0` scored one
/// condition where `a && 1` scored two, and in Perl even `$a && 1`
/// scored one. Python had both kinds since #772 and is the control the
/// other three were brought level with.
///
/// #1410 closed the six sets #1379 deferred: PHP, Groovy, and the
/// name-keyed C / C++ / Mozcpp / Objective-C set, where the omission
/// was visible *within* one language — `if (true)` scored one condition
/// and `if (1)` none, because `"true"` was in the set and
/// `number_literal` was not.
///
/// The headline claim of each case is a *comparison*: a numeric operand
/// must score exactly what an identifier operand scores in the same slot.
/// That is what discriminates the defect — with the kind missing from the
/// set the numeric form drops while the identifier form does not — and it
/// gives a failure message naming both spellings.
/// `every_operand_scores_its_recorded_values` then pins the absolute
/// numbers, so a regression moving *both* sides equally still fails, and
/// carries the cross-metric anchor `.claude/rules/grammar-dispatch.md` §8
/// asks for.
///
/// Two slots per language, because the sets feed two independent walker
/// paths (grammar-dispatch §11) and Perl's defect showed in both: the
/// operands of a `&&` chain, and the predicate of an `if`. A fixture of
/// only the first leaves `perl_count_condition` and `ruby_count_condition`
/// untested. Since #1520 Ruby's predicate pays for any operand no other
/// arm counts, terminal or not, so for Ruby only the chain half can tell
/// a kind missing from the set; the predicate half pins the slot itself.
///
/// The recorded cyclomatic figure is the same 3 for both slots — one file
/// space, one function space, one decision — while conditions differ (2
/// for the chain, 1 for the predicate, since ABC scores an `if` through
/// its predicate rather than the keyword). So §8's `conditions ==
/// cyclomatic - 1` identity is chain-specific arithmetic, not a law; what
/// generalises is that cyclomatic must not move when only the operand
/// spelling does, which is what makes a `conditions` move unambiguously
/// ABC's.
///
/// `for_each_case` guards the two ways this table could decay into
/// asserting nothing: an emptied `numerics` slice, and a template that
/// loses its `{}` slot (which would make every comparison `x == x`).
/// Both were reachable in the first draft and neither failed a test.
#[cfg(test)]
#[cfg(any(
    feature = "ruby",
    feature = "elixir",
    feature = "perl",
    feature = "python",
    feature = "lua",
    feature = "javascript",
    feature = "php",
    feature = "groovy",
    feature = "c",
    feature = "cpp",
    feature = "mozcpp",
    feature = "objc"
))]
mod numeric_bool_operands {
    use crate::test_support::metrics_verbatim;
    use crate::{LANG, MetricsOptions};

    /// One fixture shape: a source template with a `{}` operand slot, and
    /// the `abc.conditions_sum` / `cyclomatic_sum` every spelling of that
    /// operand must produce.
    type Slot = (&'static str, u64, u64);

    /// A language's two slots, its identifier baseline operand, the
    /// truthy literal operands that must score the same, and how many of
    /// those there should be. Every row but the C family's lists numeric
    /// literals only; that one adds `char_literal`, which is a second
    /// integral-literal kind rather than a second numeric spelling.
    ///
    /// The count is not bookkeeping. `for_each_case` counts *languages*,
    /// so trimming a row's operand list back to `&["1"]` — which is
    /// exactly the pre-#1379 fixture — left the whole module green when
    /// measured. Pinning the length makes that a deliberate two-line
    /// edit instead of a silent one.
    type Case = ([Slot; 2], &'static str, &'static [&'static str], usize);

    fn conditions(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .abc
            .conditions_sum()
    }

    fn cyclomatic_sum(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .cyclomatic
            .cyclomatic_sum()
    }

    /// `([chain_slot, condition_slot], identifier, numerics)` per language.
    ///
    /// `{}` is the right-hand operand of a two-operand short-circuit chain
    /// in the first slot and the whole `if` predicate in the second, so
    /// every fixture differs from its own baseline in exactly one token.
    ///
    /// Each row lists **one spelling per numeric kind the grammar emits**,
    /// which is the unit that matters: #1379's misses were sibling rules
    /// under a shared supertype, not aliases of one rule.
    ///
    /// - Ruby: `integer` / `float` / `rational` / `complex`. `1r` parses
    ///   to `rational(integer)`, `2i` to `complex(integer)` and `1ri` to
    ///   `complex(rational(integer))` — verified by `bca dump` — and the
    ///   walker cannot descend into any wrapper, so listing the wrapper
    ///   is the only way each scores at all. Radix prefixes and `_`
    ///   separators fold into `integer`.
    /// - Perl: all five members of the hidden `_numeric_literals` choice.
    ///   `0xff` and `1.5e10` are here because the first cut of #1379
    ///   named only `integer` and `floating_point` and left them scoring
    ///   1 against an identifier's 2. `017` is *not* a sixth row — it
    ///   lexes as `integer`, and the `octal` kind is unreachable.
    /// - Elixir: `integer` / `float` / `char`. `?a` is the codepoint 97,
    ///   a numeric literal wearing a sigil.
    /// - PHP: `integer` / `float`. Every radix prefix, `_` separator and
    ///   exponent folds into those two, and the `float` *type* keyword
    ///   `Float2` is a third id rendering to the same name that must
    ///   stay out of the set (#1410).
    /// - Groovy: one consolidated `number_literal`, type suffixes
    ///   (`1L`, `1.5f`, `1G`) included.
    /// - C, C++, Mozcpp and Objective-C: one consolidated
    ///   `number_literal`, plus `char_literal` — not a numeric spelling
    ///   but a second integral-literal *kind*, since `'c'` has type
    ///   `int` in C and `char` in C++ and is truthy for the same reason.
    ///   All four share one name-keyed set and so run the same fixture,
    ///   which is the only coverage `Mozcpp` can have: it owns no file
    ///   extension, and `metrics_verbatim` is the one entry point that
    ///   reaches a `LANG` without going through one.
    ///
    /// Python, Lua and JavaScript were already correct and ride along as
    /// controls — they are what the first three were measured against,
    /// and a future edit that breaks them fails here too. Each folds
    /// every radix into one `Number` / `integer` kind, checked by
    /// measurement.
    fn cases(lang: LANG) -> Option<Case> {
        Some(match lang {
            LANG::Ruby => (
                [
                    ("def f(a)\n  a && {}\nend\n", 2, 3),
                    ("def f\n  if {}\n    1\n  end\nend\n", 1, 3),
                ],
                "b",
                &["1", "1.0", "1r", "2i", "1ri"],
                5,
            ),
            LANG::Elixir => (
                [
                    ("def f(a) do\n  a && {}\nend\n", 2, 3),
                    ("def f() do\n  if {} do\n    1\n  end\nend\n", 1, 3),
                ],
                "b",
                &["1", "1.0", "?a"],
                3,
            ),
            LANG::Perl => (
                [
                    ("sub f {\n  my $x = $a && {};\n}\n", 2, 3),
                    ("sub f {\n  if ({}) { 1; }\n}\n", 1, 3),
                ],
                "$b",
                &["1", "1.0", "1.5e10", "0xff"],
                4,
            ),
            LANG::Python => (
                [
                    ("def f(a):\n    return a and {}\n", 2, 3),
                    ("def f():\n    if {}:\n        return 1\n", 1, 3),
                ],
                "b",
                &["1", "1.0", "0xff", "1j"],
                4,
            ),
            LANG::Lua => (
                [
                    ("function f(a)\n  return a and {}\nend\n", 2, 3),
                    ("function f()\n  if {} then return 1 end\nend\n", 1, 3),
                ],
                "b",
                &["1", "1.0", "0xff"],
                3,
            ),
            LANG::Javascript => (
                [
                    ("function f(a) {\n  return a && {};\n}\n", 2, 3),
                    ("function f() {\n  if ({}) { return 1; }\n}\n", 1, 3),
                ],
                "b",
                &["1", "1.0", "0xff"],
                3,
            ),
            LANG::Php => (
                [
                    ("<?php\nfunction f($a) {\n  return $a && {};\n}\n", 2, 3),
                    ("<?php\nfunction f() {\n  if ({}) { return 1; }\n}\n", 1, 3),
                ],
                "$b",
                &["1", "1.0"],
                2,
            ),
            LANG::Groovy => (
                [
                    ("def f(a) {\n  return a && {}\n}\n", 2, 3),
                    ("def f() {\n  if ({}) { return 1 }\n}\n", 1, 3),
                ],
                "b",
                &["1"],
                1,
            ),
            LANG::C | LANG::Cpp | LANG::Mozcpp | LANG::Objc => (
                [
                    ("int f(int a) {\n  return a && {};\n}\n", 2, 3),
                    ("int f() {\n  if ({}) { return 1; }\n}\n", 1, 3),
                ],
                "b",
                &["1", "'c'"],
                2,
            ),
            _ => return None,
        })
    }

    /// Runs `check` once per enabled language that has a case, having
    /// first established that the case can still assert something.
    ///
    /// Three guards, all of which had to be added after the first draft
    /// shipped without them and a measured perturbation of each left the
    /// whole module green:
    ///
    /// - **`checked > 0`** is the non-vacuity half of the rule in
    ///   `.claude/rules/testing.md`. The `#[cfg(any(feature = …))]` on
    ///   this module makes the tests *absent* when no truthy-valued
    ///   language is compiled in; this catches the residual case where
    ///   the runtime `is_enabled()` check stops agreeing with the feature
    ///   it compiled under.
    /// - **the `numerics` list is non-empty and keeps its recorded
    ///   length** — `checked` counts *languages*, so trimming a row's
    ///   numeric list back to `&["1"]` (the pre-#1379 fixture) or
    ///   emptying it left every test passing when measured, with that
    ///   language's coverage deleted. Two assertions, because the
    ///   length check passes an emptied row whose count was zeroed with
    ///   it.
    /// - **every template keeps its `{}`** — without the slot,
    ///   `str::replace` is a no-op, baseline and candidate are computed
    ///   from the same string, and the comparison degenerates to
    ///   `x == x`.
    ///
    /// Sharing one driver means no test can lose any of the three.
    fn for_each_case(check: impl Fn(LANG, Case)) {
        let mut checked = 0;
        for lang in LANG::into_enum_iter() {
            if !lang.is_enabled() {
                continue;
            }
            let Some(case @ (slots, _, numerics, expected_kinds)) = cases(lang) else {
                continue;
            };
            // Emptying a row is the half the length check below cannot
            // see: `&[]` against an `expected_kinds` of 0 agrees with
            // itself, the inner loops run zero times, and `checked` —
            // which counts languages, not spellings — still reads
            // satisfied.
            assert!(
                !numerics.is_empty(),
                "{lang:?}: the numeric-operand list is empty; this language asserted nothing"
            );
            assert_eq!(
                numerics.len(),
                expected_kinds,
                "{lang:?}: the numeric-operand list no longer covers one spelling \
                 per grammar numeric kind"
            );
            for (template, _, _) in slots {
                assert!(
                    template.contains("{}"),
                    "{lang:?}: template lost its `{{}}` operand slot: {template}"
                );
            }
            check(lang, case);
            checked += 1;
        }
        assert!(
            checked > 0,
            "no truthy-valued language enabled; this test asserted nothing"
        );
    }

    #[test]
    fn a_numeric_operand_scores_like_an_identifier_operand() {
        for_each_case(|lang, (slots, identifier, numerics, _)| {
            for (template, _, _) in slots {
                let baseline = conditions(lang, &template.replace("{}", identifier));
                for numeric in numerics {
                    let source = template.replace("{}", numeric);
                    let scored = conditions(lang, &source);
                    assert_eq!(
                        scored, baseline,
                        "{lang:?}: `{numeric}` scored {scored} unary conditions against \
                         `{identifier}`'s {baseline}\n  source: {source}"
                    );
                }
            }
        });
    }

    /// The absolute anchor under the comparison above: every operand
    /// spelling must produce the slot's recorded `conditions`, and must
    /// leave `cyclomatic` alone. The second half is what rules out a
    /// regression that moved both metrics together.
    #[test]
    fn every_operand_scores_its_recorded_values() {
        for_each_case(|lang, (slots, identifier, numerics, _)| {
            for (template, expected_conditions, expected_cyclomatic) in slots {
                for operand in std::iter::once(identifier).chain(numerics.iter().copied()) {
                    let source = template.replace("{}", operand);
                    assert_eq!(
                        conditions(lang, &source),
                        expected_conditions,
                        "{lang:?}: `{operand}` conditions\n  source: {source}"
                    );
                    assert_eq!(
                        cyclomatic_sum(lang, &source),
                        expected_cyclomatic,
                        "{lang:?}: `{operand}` cyclomatic_sum\n  source: {source}"
                    );
                }
            }
        });
    }
}

/// A relational construct with its own grammar production must score
/// like an identifier in the same boolean slot (#1449, #1461).
///
/// Every language here spells at least one boolean test as a dedicated
/// node rather than as a `binary_expression`, so no comparison-token
/// arm ever sees it. A kind missing from the former per-language
/// terminal-kind sets scored **zero**, silently, and zero is
/// indistinguishable from a legitimate zero — which is why the headline
/// claim of each case is a *comparison* against an identifier control
/// in the identical slot rather than an absolute number.
///
/// The constructs, and the route each fix took:
///
/// - **Groovy** `a in l` / `a !in l` (`membership_expression`), counted
///   as a node by `groovy_count_token_condition`. The other four —
///   `a === b` / `a !== b` (`identity_expression`) and `s =~ /p/` /
///   `s ==~ /p/` (`regex_find_expression`, `regex_match_expression`) —
///   are counted there as operator tokens, so all five score outside a
///   boolean slot as `==` does, and `groovy_condition_scores_itself`
///   lists each so the slot holding one does not pay again; a construct
///   takes exactly one of the two routes, never both
///   (`.claude/rules/grammar-dispatch.md` §5).
/// - **Perl** `/^#/` (`pattern_matcher`) and `m{^#}`
///   (`pattern_matcher_m`), the two spellings of a match against the
///   implicit `$_`. They are sibling rules, not aliases, so both are
///   covered — a fixture carrying only the first would have left the
///   `m{}` half at zero and read as covered. Since #1467 they take the
///   other route: a gated arm in `PerlCode::compute` counts them by use,
///   and they have left the former `perl_bool_terminal_kinds!()`.
/// - **Ruby** `a in Integer` (`test_pattern`), the one-line pattern
///   test. Decided against `match_pattern` (`expr => pat`), which
///   raises rather than yielding a boolean.
/// - **Objective-C** `@available(iOS 13.0, *)` and its
///   `__builtin_available` synonym (`available_expression`), the runtime
///   OS-version check. Not relational, but boolean by definition and
///   invisible to every comparison-token arm, so it measured short in
///   exactly the same way (#1457). Its entry landed in the *name*-keyed
///   former `cpp_bool_terminal_kinds!()` that C, C++ and Mozcpp shared, which is
///   why `the_c_family_grammars_do_not_emit_available_expression` below
///   pins the inertness the other three rely on.
///
/// Rust's `matches!(…)` measures short in the same way, and is
/// deliberately **not** here: its fix is `macro_invocation`, which also
/// catches `cfg!` / `dbg!` / `todo!`, and the one corpus snapshot it
/// moves is a `cfg!` rather than a `matches!`. That breadth is what
/// #1461 item 2 exists to decide, so it is left to that issue rather
/// than settled by inclusion here.
///
/// Two slots per language, because they are two independent walker
/// paths (§11) and every construct above measured short in **both**: the
/// operands of a `&&` chain, and the predicate of an `if`. A fixture of
/// only one leaves the other untested.
///
/// Each row also carries the construct's negated spelling, which reaches
/// the construct only through the language's value peel: the `!…` /
/// `(…)` wrapper is peeled before `count_boolean_slot` asks
/// `<lang>_condition_scores_itself` whether the operand already paid.
/// Without a negated row the peel is the path no fixture here exercises.
///
/// Since #1526 no language here has a terminal-kind set: the chain
/// operands and the slots both score through the shared
/// `count_boolean_slot` rule, and Perl's rows score through the by-use
/// arm (#1467).
///
/// The `cyclomatic` half of `every_construct_scores_its_recorded_values`
/// is what rules out a regression that moved both metrics together:
/// cyclomatic must not move when only the operand spelling does, which
/// is what makes a `conditions` move unambiguously ABC's. The recorded
/// figures differ per slot (Rust's chain slot carries the extra `&&`
/// decision), so each slot pins its own pair rather than sharing one.
// Gated on the union of the three languages with rows, so a build
// enabling none of them drops the module instead of failing its
// guards (`.claude/rules/testing.md`, #1286 / #1411).
#[cfg(test)]
#[cfg(any(
    feature = "groovy",
    feature = "perl",
    feature = "ruby",
    feature = "objc"
))]
mod own_production_bool_constructs {
    use crate::test_support::metrics_verbatim;
    use crate::{LANG, MetricsOptions};

    /// One fixture shape: a source template with a `{}` slot for the
    /// whole boolean expression, and the `abc.conditions_sum` /
    /// `cyclomatic_sum` every spelling in that slot must produce.
    type Slot = (&'static str, u64, u64);

    /// A language's two slots, its identifier control, the constructs
    /// that must score the same, and how many of those there should be.
    ///
    /// The count is not bookkeeping. `for_each_case` counts *languages*,
    /// so trimming Groovy's list back to a single construct — or
    /// dropping Perl's `m{}` half, which is a separate grammar rule from
    /// its `//` half — leaves the module green with that coverage
    /// deleted. Pinning the length makes such a trim a deliberate
    /// two-line edit instead of a silent one.
    type Case = ([Slot; 2], &'static str, &'static [&'static str], usize);

    fn conditions(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .abc
            .conditions_sum()
    }

    fn cyclomatic_sum(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .cyclomatic
            .cyclomatic_sum()
    }

    /// `([chain_slot, predicate_slot], identifier, constructs)` per
    /// language.
    ///
    /// `{}` is the left-hand operand of a two-operand short-circuit
    /// chain in the first slot and the whole `if` predicate in the
    /// second, so every fixture differs from its own control in exactly
    /// the construct under test.
    ///
    /// Ruby's chain slot parenthesises the slot because `in` binds
    /// looser than `&&` there; the control is parenthesised identically,
    /// so the parens cancel out of the comparison and the peel unwraps
    /// them for both sides alike.
    fn cases(lang: LANG) -> Option<Case> {
        Some(match lang {
            LANG::Groovy => (
                [
                    ("def f(a, b, l, s) {\n  return {} && b\n}\n", 2, 3),
                    ("def f(a, b, l, s) {\n  if ({}) { return 1 }\n}\n", 1, 3),
                ],
                "b",
                &[
                    "a in l",
                    "a !in l",
                    "a === b",
                    "a !== b",
                    "s =~ /p/",
                    "s ==~ /p/",
                    "!(a in l)",
                    // The indexing / navigation kinds added by #1466.
                    // These two are the cyclomatic-neutral ones, so
                    // they belong in this module's same-as-the-control
                    // shape. The three *null-safe* spellings (`a?.b`,
                    // `a??.b`, `l?[0]`) each short-circuit on a null
                    // receiver and so add a cyclomatic decision, which
                    // a row whose contract is "the control's
                    // cyclomatic" cannot express; they get their own
                    // test,
                    // `groovy_safe_navigation_closes_the_two_below_gap`,
                    // which anchors them on that axis explicitly.
                    "l[0]",
                    "a.@b",
                ],
                9,
            ),
            LANG::Perl => (
                [
                    ("sub f {\n  my $x = {} && $b;\n}\n", 2, 3),
                    ("sub f {\n  if ({}) { 1; }\n}\n", 1, 3),
                ],
                "$a",
                &["/^#/", "m{^#}", "!/^#/"],
                3,
            ),
            LANG::Ruby => (
                [
                    ("def f(a)\n  ({}) && b\nend\n", 2, 3),
                    ("def f(a)\n  if {}\n    1\n  end\nend\n", 1, 3),
                ],
                "a",
                &["a in Integer", "!(a in Integer)"],
                2,
            ),
            // Objective-C's `@available` is not relational like the
            // constructs above, but it reaches the terminal set by the
            // route Groovy's `in` takes: a dedicated `available_expression`
            // production whose value is a boolean, seen by no
            // comparison-token arm (#1457). Both spellings are listed
            // because they are alternatives of one rule's leading token
            // rather than two rules — so unlike Perl's `m{}` above they
            // cannot drift apart, and the second row is here to keep that
            // claim measured rather than assumed.
            LANG::Objc => (
                [
                    ("int f(int a) {\n  return {} && b;\n}\n", 2, 3),
                    ("int f() {\n  if ({}) { return 1; }\n}\n", 1, 3),
                ],
                "a",
                &[
                    "@available(iOS 13.0, *)",
                    "__builtin_available(macOS 10.15, *)",
                    "!@available(iOS 13.0, *)",
                ],
                3,
            ),
            _ => return None,
        })
    }

    /// Runs `check` once per enabled language that has a case, having
    /// first established that the case can still assert something.
    ///
    /// The four guards mirror `numeric_bool_operands::for_each_case`,
    /// where each was added only after a measured perturbation of it
    /// left that module green: `checked > 0` for the runtime half of
    /// the feature gate, a non-empty construct list and its recorded
    /// count so a trimmed row cannot vanish silently, and the `{}` slot
    /// so `str::replace` does not degenerate into comparing a string
    /// with itself.
    fn for_each_case(check: impl Fn(LANG, Case)) {
        let mut checked = 0;
        for lang in LANG::into_enum_iter() {
            if !lang.is_enabled() {
                continue;
            }
            let Some(case @ (slots, _, constructs, expected_constructs)) = cases(lang) else {
                continue;
            };
            // Both halves are needed, and the second does not imply the
            // first. The length check alone only asserts that the list
            // and its recorded count *agree*, so emptying a row and
            // setting its count to 0 — the shape a careless "the test
            // failed, fix the number" edit takes — deleted that
            // language's coverage with both tests still green when
            // measured.
            assert!(
                !constructs.is_empty(),
                "{lang:?}: the construct list is empty; this language asserted nothing"
            );
            assert_eq!(
                constructs.len(),
                expected_constructs,
                "{lang:?}: the construct list no longer covers every own-production \
                 boolean spelling this language was fixed for"
            );
            for (template, _, _) in slots {
                assert!(
                    template.contains("{}"),
                    "{lang:?}: template lost its `{{}}` slot: {template}"
                );
            }
            check(lang, case);
            checked += 1;
        }
        assert!(
            checked > 0,
            "no language with an own-production boolean construct enabled; \
             this test asserted nothing"
        );
    }

    #[test]
    fn an_own_production_construct_scores_like_an_identifier() {
        for_each_case(|lang, (slots, identifier, constructs, _)| {
            for (template, _, _) in slots {
                let baseline = conditions(lang, &template.replace("{}", identifier));
                for construct in constructs {
                    let source = template.replace("{}", construct);
                    let scored = conditions(lang, &source);
                    assert_eq!(
                        scored, baseline,
                        "{lang:?}: `{construct}` scored {scored} conditions against \
                         `{identifier}`'s {baseline}\n  source: {source}"
                    );
                }
            }
        });
    }

    /// Groovy's three null-safe spellings, on the cyclomatic axis.
    ///
    /// They cannot ride the rows above, whose contract is "scores the
    /// control's `conditions` *and* the control's `cyclomatic`":
    /// the boolean-slot rule (`groovy_count_condition`) does not move cyclomatic, but
    /// `?.` (`QMARKDOT`), `??.` (`QMARKQMARKDOT`) and `?[`
    /// (`QMARKLBRACK`) are already cyclomatic decisions in their own
    /// right (`src/metrics/cyclomatic/groovy.rs`), so each spelling
    /// scores the control's conditions against the control's cyclomatic
    /// **plus one**. That is the whole reason this family was the worst
    /// case in #1466: before the fix ABC sat *two* below its own
    /// decision count on `if (a?.b)`, against one below for every other
    /// spelling.
    ///
    /// `l?[0]` joined the family in #1471. It sat in the neutral rows
    /// above until then, passing only because Groovy cyclomatic had no
    /// `?[` arm — a fixture that would have rejected the fix for the
    /// very gap it recorded.
    ///
    /// Asserting the offset rather than the bare conditions is what
    /// makes this a §5 double-count guard as well. If a later change
    /// added `QMARKDOT` to `groovy_count_token_condition`'s arm while
    /// the wrapper stayed in the terminal set, `conditions` would go to
    /// `control + 1` and this test — not a snapshot — would say so.
    #[test]
    #[cfg(feature = "groovy")]
    fn groovy_safe_navigation_closes_the_two_below_gap() {
        for (template, control_conditions, control_cyclomatic) in [
            ("def f(a, b, l) {\n  return {} && b\n}\n", 2, 3),
            ("def f(a, b, l) {\n  if ({}) { return 1 }\n}\n", 1, 3),
        ] {
            let control = template.replace("{}", "b");
            assert_eq!(conditions(LANG::Groovy, &control), control_conditions);
            assert_eq!(cyclomatic_sum(LANG::Groovy, &control), control_cyclomatic);

            for spelling in ["a?.b", "a??.b", "l?[0]"] {
                let source = template.replace("{}", spelling);
                assert_eq!(
                    conditions(LANG::Groovy, &source),
                    control_conditions,
                    "`{spelling}` conditions\n  source: {source}"
                );
                assert_eq!(
                    cyclomatic_sum(LANG::Groovy, &source),
                    control_cyclomatic + 1,
                    "`{spelling}` cyclomatic_sum: the navigation operator's own \
                     decision has moved\n  source: {source}"
                );
            }
        }
    }

    /// The `!` operand is read by field, so an `extra` cannot hide it.
    ///
    /// `groovy_wrapper_operand` took `child(1)` until #1466, which is
    /// the `!` operand only when nothing sits between the two. A comment
    /// is an `extra` and occupies that slot, so `if (! /*c*/ a)` scored
    /// zero conditions where `if (!a)` scored one — the positional-read
    /// class grammar-dispatch §3 is about, and the observable half of
    /// the peel rewrite.
    ///
    /// `parenthesized_expression` names nothing in node-types.json, so
    /// it kept the positional read, and the bug, until #1455 read it as
    /// the first operand that is not an extra.
    #[test]
    #[cfg(feature = "groovy")]
    fn groovy_negation_operand_survives_an_interposed_comment() {
        let template = "def f(a) {\n  if ({}) { return 1 }\n}\n";

        assert_eq!(conditions(LANG::Groovy, &template.replace("{}", "!a")), 1);
        assert_eq!(
            conditions(LANG::Groovy, &template.replace("{}", "! /*c*/ a")),
            1,
            "the `!` operand is being read positionally again; a comment displaces it"
        );

        assert_eq!(conditions(LANG::Groovy, &template.replace("{}", "(a)")), 1);
        assert_eq!(
            conditions(LANG::Groovy, &template.replace("{}", "( /*c*/ a)")),
            1,
            "the parenthesised operand is being read positionally again; a comment \
             displaces it"
        );
    }

    /// The arithmetic unary operators are values, not wrappers.
    ///
    /// `groovy_count_condition` routed every `unary_expression` to the
    /// peel while the peel handled only the `!` spelling, so the arm
    /// claimed `~a` / `-a` / `+a` and dropped them
    /// (grammar-dispatch §7). Since #1526 the slot pays for any
    /// predicate no other arm counts — Groovy truth makes `if (-a)` a
    /// decision — so the three spellings score what `a` does. Outside a
    /// slot they are no negation, so a call argument scores nothing for
    /// them, while `!-a` scores its negation once.
    #[test]
    #[cfg(feature = "groovy")]
    fn groovy_arithmetic_unary_is_a_value_not_a_wrapper() {
        let template = "def f(a) {\n  if ({}) { return 1 }\n}\n";
        let call = "def f(a) {\n  g({})\n}\n";

        assert_eq!(conditions(LANG::Groovy, &template.replace("{}", "a")), 1);
        for spelling in ["~a", "-a", "+a"] {
            assert_eq!(
                conditions(LANG::Groovy, &template.replace("{}", spelling)),
                1,
                "`{spelling}` in a slot pays as `a` does"
            );
            assert_eq!(
                conditions(LANG::Groovy, &call.replace("{}", spelling)),
                0,
                "`{spelling}` outside a slot is not a negation"
            );
            let negated = format!("!{spelling}");
            assert_eq!(
                conditions(LANG::Groovy, &call.replace("{}", &negated)),
                1,
                "`{negated}` outside a slot is one negation"
            );
        }
    }

    /// The two Perl spellings must remain two distinct grammar kinds.
    ///
    /// The bare-match arm of `PerlCode::compute` lists `PatternMatcher`
    /// **and** `PatternMatcherM` on the stated grounds that `/^#/` and `m{^#}`
    /// are sibling rules rather than aliases of one. Nothing above pins
    /// that: if a grammar bump collapsed `m{}` onto `pattern_matcher`,
    /// both fixtures would keep scoring through the surviving entry,
    /// the `PatternMatcherM` arm would become dead code, and every test
    /// in this module would stay green — the silent-drift shape lesson
    /// 34 and grammar-dispatch §2 exist to catch.
    ///
    /// Asserting the ids differ is not enough on its own, since two
    /// distinct enum variants prove nothing about what the parser
    /// emits. So each spelling is parsed and required to produce its
    /// own kind and not the other's.
    #[test]
    #[cfg(feature = "perl")]
    fn the_two_perl_match_spellings_are_distinct_kinds() {
        use crate::{ParserTrait, Perl, PerlParser};
        use big_code_analysis_ast::test_support::ast_has_kind_id;

        assert_ne!(
            Perl::PatternMatcher as u16,
            Perl::PatternMatcherM as u16,
            "the two spellings share one kind id; one bare-match arm entry is dead"
        );

        for (src, present, absent) in [
            (
                "sub f { if (/^#/) { 1; } }",
                ("pattern_matcher", Perl::PatternMatcher as u16),
                ("pattern_matcher_m", Perl::PatternMatcherM as u16),
            ),
            (
                "sub f { if (m{^#}) { 1; } }",
                ("pattern_matcher_m", Perl::PatternMatcherM as u16),
                ("pattern_matcher", Perl::PatternMatcher as u16),
            ),
        ] {
            let parser = PerlParser::new(
                src.as_bytes().to_vec(),
                &std::path::PathBuf::from("f.pl"),
                None,
            );
            let (present_name, present_id) = present;
            let (absent_name, absent_id) = absent;
            assert!(
                ast_has_kind_id(&parser, present_id),
                "`{src}` no longer emits `{present_name}`"
            );
            assert!(
                !ast_has_kind_id(&parser, absent_id),
                "`{src}` now also emits `{absent_name}`; the two spellings have \
                 collapsed and one bare-match arm entry is dead"
            );
        }
    }

    /// The absolute anchor under the comparison above: every spelling
    /// must produce the slot's recorded `conditions`, and must leave
    /// `cyclomatic` alone.
    #[test]
    fn every_construct_scores_its_recorded_values() {
        for_each_case(|lang, (slots, identifier, constructs, _)| {
            for (template, expected_conditions, expected_cyclomatic) in slots {
                for spelling in std::iter::once(identifier).chain(constructs.iter().copied()) {
                    let source = template.replace("{}", spelling);
                    assert_eq!(
                        conditions(lang, &source),
                        expected_conditions,
                        "{lang:?}: `{spelling}` conditions\n  source: {source}"
                    );
                    assert_eq!(
                        cyclomatic_sum(lang, &source),
                        expected_cyclomatic,
                        "{lang:?}: `{spelling}` cyclomatic_sum\n  source: {source}"
                    );
                }
            }
        });
    }
}

/// A Perl statement modifier must score like the block form it is
/// shorthand for (#1464).
///
/// `return 1 if $x;` and `if ($x) { return 1; }` are the same decision
/// written two ways, and the modifier is the idiomatic Perl spelling —
/// `next unless $ok;`, `warn "..." if $debug;`. Perl's *cyclomatic*
/// dispatcher already counted all six modifier kinds, so this was a
/// straight ABC undercount against Perl's own decision count rather
/// than a policy disagreement between the two metrics.
///
/// Each pair is asserted equal **and** equal to a literal, so a
/// regression that zeroed both spellings still fails. The fixtures are
/// spell-anchored because the modifier is the only thing in them that
/// scores a condition: deleting `if $x` from the modifier fixture would
/// otherwise turn it into a silent copy of nothing at all
/// (`.claude/rules/testing.md`, "Perturb the fixture as well as the
/// production line").
#[cfg(test)]
#[cfg(feature = "perl")]
mod perl_statement_modifier_parity {
    use crate::test_support::{assert_perl_fixture_spells, metrics_verbatim};
    use crate::{LANG, MetricsOptions, Perl};

    fn conditions(source: &str) -> u64 {
        metrics_verbatim(LANG::Perl, source.as_bytes(), MetricsOptions::default())
            .abc
            .conditions_sum()
    }

    /// `(keyword, kind id, kind name)` — the four modifier keywords
    /// whose grammar slot is a `condition`. `for` / `foreach` is the
    /// fifth spelling and is covered by its own test below; `when` is
    /// the sixth and has no fixture at all, being unreachable from
    /// valid Perl (see `perl_walk_statement_modifier`).
    const CONDITION_MODIFIERS: [(&str, u16, &str); 4] = [
        ("if", Perl::IfSimpleStatement as u16, "if_simple_statement"),
        (
            "unless",
            Perl::UnlessSimpleStatement as u16,
            "unless_simple_statement",
        ),
        (
            "while",
            Perl::WhileSimpleStatement as u16,
            "while_simple_statement",
        ),
        (
            "until",
            Perl::UntilSimpleStatement as u16,
            "until_simple_statement",
        ),
    ];

    #[test]
    fn a_modifier_scores_like_its_block_form() {
        assert!(
            LANG::Perl.is_enabled(),
            "compiled under `feature = \"perl\"` but `LANG::Perl` reports disabled; \
             this test asserted nothing"
        );
        for (keyword, kind, name) in CONDITION_MODIFIERS {
            let modifier = format!("sub f {{ my $x = shift; return 1 {keyword} $x; }}");
            let block = format!("sub f {{ my $x = shift; {keyword} ($x) {{ return 1; }} }}");
            assert_perl_fixture_spells(&modifier, &[(kind, 1, name)]);
            assert_eq!(
                conditions(&modifier),
                conditions(&block),
                "`{keyword}` modifier and block form disagree\n  modifier: {modifier}\n  block:    {block}"
            );
            assert_eq!(
                conditions(&modifier),
                1,
                "`{keyword}` modifier: the bare scalar predicate is one condition"
            );
        }
    }

    /// The modifier's `condition` field goes through the shared
    /// condition classifier, not a flat `+1`, so a compound predicate
    /// keeps its sub-structure — three shapes the block form already
    /// scores above and below one.
    #[test]
    fn a_modifier_condition_keeps_its_substructure() {
        for (predicate, expected) in [("!$x", 1), ("($x)", 1), ("$x && $x", 2), ("$x > 2", 1)] {
            let modifier = format!("sub f {{ my $x = shift; return 1 if {predicate}; }}");
            let block = format!("sub f {{ my $x = shift; if ({predicate}) {{ return 1; }} }}");
            assert_perl_fixture_spells(
                &modifier,
                &[(Perl::IfSimpleStatement as u16, 1, "if_simple_statement")],
            );
            assert_eq!(
                conditions(&modifier),
                expected,
                "`if {predicate}` modifier\n  source: {modifier}"
            );
            assert_eq!(
                conditions(&block),
                expected,
                "`if ({predicate})` block form\n  source: {block}"
            );
        }
    }

    /// The `for` / `foreach` modifier iterates a list and is not a
    /// boolean test — the grammar names its slot `list`, not
    /// `condition`. Pinned against the `if` modifier so the zero reads
    /// as a decision rather than as an arm nothing reaches.
    ///
    /// Measured: simply *adding* `ForSimpleStatement` to the dispatch
    /// arm does not fail this test, because the walker reads the slot by
    /// field name and `for_simple_statement` exposes no `condition` —
    /// the exclusion is structural, not a listed omission. What it does
    /// catch is a rework that reaches the slot some other way (a child
    /// index, the `list` field) or a grammar that renames the field.
    #[test]
    fn the_for_modifier_is_not_a_condition() {
        for keyword in ["for", "foreach"] {
            let source = format!("sub f {{ my $x = shift; print 5 {keyword} @$x; }}");
            assert_perl_fixture_spells(
                &source,
                &[(Perl::ForSimpleStatement as u16, 1, "for_simple_statement")],
            );
            let abc =
                metrics_verbatim(LANG::Perl, source.as_bytes(), MetricsOptions::default()).abc;
            assert_eq!(abc.conditions_sum(), 0, "`{keyword}` modifier: {source}");
            // The expected value *is* the default, so the zero above
            // proves nothing on its own — a fixture that stopped
            // parsing would satisfy it too. `my $x = shift` is the
            // file's one assignment, and `shift` and `print 5` its two
            // branches; all three must survive.
            assert_eq!(
                abc.assignments_sum(),
                1,
                "`{keyword}`: fixture stopped scoring"
            );
            assert_eq!(
                abc.branches_sum(),
                2,
                "`{keyword}`: fixture stopped scoring"
            );
        }
        assert_eq!(
            conditions("sub f { my $x = shift; return 1 if $x; }"),
            1,
            "control: the `if` modifier still counts, so the zero above is a \
             policy decision and not a dead arm"
        );
    }
}

/// A non-numeric literal in a boolean operand slot must score like an
/// identifier in the same slot (#1462).
///
/// The sibling module above pins the *numeric* half, closed by #1410.
/// The non-numeric literals were never swept and were missing from
/// every set the numerics were added to — same mechanism, same silent
/// zero, same file. Measured before the fix, every row below scored
/// exactly one condition short of its identifier control, in **both**
/// slots: `x || "default"` — the language's commonest truthy-default
/// idiom — reported 1 against `x || y`'s 2.
///
/// Scope is the eleven truthy-valued sets. #1462 shipped eight of them
/// and called that complete; a whole-branch review of the batch found
/// Perl, Ruby and Elixir in neither the swept list nor the
/// compile-error exemption, each already carrying `False` / `Nil`, and
/// each reproducing the gap exactly. They were swept on the same terms
/// and are rows here. Tcl and iRules are truthy too and needed nothing:
/// their `quoted_word` / `braced_word_simple` / `number` kinds already
/// cover every literal an `expr {…}` operand can hold, so they have no
/// row rather than a vacuous one.
///
/// C#, Java, Kotlin, Rust and Go name no literal kind at all and stay
/// that way: a bare literal in a boolean slot is a compile error there,
/// so there is nothing to count. The C family is integer-truthy, and
/// #1462 deferred it for its corpus exposure. #1526 then closed its gap
/// without naming a kind, by making every slot pay for an occupant no
/// other arm counts; its rows here (#1469) pin that answer, because a
/// kind `cpp_condition_scores_itself` wrongly claimed would drop a slot
/// exactly as the missing terminal kind once did. Its `true`, `false`
/// and `null` rows are the exception to "measured short": the former
/// set already named them, and they stay so the pin covers every kind.
///
/// Three things each row pins that a conditions comparison alone
/// cannot:
///
/// - **The `kind_id` each spelling parses to.** This is the whole bug
///   class (`.claude/rules/grammar-dispatch.md` §1): the grammars here
///   emit `string` under two ids in JavaScript, Mozjs and Tsx and under
///   three in Tsx counting the type keyword, and listing the wrong one
///   compiles, runs, and returns the unfixed number. Asserting the id
///   turns that measurement into a standing claim rather than a note in
///   an issue. It is also the fixture anchor `.claude/rules/testing.md`
///   asks for — editing `"s"` to `1` in a row now fails by name instead
///   of quietly turning that row into a copy of the numeric module.
/// - **`cyclomatic` does not move.** Only the operand spelling changes
///   between a row and its control, so a `conditions` difference is
///   unambiguously ABC's.
/// - **Both walker paths.** The sets feed two structurally independent
///   consumers (§11) — the operands of a `&&` / `and` chain, and the
///   predicate of an `if` — and every row measured short in both. A
///   fixture of only one leaves the other path invisible.
///
/// The JS-family rows go through `js_literals!` rather than four hand-
/// written arrays, because the four languages differ in exactly one
/// place — which `string` alias an operand slot carries — and making
/// that the macro's only argument states the asymmetry instead of
/// leaving a reader to diff four near-identical lists for it.
#[cfg(test)]
#[cfg(any(
    feature = "javascript",
    feature = "mozjs",
    feature = "typescript",
    feature = "python",
    feature = "lua",
    feature = "php",
    feature = "groovy",
    feature = "perl",
    feature = "ruby",
    feature = "elixir",
    feature = "c",
    feature = "cpp",
    feature = "mozcpp",
    feature = "objc"
))]
mod literal_bool_operands {
    use crate::test_support::{assert_fixture_spells, metrics_verbatim};
    use crate::{LANG, MetricsOptions};

    /// One fixture shape: a source template with a `{}` operand slot,
    /// and the `abc.conditions_sum` / `cyclomatic_sum` every spelling of
    /// that operand must produce.
    type Slot = (&'static str, u64, u64);

    /// One literal operand: its spelling, and the `kind_id` the grammar
    /// must emit for it.
    type Literal = (&'static str, u16);

    /// A language's two slots, its identifier baseline operand, the
    /// literal operands that must score the same, and how many of those
    /// there should be.
    ///
    /// The count is not bookkeeping. `for_each_case` counts *languages*,
    /// so trimming a row's literal list — the pre-#1462 state is the
    /// empty list — would leave the whole module green.
    type Case = ([Slot; 2], &'static str, &'static [Literal], usize);

    /// The seven non-numeric literal kinds of a JS-family grammar, with
    /// the `string` alias an operand slot carries passed in: `String2`
    /// for JavaScript, Mozjs and Tsx, `String` for TypeScript. That one
    /// argument is the entire difference between the four rows, and it
    /// is the same split `Checker::is_string` makes (§7).
    macro_rules! js_literals {
        ($Lang:ident, $string:ident) => {
            &[
                ("\"s\"", crate::$Lang::$string as u16),
                ("`t`", crate::$Lang::TemplateString as u16),
                ("/re/", crate::$Lang::Regex as u16),
                ("null", crate::$Lang::Null as u16),
                ("undefined", crate::$Lang::Undefined as u16),
                ("{}", crate::$Lang::Object as u16),
                ("[]", crate::$Lang::Array as u16),
            ]
        };
    }

    const JS_SLOTS: [Slot; 2] = [
        ("function f(a) {\n  return a && {};\n}\n", 2, 3),
        ("function f() {\n  if ({}) { return 1; }\n}\n", 1, 3),
    ];

    /// The five non-numeric literal kinds every C-family grammar shares,
    /// then the grammar's own. The string and null spellings are passed
    /// in because Objective-C writes its strings `@"s"` and C++ its null
    /// `nullptr`; each still parses to the shared `string_literal` /
    /// `null` kind, so the row stays one spelling per kind.
    macro_rules! c_family_literals {
        ($Lang:ident, $string:literal, $null:literal $(, $extra:expr)* $(,)?) => {
            &[
                ($string, crate::$Lang::StringLiteral as u16),
                ("\"a\" \"b\"", crate::$Lang::ConcatenatedString as u16),
                ("true", crate::$Lang::True as u16),
                ("false", crate::$Lang::False as u16),
                ($null, crate::$Lang::Null as u16),
                $($extra,)*
            ]
        };
    }

    const C_FAMILY_SLOTS: [Slot; 2] = [
        ("int f(int a) {\n  return a && {};\n}\n", 2, 3),
        ("int f() {\n  if ({}) { return 1; }\n}\n", 1, 3),
    ];

    fn conditions(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .abc
            .conditions_sum()
    }

    fn cyclomatic_sum(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .cyclomatic
            .cyclomatic_sum()
    }

    /// Asserts the fixture still spells the construct under test, by
    /// parsing it with the language's own parser. Split out of `cases`
    /// because only the parser types are feature-gated; the `kind_id`
    /// enums are compiled unconditionally.
    fn assert_spells(lang: LANG, source: &str, kinds: &[(u16, usize, &str)]) {
        match lang {
            #[cfg(feature = "javascript")]
            LANG::Javascript => {
                assert_fixture_spells::<crate::JavascriptParser>(source, "f.js", kinds);
            }
            #[cfg(feature = "mozjs")]
            LANG::Mozjs => assert_fixture_spells::<crate::MozjsParser>(source, "f.jsm", kinds),
            #[cfg(feature = "typescript")]
            LANG::Typescript => {
                assert_fixture_spells::<crate::TypescriptParser>(source, "f.ts", kinds);
            }
            #[cfg(feature = "typescript")]
            LANG::Tsx => assert_fixture_spells::<crate::TsxParser>(source, "f.tsx", kinds),
            #[cfg(feature = "python")]
            LANG::Python => assert_fixture_spells::<crate::PythonParser>(source, "f.py", kinds),
            #[cfg(feature = "lua")]
            LANG::Lua => assert_fixture_spells::<crate::LuaParser>(source, "f.lua", kinds),
            #[cfg(feature = "php")]
            LANG::Php => assert_fixture_spells::<crate::PhpParser>(source, "f.php", kinds),
            #[cfg(feature = "groovy")]
            LANG::Groovy => {
                assert_fixture_spells::<crate::GroovyParser>(source, "f.groovy", kinds);
            }
            #[cfg(feature = "perl")]
            LANG::Perl => assert_fixture_spells::<crate::PerlParser>(source, "f.pl", kinds),
            #[cfg(feature = "ruby")]
            LANG::Ruby => assert_fixture_spells::<crate::RubyParser>(source, "f.rb", kinds),
            #[cfg(feature = "elixir")]
            LANG::Elixir => assert_fixture_spells::<crate::ElixirParser>(source, "f.ex", kinds),
            #[cfg(feature = "c")]
            LANG::C => assert_fixture_spells::<crate::CParser>(source, "f.c", kinds),
            #[cfg(feature = "cpp")]
            LANG::Cpp => assert_fixture_spells::<crate::CppParser>(source, "f.cpp", kinds),
            #[cfg(feature = "mozcpp")]
            LANG::Mozcpp => assert_fixture_spells::<crate::MozcppParser>(source, "f.cpp", kinds),
            #[cfg(feature = "objc")]
            LANG::Objc => assert_fixture_spells::<crate::ObjcParser>(source, "f.m", kinds),
            other => panic!("{other:?} has a case row but no parser arm"),
        }
    }

    /// `([chain_slot, condition_slot], identifier, literals)` per
    /// language, one spelling per literal *kind* the grammar emits.
    ///
    /// - JS family: `string`, `template_string`, `regex`, `null`,
    ///   `undefined`, `object`, `array`. TypeScript's `string` / `object`
    ///   type keywords (`a: string`) are different ids rendering to the
    ///   same names and are deliberately not in the sets, so a row that
    ///   accidentally named one would fail the id anchor here.
    /// - Python: `string` covers `'s'`, `"""s"""`, `f'x'` and `b'x'`,
    ///   while the implicit-join `'a' 'b'` is the separate
    ///   `concatenated_string` rule — the sibling-rule-under-a-supertype
    ///   shape #1379's Perl numerals were, which an alias sweep cannot
    ///   see. Then `none`, the four collection displays, and `ellipsis`.
    /// - Lua: one `string` kind for `"s"`, `'s'` and `[[s]]`, plus
    ///   `table_constructor`. Lua's is the strongest case of the eight:
    ///   everything but `false` and `nil` is truthy, which is why
    ///   `cond and "a" or "b"` is the language's ternary.
    /// - PHP: `string` (single-quoted) and `encapsed_string`
    ///   (interpolating) are separate rules, as are `heredoc` and
    ///   `nowdoc`; then `array_creation_expression`, `null`, the
    ///   backtick `shell_command_expression`, and `cast_expression` —
    ///   the second finding of #1462, PHP being the only set in the
    ///   Java / C# / Groovy / PHP group that named no cast kind.
    /// - Groovy: `string_literal` (which also covers the slashy `/re/`),
    ///   `null_literal`, `list_literal`, `map_literal`.
    /// - Perl: the four string productions the grammar keeps separate
    ///   (`'s'`, `q()`, `"s"`, `qq()`), the two command substitutions
    ///   (`qx()`, backticks), the `qw()` / `[…]` / `{…}` collection
    ///   literals, `qr//`, and `special_literal` (`__FILE__`).
    ///   `heredoc_initializer` is the twelfth kind and cannot live in
    ///   this table — a Perl heredoc body follows the *statement*, not
    ///   the operand — so it has its own test below.
    /// - Ruby: `string` (covering `"s"`, `'s'`, `%q()`, `%Q()`),
    ///   `chained_string` (the adjacent-literal join `"a" "b"`, a
    ///   sibling rule an alias sweep cannot see), `subshell`, the four
    ///   collection literals `array` / `hash` / `%w[]` / `%i[]`,
    ///   `regex`, the one-character `?a`, and both symbol productions.
    ///   `heredoc_beginning` is the twelfth and shares the Perl heredoc
    ///   test for the same reason.
    /// - Elixir: `string` (one kind for `"s"` and the `"""` heredoc),
    ///   `charlist`, `sigil` (one kind for `~r//`, `~s()`, `~w()`),
    ///   `quoted_atom` — a separate production from `atom`, so
    ///   `:"q a"` scored zero while `:atom` scored one — and the four
    ///   collection literals `list` / `tuple` / `map` / `bitstring`.
    /// - C family: `string_literal` (one kind for `"s"`, `L"s"`, `u8"s"`
    ///   and Objective-C's `@"s"`), `concatenated_string`, `true`,
    ///   `false` and `null` (`NULL`, and C++'s `nullptr`, which the
    ///   grammar wraps in a `null` node). C++ adds `raw_string_literal`
    ///   and `user_defined_literal` (`"s"_x`, and `1.0_km` around a
    ///   number); Objective-C adds its boxed forms — `array_literal`,
    ///   `dictionary_literal`, `at_expression` (`@1`, `@YES`, `@(b)`,
    ///   `@protocol(P)`), `selector_expression` and `encode_expression`.
    ///   `char_literal` is numeric and pinned in the sibling module.
    ///   Objective-C's `nil`, `YES` and `NO` parse as plain identifiers,
    ///   so they need no row of their own.
    ///
    /// Shapes that measured short and are not rows here, none of them a
    /// literal: JavaScript's `this` and Groovy's
    /// `object_creation_expression` (recorded in #1462); Perl's
    /// `s///` and `tr///` (operations on `$_` evaluating to a count),
    /// `anonymous_function` and `array_dereference`; Ruby's `lambda`;
    /// and Elixir's `anonymous_function` and `&f/1` capture. Every one
    /// pays its slot since #1526 (Elixir's since #1527), and
    /// `slot_pays_tests` pins them against an identifier control (#1475).
    fn cases(lang: LANG) -> Option<Case> {
        Some(match lang {
            LANG::Javascript => (JS_SLOTS, "b", js_literals!(Javascript, String2), 7),
            LANG::Mozjs => (JS_SLOTS, "b", js_literals!(Mozjs, String2), 7),
            LANG::Typescript => (JS_SLOTS, "b", js_literals!(Typescript, String), 7),
            LANG::Tsx => (JS_SLOTS, "b", js_literals!(Tsx, String2), 7),
            LANG::Python => (
                [
                    ("def f(a):\n    return a and {}\n", 2, 3),
                    ("def f():\n    if {}:\n        return 1\n", 1, 3),
                ],
                "b",
                &[
                    ("'s'", crate::Python::String as u16),
                    ("'a' 'b'", crate::Python::ConcatenatedString as u16),
                    ("None", crate::Python::None as u16),
                    ("[]", crate::Python::List as u16),
                    ("{1}", crate::Python::Set as u16),
                    ("()", crate::Python::Tuple as u16),
                    ("{}", crate::Python::Dictionary as u16),
                    ("...", crate::Python::Ellipsis as u16),
                ],
                8,
            ),
            LANG::Lua => (
                [
                    ("function f(a)\n  return a and {}\nend\n", 2, 3),
                    ("function f()\n  if {} then return 1 end\nend\n", 1, 3),
                ],
                "b",
                &[
                    ("\"s\"", crate::Lua::String as u16),
                    ("{}", crate::Lua::TableConstructor as u16),
                ],
                2,
            ),
            LANG::Php => (
                [
                    ("<?php\nfunction f($a) {\n  return $a && {};\n}\n", 2, 3),
                    ("<?php\nfunction f() {\n  if ({}) { return 1; }\n}\n", 1, 3),
                ],
                "$b",
                &[
                    ("'s'", crate::Php::String as u16),
                    ("\"x$b\"", crate::Php::EncapsedString as u16),
                    ("<<<EOT\ns\nEOT", crate::Php::Heredoc as u16),
                    ("<<<'EOT'\ns\nEOT", crate::Php::Nowdoc as u16),
                    ("[]", crate::Php::ArrayCreationExpression as u16),
                    ("null", crate::Php::Null as u16),
                    ("`ls`", crate::Php::ShellCommandExpression as u16),
                    ("(bool)$b", crate::Php::CastExpression as u16),
                ],
                8,
            ),
            LANG::Groovy => (
                [
                    ("def f(a) {\n  return a && {}\n}\n", 2, 3),
                    ("def f() {\n  if ({}) { return 1 }\n}\n", 1, 3),
                ],
                "b",
                &[
                    ("\"s\"", crate::Groovy::StringLiteral as u16),
                    ("null", crate::Groovy::NullLiteral as u16),
                    ("[]", crate::Groovy::ListLiteral as u16),
                    ("[:]", crate::Groovy::MapLiteral as u16),
                ],
                4,
            ),
            LANG::Perl => (
                [
                    (
                        "sub f {\n  my ($a, $b) = @_;\n  if ($a && {}) { print 1; }\n}\n",
                        2,
                        4,
                    ),
                    (
                        "sub f {\n  my ($a, $b) = @_;\n  if ({}) { print 1; }\n}\n",
                        1,
                        3,
                    ),
                ],
                "$b",
                &[
                    ("'s'", crate::Perl::StringSingleQuoted as u16),
                    ("q(s)", crate::Perl::StringQQuoted as u16),
                    ("\"s\"", crate::Perl::StringDoubleQuoted as u16),
                    ("qq(s)", crate::Perl::StringQqQuoted as u16),
                    ("qx(ls)", crate::Perl::CommandQxQuoted as u16),
                    ("`ls`", crate::Perl::BacktickQuoted as u16),
                    ("qw(a b)", crate::Perl::WordListQw as u16),
                    ("[1, 2]", crate::Perl::ArrayRef as u16),
                    ("{ a => 1 }", crate::Perl::HashRef as u16),
                    ("qr/re/", crate::Perl::RegexPatternQr as u16),
                    ("__FILE__", crate::Perl::SpecialLiteral as u16),
                ],
                11,
            ),
            LANG::Ruby => (
                [
                    ("def f(a, b)\n  if a && {} then 1 else 0 end\nend\n", 3, 4),
                    ("def f(a, b)\n  if {} then 1 else 0 end\nend\n", 2, 3),
                ],
                "b",
                &[
                    ("\"s\"", crate::Ruby::String as u16),
                    ("\"a\" \"b\"", crate::Ruby::ChainedString as u16),
                    ("`ls`", crate::Ruby::Subshell as u16),
                    ("[1, 2]", crate::Ruby::Array as u16),
                    ("{ a: 1 }", crate::Ruby::Hash as u16),
                    ("%w[a b]", crate::Ruby::StringArray as u16),
                    ("%i[a b]", crate::Ruby::SymbolArray as u16),
                    ("/re/", crate::Ruby::Regex as u16),
                    ("?a", crate::Ruby::Character as u16),
                    (":sym", crate::Ruby::SimpleSymbol as u16),
                    (":\"sym\"", crate::Ruby::DelimitedSymbol as u16),
                ],
                11,
            ),
            LANG::Elixir => (
                [
                    (
                        "defmodule M do\n  def f(a, b) do\n    if a && {} do\n      a\n    end\n  end\nend\n",
                        2,
                        5,
                    ),
                    (
                        "defmodule M do\n  def f(a, b) do\n    if {} do\n      a\n    end\n  end\nend\n",
                        1,
                        4,
                    ),
                ],
                "b",
                &[
                    ("\"s\"", crate::Elixir::String as u16),
                    ("'c'", crate::Elixir::Charlist as u16),
                    ("~r/re/", crate::Elixir::Sigil as u16),
                    (":\"q a\"", crate::Elixir::QuotedAtom as u16),
                    ("[1, 2]", crate::Elixir::List as u16),
                    ("{1, 2}", crate::Elixir::Tuple as u16),
                    ("%{a: 1}", crate::Elixir::Map as u16),
                    ("<<1>>", crate::Elixir::Bitstring as u16),
                ],
                8,
            ),
            LANG::C => (
                C_FAMILY_SLOTS,
                "b",
                c_family_literals!(C, "\"s\"", "NULL"),
                5,
            ),
            LANG::Cpp => (
                C_FAMILY_SLOTS,
                "b",
                c_family_literals!(
                    Cpp,
                    "\"s\"",
                    "nullptr",
                    ("R\"(x)\"", crate::Cpp::RawStringLiteral as u16),
                    ("\"s\"_x", crate::Cpp::UserDefinedLiteral as u16),
                ),
                7,
            ),
            LANG::Mozcpp => (
                C_FAMILY_SLOTS,
                "b",
                c_family_literals!(
                    Mozcpp,
                    "\"s\"",
                    "nullptr",
                    ("R\"(x)\"", crate::Mozcpp::RawStringLiteral as u16),
                    ("\"s\"_x", crate::Mozcpp::UserDefinedLiteral as u16),
                ),
                7,
            ),
            LANG::Objc => (
                C_FAMILY_SLOTS,
                "b",
                c_family_literals!(
                    Objc,
                    "@\"s\"",
                    "NULL",
                    ("@[]", crate::Objc::ArrayLiteral as u16),
                    ("@{}", crate::Objc::DictionaryLiteral as u16),
                    ("@1", crate::Objc::AtExpression as u16),
                    ("@selector(x)", crate::Objc::SelectorExpression as u16),
                    ("@encode(int)", crate::Objc::EncodeExpression as u16),
                ),
                10,
            ),
            _ => return None,
        })
    }

    /// Runs `check` once per enabled language that has a case, having
    /// first established that the case can still assert something. The
    /// four guards are the sibling module's, for the same four ways
    /// this table could decay into asserting nothing: no language
    /// enabled, an emptied literal list, a list that no longer covers
    /// every kind, and a template that lost its `{}` slot (which makes
    /// every comparison `x == x`).
    fn for_each_case(check: impl Fn(LANG, Case)) {
        let mut checked = 0;
        for lang in LANG::into_enum_iter() {
            if !lang.is_enabled() {
                continue;
            }
            let Some(case @ (slots, _, literals, expected_kinds)) = cases(lang) else {
                continue;
            };
            // The length check does not imply this one: it asserts only
            // that the list and its recorded count *agree*, which an
            // emptied row with `expected_kinds` set to 0 satisfies —
            // the shape a "the test failed, fix the number" edit takes.
            // `checked` counts languages, so that row still increments
            // it and the non-vacuity guard below reads satisfied.
            assert!(
                !literals.is_empty(),
                "{lang:?}: the literal-operand list is empty; this language asserted nothing"
            );
            assert_eq!(
                literals.len(),
                expected_kinds,
                "{lang:?}: the literal-operand list no longer covers one spelling \
                 per grammar literal kind"
            );
            for (template, _, _) in slots {
                assert!(
                    template.contains("{}"),
                    "{lang:?}: template lost its `{{}}` operand slot: {template}"
                );
            }
            check(lang, case);
            checked += 1;
        }
        assert!(
            checked > 0,
            "no truthy-valued language enabled; this test asserted nothing"
        );
    }

    #[test]
    fn a_literal_operand_scores_like_an_identifier_operand() {
        for_each_case(|lang, (slots, identifier, literals, _)| {
            for (template, _, _) in slots {
                let baseline = conditions(lang, &template.replace("{}", identifier));
                for (literal, _) in literals {
                    let source = template.replace("{}", literal);
                    let scored = conditions(lang, &source);
                    assert_eq!(
                        scored, baseline,
                        "{lang:?}: `{literal}` scored {scored} unary conditions against \
                         `{identifier}`'s {baseline}\n  source: {source}"
                    );
                }
            }
        });
    }

    /// The absolute anchor under the comparison above: every operand
    /// spelling must produce the slot's recorded `conditions`, and must
    /// leave `cyclomatic` alone.
    #[test]
    fn every_literal_operand_scores_its_recorded_values() {
        for_each_case(|lang, (slots, identifier, literals, _)| {
            for (template, expected_conditions, expected_cyclomatic) in slots {
                let operands = std::iter::once(identifier)
                    .chain(literals.iter().map(|(spelling, _)| *spelling));
                for operand in operands {
                    let source = template.replace("{}", operand);
                    assert_eq!(
                        conditions(lang, &source),
                        expected_conditions,
                        "{lang:?}: `{operand}` conditions\n  source: {source}"
                    );
                    assert_eq!(
                        cyclomatic_sum(lang, &source),
                        expected_cyclomatic,
                        "{lang:?}: `{operand}` cyclomatic_sum\n  source: {source}"
                    );
                }
            }
        });
    }

    /// The twelfth Perl and Ruby literal kind, which the table above
    /// cannot hold: in both languages a heredoc body follows the
    /// *statement*, so the operand slot carries only the introducer and
    /// the rest of the literal lands on later lines. Substituting one
    /// into a single-line template produces an unterminated heredoc and
    /// an `ERROR` parse, not a measurement.
    ///
    /// That shape is also why exactly one kind is listed per language
    /// (§5): `heredoc_initializer` / `heredoc_beginning` is the node in
    /// the operand slot, while `heredoc_body_statement` /
    /// `heredoc_body` is a sibling the walker never reaches. Listing
    /// both would score one literal twice.
    #[cfg(any(feature = "perl", feature = "ruby"))]
    #[test]
    fn a_heredoc_operand_scores_like_an_identifier_operand() {
        #[cfg(feature = "perl")]
        {
            let heredoc = "sub f {\n  my ($a, $b) = @_;\n  if ($a && <<\"EOT\") { print 1; }\nhello\nEOT\n}\n";
            assert_spells(
                LANG::Perl,
                heredoc,
                &[(crate::Perl::HeredocInitializer as u16, 1, "<<\"EOT\"")],
            );
            assert_eq!(
                conditions(LANG::Perl, heredoc),
                conditions(
                    LANG::Perl,
                    "sub f {\n  my ($a, $b) = @_;\n  if ($a && $b) { print 1; }\n}\n"
                ),
                "Perl heredoc operand"
            );
        }
        #[cfg(feature = "ruby")]
        {
            let heredoc =
                "def f(a, b)\n  if a && <<~TXT then 1 else 0 end\n    hello\n  TXT\nend\n";
            assert_spells(
                LANG::Ruby,
                heredoc,
                &[(crate::Ruby::HeredocBeginning as u16, 1, "<<~TXT")],
            );
            assert_eq!(
                conditions(LANG::Ruby, heredoc),
                conditions(
                    LANG::Ruby,
                    "def f(a, b)\n  if a && b then 1 else 0 end\nend\n"
                ),
                "Ruby heredoc operand"
            );
        }
    }

    /// Every spelling must parse to the `kind_id` its row names — the
    /// §1 alias claim, which is the one thing a conditions comparison
    /// cannot check: a row naming the wrong alias of a multi-id kind
    /// would simply keep reporting the unfixed number.
    #[test]
    fn every_literal_spelling_parses_to_the_kind_its_row_names() {
        for_each_case(|lang, (slots, _, literals, _)| {
            for (template, _, _) in slots {
                for (literal, kind) in literals {
                    let source = template.replace("{}", literal);
                    assert_spells(lang, &source, &[(*kind, 1, literal)]);
                }
            }
        });
    }
}

/// The condition slot and the wrapper peel agree on which kinds are
/// wrappers, in each language whose slot used to restate the list
/// (#1470).
///
/// `<lang>_count_condition` decided which slot expressions to hand the
/// peel, and the former `<lang>_inspect_container` which it could descend.
/// Spelled as two lists they drifted three times — Kotlin (#1459),
/// Groovy (#1466) and C# (#1463) — each time scoring a valid predicate
/// zero. The six languages here now ask `<lang>_wrapper_operand`
/// instead, which removed the duplication without moving a number: the
/// wrapper matrix measured identical before and after, so a revert
/// cannot fail these tests. What they pin is the *answer* both halves
/// must keep giving:
///
/// - **Routed.** Every wrapper the peel accepts scores its slot once.
///   A slot that stops asking the peel scores these zero.
/// - **Declined.** A unary the peel does not accept (`-b`, or a valid
///   non-wrapper such as `b & b`) stops the peel: a slot pays for it
///   once (#1526; Go's terminal-kind slot still scores `-b` nothing),
///   and outside a slot it scores nothing, so a peel that starts
///   accepting arithmetic operators by accident is caught here rather
///   than in a corpus snapshot.
/// - **Proves boolean.** A negation counts its operand outside any
///   boolean slot and a parenthesis does not — the second half of the
///   peel's answer, which the slot never sees.
///
/// Each template's `@` is the operand under test.
#[cfg(test)]
#[cfg(any(
    feature = "rust",
    feature = "go",
    feature = "java",
    feature = "python",
    feature = "ruby",
    feature = "lua"
))]
mod wrapper_peel_routing {
    use crate::test_support::metrics_verbatim;
    use crate::{LANG, MetricsOptions};

    fn conditions(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .abc
            .conditions_sum()
    }

    /// Asserts `conditions` for every `(operand, expected)` row of one
    /// template.
    fn assert_operands(lang: LANG, template: &str, rows: &[(&str, u64)]) {
        assert!(template.contains('@'), "template has no operand slot");
        for &(operand, expected) in rows {
            let source = template.replace('@', operand);
            assert_eq!(
                conditions(lang, &source),
                expected,
                "`{operand}` in {lang:?}\n  source: {source}"
            );
        }
    }

    /// Rust's slot pays for any predicate no other arm counted (#1526),
    /// so the declined half reads the valid non-wrapper `b & b`: the
    /// peel stops on it, the slot pays for it, and the call argument
    /// below does not.
    #[test]
    #[cfg(feature = "rust")]
    fn rust_condition_slot_routes_what_the_peel_accepts() {
        assert_operands(
            LANG::Rust,
            "fn f(b: bool) { if @ {} }\n",
            &[
                ("b", 1),
                ("(b)", 1),
                ("!b", 1),
                ("!(b)", 1),
                ("b & b", 1),
                ("(b & b)", 1),
                ("!(b & b)", 1),
            ],
        );
        assert_operands(
            LANG::Rust,
            "fn f(b: bool) { g(@); }\n",
            &[("!b", 1), ("(b)", 0), ("b & b", 0), ("!(b & b)", 1)],
        );
    }

    #[test]
    #[cfg(feature = "go")]
    fn go_condition_slot_routes_what_the_peel_accepts() {
        assert_operands(
            LANG::Go,
            "package p\nfunc f(b bool) { if @ {} }\n",
            &[
                ("b", 1),
                ("(b)", 1),
                ("!b", 1),
                ("!(b)", 1),
                ("-b", 0),
                ("(-b)", 0),
            ],
        );
        assert_operands(
            LANG::Go,
            "package p\nfunc f(b bool) { g(@) }\n",
            &[("!b", 1), ("(b)", 0), ("-b", 0)],
        );
    }

    /// The ternary condition is a slot like the `if` one; the `?` itself
    /// is the base 1. Java's slot pays for any predicate no other arm
    /// counted (#1526), so the declined half reads the valid non-wrapper
    /// `b & b`: the peel stops on it, the slot pays for it, and the call
    /// argument below does not.
    #[test]
    #[cfg(feature = "java")]
    fn java_condition_slot_routes_what_the_peel_accepts() {
        assert_operands(
            LANG::Java,
            "class A { int f(boolean b) { return @ ? 1 : 2; } }\n",
            &[
                ("b", 2),
                ("(b)", 2),
                ("!b", 2),
                ("!(b)", 2),
                ("b & b", 2),
                ("(b & b)", 2),
            ],
        );
        assert_operands(
            LANG::Java,
            "class A { void f(boolean b) { g(@); } }\n",
            &[("!b", 1), ("(b)", 0), ("b & b", 0), ("!(b & b)", 1)],
        );
    }

    /// Python peels parentheses and the walrus only: `not` is counted by
    /// its own `NotOperator` arm, so `python_wrapper_operand` carries no
    /// proves-boolean flag and there is no outside-a-slot half to pin.
    /// Python is truthy-valued, so the slot pays for any predicate no
    /// other arm counted, `-b` included (#1526), as Ruby's does.
    #[test]
    #[cfg(feature = "python")]
    fn python_condition_slot_routes_what_the_peel_accepts() {
        assert_operands(
            LANG::Python,
            "def f(b):\n    if @:\n        pass\n",
            &[("b", 1), ("(b)", 1), ("((b))", 1), ("-b", 1), ("(-b)", 1)],
        );
    }

    /// Ruby has no counted call-argument slot, so the outside-a-slot
    /// half reads a ternary *branch*, which is type-free: only a
    /// negation there proves its operand boolean. That branch is also
    /// where the declined half lives for Ruby: its condition slot pays
    /// for any predicate no other arm counted, `-b` included (#1520), so
    /// `if -b` scores 1 rather than 0.
    #[test]
    #[cfg(feature = "ruby")]
    fn ruby_condition_slot_routes_what_the_peel_accepts() {
        assert_operands(
            LANG::Ruby,
            "def f(b)\n  if @ then 1 end\nend\n",
            &[
                ("b", 1),
                ("(b)", 1),
                ("!b", 1),
                ("not b", 1),
                ("!(b)", 1),
                ("-b", 1),
                ("(-b)", 1),
            ],
        );
        assert_operands(
            LANG::Ruby,
            "def f(b, c)\n  x = c ? 1 : @\nend\n",
            &[
                ("!b", 3),
                ("not b", 3),
                ("(b)", 2),
                ("-b", 2),
                // A negated branch is a slot whatever it negates (#1529).
                ("!self", 3),
                ("not -b", 3),
                ("!(b > 1)", 3),
            ],
        );
        // A statement sequence evaluates to its last statement, so that is
        // the operand the slot reads: `(b; b > 1)` is the comparison,
        // already counted by its own `>`, and `(b > 1; b)` is the bare `b`,
        // which the slot counts beside that `>`. Reading the first
        // statement inverted both. The subject-less `when` goes through
        // the same peel.
        let seqs: &[(&str, u64)] = &[("(b; b > 1)", 1), ("(b > 1; b)", 2)];
        assert_operands(LANG::Ruby, "def f(b)\n  if @ then 1 end\nend\n", seqs);
        assert_operands(
            LANG::Ruby,
            "def f(b)\n  case\n  when @ then 1\n  end\nend\n",
            seqs,
        );
    }

    /// A subject-less `when` whose pattern is a chain adds nothing of its
    /// own: the Rule 9 walker scores every operand as a slot, so each
    /// chain already pays at least one (#1529). Before that the walker
    /// skipped an operand outside its terminal list, the clause had to
    /// pay for `-a && -b` (review of #1453), and a chain scored as many
    /// conditions as it had *listed* operands plus one at most. Each row
    /// now scores what its plain-identifier twin (`a && b`, `a || b ||
    /// c`) does. An assignment operand is its value (#1520), so
    /// `(a = 1) && (b = 2)` is `1 && 2`.
    #[test]
    #[cfg(feature = "ruby")]
    fn ruby_subjectless_when_chain_pays_per_operand() {
        assert_operands(
            LANG::Ruby,
            "def f(a, b, c)\n  case\n  when @ then 1\n  end\nend\n",
            &[
                ("a", 1),
                ("-a", 1),
                ("a && b", 2),
                ("-a && -b", 2),
                ("(a = 1) && (b = 2)", 2),
                ("a || b || c", 3),
                ("-a || -b || -c", 3),
                ("-a && b", 2),
                ("a > 1 && b", 2),
                ("a > 1 && -b", 2),
                ("a && (b || c)", 3),
                ("-a && (-b || c)", 3),
            ],
        );
    }

    /// #1529: an operand of a Ruby `&&` / `||` / `and` / `or` chain is
    /// scored by the rule #1520 gave every condition slot — one, unless
    /// another arm already counts it — wherever the chain is written.
    /// The walker used to pay only for an operand that peeled down to a
    /// fixed list of terminal kinds, so every spelling in `UNLISTED`
    /// scored one below its plain-identifier twin `b` in every position
    /// below. `CONTROLS` must not move: `!b` and `(b)` already scored
    /// their twin, and a comparison, a pattern test, or a negation of one
    /// is counted by its own arm, so paying the operand as well would
    /// count that decision twice.
    #[test]
    #[cfg(feature = "ruby")]
    fn ruby_chain_operand_pays_what_no_other_arm_counted() {
        const UNLISTED: &[&str] = &[
            "self",
            "Foo::Bar",
            "-b",
            "(-b)",
            "defined?(b)",
            "b + 1",
            "!self",
            "not self",
            "(y ||= b)",
            "(y = self)",
            "begin self end",
        ];
        const CONTROLS: &[&str] = &["!b", "(b)", "c > 1", "!(c > 1)", "(c in Integer)"];
        // (template, conditions with `b` in the `@` operand)
        let positions: &[(&str, u64)] = &[
            ("def f(a, b, c)\n  g if a && @\nend\n", 2),
            ("def f(a, b, c)\n  g if (a && @)\nend\n", 2),
            ("def f(a, b, c)\n  x = a && @\nend\n", 2),
            ("def f(a, b, c)\n  return a || @\nend\n", 2),
            ("def f(a, b, c)\n  h(@ && a)\nend\n", 2),
            ("def f(a, b, c)\n  x = (a and @)\nend\n", 2),
            ("def f(a, b, c)\n  x = (a or @)\nend\n", 2),
            ("def f(a, b, c)\n  y ||= a && @\nend\n", 2),
            ("def f(a, b, c)\n  y &&= a || @\nend\n", 2),
            ("def f(a, b, c)\n  x = a && (c || @)\nend\n", 3),
            // A comment is a named child of the `binary` too, and must not
            // pay as a third operand.
            ("def f(a, b, c)\n  x = a && # c\n    @\nend\n", 2),
            ("def f(a, b, c)\n  while a && @ do g end\nend\n", 2),
            (
                "def f(a, b, c)\n  if a then 1 elsif a && @ then 2 end\nend\n",
                4,
            ),
            (
                "def f(a, b, c)\n  case\n  when a && @ then 1\n  end\nend\n",
                2,
            ),
        ];
        for &(template, twin) in positions {
            // The twin is measured, not only assumed, so a template that
            // stopped parsing as a chain fails here rather than agreeing
            // with every row at some other value.
            assert_operands(LANG::Ruby, template, &[("b", twin)]);
            let rows: Vec<_> = UNLISTED
                .iter()
                .chain(CONTROLS)
                .map(|&operand| (operand, twin))
                .collect();
            assert_operands(LANG::Ruby, template, &rows);
        }
    }

    #[test]
    #[cfg(feature = "lua")]
    fn lua_condition_slot_routes_what_the_peel_accepts() {
        // Lua is truthy-valued, so the slot pays for any predicate no
        // other arm counted, `-b` and `#b` included (#1526).
        assert_operands(
            LANG::Lua,
            "function f(b)\n  if @ then end\nend\n",
            &[
                ("b", 1),
                ("(b)", 1),
                ("not b", 1),
                ("not (b)", 1),
                ("-b", 1),
                ("#b", 1),
                ("(-b)", 1),
            ],
        );
        assert_operands(
            LANG::Lua,
            "function f(b)\n  g(@)\nend\n",
            &[("not b", 1), ("(b)", 0), ("-b", 0)],
        );
    }
}

/// A comment inside a condition or value slot changes nothing (#1455).
///
/// Every walker read its slots by fixed child index, and every peel
/// stepped into a `(…)` / negation with `child(1)` or the first named
/// child. tree-sitter counts a comment among a node's children and
/// marks it *named*, so `if (/*c*/ b)` handed the comment to the slot,
/// which declined it, and the condition scored zero. Each pair below is
/// one spelling with and without a comment; the two are asserted equal
/// to each other *and* to the expected literal, so a regression that
/// moved both sides alike — to zero, say — still fails.
///
/// The forms, per slot and per comment spelling of the language: a
/// comment before the operand, inside a nested parenthesis, before a
/// negation, between a negation and its operand, and — where the
/// language's syntax puts parentheses around the slot — before those
/// parentheses. Value slots (`return`, declarator, assignment, lambda
/// body) take the negated forms only, since a bare operand there is no
/// condition, and only the first comment spelling: a line comment after
/// `return` ends the statement in Go.
#[cfg(test)]
#[cfg(any(
    feature = "c",
    feature = "cpp",
    feature = "csharp",
    feature = "elixir",
    feature = "go",
    feature = "groovy",
    feature = "java",
    feature = "javascript",
    feature = "kotlin",
    feature = "lua",
    feature = "mozcpp",
    feature = "mozjs",
    feature = "objc",
    feature = "perl",
    feature = "php",
    feature = "python",
    feature = "ruby",
    feature = "rust",
    feature = "typescript"
))]
mod slot_comment_invariance {
    use crate::test_support::metrics_verbatim;
    use crate::{LANG, MetricsOptions};

    fn conditions(lang: LANG, source: &str) -> u64 {
        metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default())
            .abc
            .conditions_sum()
    }

    /// How one language spells the slots under test.
    struct Spelling {
        /// Comment spellings, each carrying the whitespace — a newline
        /// for a line comment — the operand after it needs.
        comments: &'static [&'static str],
        operand: &'static str,
        /// `None` where the peel does not descend the negation: Python
        /// counts `not` through its own arm, and tree-sitter-python
        /// fails to parse the valid `(not # c⏎ b)` at the pinned grammar.
        negation: Option<&'static str>,
        /// The slot is written inside parentheses: either the syntax
        /// requires them (`if (…)`), or a line comment needs them to
        /// stay inside the expression (Python, Ruby, Elixir).
        parenthesised: bool,
        /// The parentheses belong to the slot's syntax, so a comment
        /// may also sit before them (`if /*c*/ (b)`).
        syntactic_parens: bool,
        /// `(template, expected)`; `@` marks a condition slot.
        conditions: &'static [(&'static str, u64)],
        /// Templates whose `@` is a value slot; a negation there scores 1.
        values: &'static [&'static str],
    }

    const C_COMMENTS: &[&str] = &["/*c*/ ", "//c\n "];

    const C_FAMILY: Spelling = Spelling {
        comments: C_COMMENTS,
        operand: "b",
        negation: Some("!"),
        parenthesised: true,
        syntactic_parens: true,
        conditions: &[
            ("int f(){ if @ { x(); } }", 1),
            ("int f(){ while @ { x(); } }", 1),
            ("int f(){ do { x(); } while @; }", 1),
        ],
        values: &["int f(){ return @; }"],
    };

    const JS_FAMILY: Spelling = Spelling {
        comments: C_COMMENTS,
        operand: "b",
        negation: Some("!"),
        parenthesised: true,
        syntactic_parens: true,
        conditions: &[
            ("function f(){ if @ { x(); } }", 1),
            ("function f(){ while @ { x(); } }", 1),
            ("function f(){ do { x(); } while @; }", 1),
        ],
        values: &["function f(){ return @; }"],
    };

    fn spelling(lang: LANG) -> Option<Spelling> {
        Some(match lang {
            LANG::C | LANG::Cpp | LANG::Mozcpp | LANG::Objc => C_FAMILY,
            LANG::Javascript | LANG::Mozjs | LANG::Typescript | LANG::Tsx => JS_FAMILY,
            LANG::Java => Spelling {
                conditions: &[
                    ("class K{ void f(){ if @ { x(); } } }", 1),
                    ("class K{ void f(){ while @ { x(); } } }", 1),
                    ("class K{ void f(){ do { x(); } while @; } }", 1),
                ],
                values: &[
                    "class K{ boolean f(){ return @; } }",
                    "class K{ void f(){ boolean y = @; } }",
                    "class K{ void f(){ y = @; } }",
                    "class K{ void f(){ Supplier<Boolean> s = () -> @; } }",
                ],
                ..C_FAMILY
            },
            LANG::Csharp => Spelling {
                conditions: &[
                    ("class K{ void f(){ if @ { x(); } } }", 1),
                    ("class K{ void f(){ while @ { x(); } } }", 1),
                    ("class K{ void f(){ do { x(); } while @; } }", 1),
                ],
                values: &[
                    "class K{ bool f(){ return @; } }",
                    "class K{ void f(){ var y = @; } }",
                    "class K{ void f(){ y = @; } }",
                    "class K{ void f(){ Func<bool> s = () => @; } }",
                ],
                ..C_FAMILY
            },
            LANG::Groovy => Spelling {
                conditions: &[
                    ("def f(){ if @ { x() } }", 1),
                    ("def f(){ while @ { x() } }", 1),
                    ("def f(){ do { x() } while @ }", 1),
                ],
                values: &[
                    "def f(){ return @ }",
                    "def f(){ def y = @ }",
                    "def f(){ y = @ }",
                ],
                ..C_FAMILY
            },
            LANG::Php => Spelling {
                comments: &["/*c*/ ", "//c\n ", "#c\n "],
                operand: "$b",
                conditions: &[
                    ("<?php function f(){ if @ { x(); } }", 1),
                    ("<?php function f(){ while @ { x(); } }", 1),
                    ("<?php function f(){ do { x(); } while @; }", 1),
                ],
                values: &["<?php function f(){ return @; }"],
                ..C_FAMILY
            },
            LANG::Kotlin => Spelling {
                conditions: &[
                    ("fun f(){ if @ { x() } }", 1),
                    ("fun f(){ while @ { x() } }", 1),
                    ("fun f(){ do { x() } while @ }", 1),
                ],
                values: &[],
                ..C_FAMILY
            },
            LANG::Perl => Spelling {
                comments: &["# c\n "],
                operand: "$b",
                conditions: &[
                    ("sub f { if @ { x(); } }", 1),
                    ("sub f { unless @ { x(); } }", 1),
                    ("sub f { while @ { x(); } }", 1),
                    ("sub f { until @ { x(); } }", 1),
                ],
                values: &["sub f { return @; }"],
                ..C_FAMILY
            },
            LANG::Rust => Spelling {
                parenthesised: false,
                syntactic_parens: false,
                conditions: &[
                    ("fn f(){ if @ { x(); } }", 1),
                    ("fn f(){ while @ { x(); } }", 1),
                ],
                values: &["fn f() -> bool { return @; }"],
                ..C_FAMILY
            },
            LANG::Go => Spelling {
                parenthesised: false,
                syntactic_parens: false,
                conditions: &[
                    ("package p\nfunc f(){ if @ { x() } }", 1),
                    ("package p\nfunc f(){ for @ { x() } }", 1),
                ],
                values: &["package p\nfunc f() bool { return @ }"],
                ..C_FAMILY
            },
            LANG::Lua => Spelling {
                comments: &["--[[c]] ", "--c\n "],
                negation: Some("not "),
                parenthesised: false,
                syntactic_parens: false,
                conditions: &[
                    ("function f() if @ then x() end end", 1),
                    ("function f() while @ do x() end end", 1),
                    ("function f() repeat x() until @ end", 1),
                ],
                values: &["function f() return @ end"],
                ..C_FAMILY
            },
            LANG::Python => Spelling {
                comments: &["# c\n "],
                negation: None,
                syntactic_parens: false,
                conditions: &[
                    ("def f():\n    if @:\n        x()\n", 1),
                    ("def f():\n    while @:\n        x()\n", 1),
                ],
                values: &[],
                ..C_FAMILY
            },
            LANG::Ruby => Spelling {
                comments: &["# c\n "],
                syntactic_parens: false,
                conditions: &[
                    ("def f\n  if @\n    x\n  end\nend\n", 1),
                    ("def f\n  while @\n    x\n  end\nend\n", 1),
                    ("def f\n  case\n  when @\n    x\n  end\nend\n", 1),
                ],
                values: &[],
                ..C_FAMILY
            },
            // Elixir's `if` slot scored its operand whatever the peel
            // returned, so the defect showed only where the peel decides:
            // an operand of a `&&` chain, which counts each operand.
            LANG::Elixir => Spelling {
                comments: &["# c\n "],
                syntactic_parens: false,
                conditions: &[
                    (
                        "defmodule M do\n def f do\n  if @ do\n   x()\n  end\n end\nend\n",
                        1,
                    ),
                    ("defmodule M do\n def f do\n  y = a && @\n end\nend\n", 2),
                ],
                values: &[],
                ..C_FAMILY
            },
            _ => return None,
        })
    }

    /// `(without, with, expected)` for every form of every slot.
    fn cases(s: &Spelling) -> Vec<(String, String, u64)> {
        let slot = |x: String| {
            if s.parenthesised { format!("({x})") } else { x }
        };
        let b = s.operand;
        let mut out = Vec::new();
        for &(template, expected) in s.conditions {
            let fill = |x: String| template.replace('@', &x);
            for c in s.comments {
                let mut push = |plain: String, commented: String| {
                    out.push((fill(plain), fill(commented), expected));
                };
                push(slot(b.into()), slot(format!("{c}{b}")));
                push(slot(format!("({b})")), slot(format!("({c}{b})")));
                if let Some(n) = s.negation {
                    push(slot(format!("{n}{b}")), slot(format!("{c}{n}{b}")));
                    push(slot(format!("{n}{b}")), slot(format!("{n}{c}{b}")));
                }
                if s.syntactic_parens {
                    push(slot(b.into()), format!("{c}{}", slot(b.into())));
                }
            }
        }
        if let (Some(n), Some(c)) = (s.negation, s.comments.first()) {
            for template in s.values {
                let fill = |x: String| template.replace('@', &x);
                out.push((fill(format!("{n}{b}")), fill(format!("{c}{n}{b}")), 1));
                out.push((fill(format!("{n}{b}")), fill(format!("{n}{c}{b}")), 1));
            }
        }
        out
    }

    #[test]
    fn a_comment_in_a_slot_changes_nothing() {
        let mut checked = 0;
        for lang in LANG::into_enum_iter().filter(LANG::is_enabled) {
            let Some(spelling) = spelling(lang) else {
                continue;
            };
            for (plain, commented, expected) in cases(&spelling) {
                let without = conditions(lang, &plain);
                assert_eq!(
                    conditions(lang, &commented),
                    without,
                    "{lang:?}: a comment changed the ABC conditions\n  \
                     without: {plain}\n  with:    {commented}"
                );
                assert_eq!(without, expected, "{lang:?}: {plain}");
                checked += 1;
            }
        }
        assert!(
            checked > 0,
            "no slot language enabled; this test asserted nothing"
        );
    }
}

/// Slot occupants that no fixed index or first-named-child read finds
/// (#1455): a preamble before the slot, a comment *after* the operand
/// of a last-operand read, and the non-condition reads that were
/// positional too. Each row pairs a spelling with its plain twin.
#[cfg(test)]
#[cfg(any(
    feature = "cpp",
    feature = "elixir",
    feature = "mozcpp",
    feature = "perl",
    feature = "ruby",
    feature = "rust"
))]
mod slot_role_reads {
    use crate::test_support::metrics_verbatim;
    use crate::{LANG, MetricsOptions};

    /// `(conditions, assignments)`.
    fn abc(lang: LANG, source: &str) -> (u64, u64) {
        let abc = metrics_verbatim(lang, source.as_bytes(), MetricsOptions::default()).abc;
        (abc.conditions_sum(), abc.assignments_sum())
    }

    /// `(language, plain, variant, (conditions, assignments))`.
    const ROWS: &[(LANG, &str, &str, (u64, u64))] = &[
        // A C++ `condition_clause` holds its condition in the `value`
        // field; an init-statement sits at child(1) before it.
        (
            LANG::Cpp,
            "int f(){ int y = g(); if (b) { x(); } }",
            "int f(){ if (int y = g(); b) { x(); } }",
            (1, 1),
        ),
        (
            LANG::Mozcpp,
            "int f(){ int y = g(); if (b) { x(); } }",
            "int f(){ if (int y = g(); b) { x(); } }",
            (1, 1),
        ),
        (
            LANG::Cpp,
            "int f(){ if constexpr (b) { x(); } }",
            "int f(){ if constexpr (/*c*/ b) { x(); } }",
            (1, 0),
        ),
        // A loop label is the `while` expression's first child.
        (
            LANG::Rust,
            "fn f(){ while b { x(); } }",
            "fn f(){ 'a: while b { x(); } }",
            (1, 0),
        ),
        // Perl's `(…)` evaluates to its last element, so the peel takes
        // the last operand — never a trailing comment.
        (
            LANG::Perl,
            "sub f { if ($b) { x(); } }",
            "sub f { if ($b # c\n) { x(); } }",
            (1, 0),
        ),
        (
            LANG::Perl,
            "sub f { x() if $b; }",
            "sub f { x() if $b # c\n; }",
            (1, 0),
        ),
        // `split`'s delimiter is its first *operand*; a comment before it
        // made the pattern read as an ordinary match.
        (
            LANG::Perl,
            "sub f { my @a = split(/,/, $s); }",
            "sub f { my @a = split( # sep\n /,/, $s); }",
            (0, 1),
        ),
        // A subject-less `when` scores its operand once; the comment
        // made the peel return it, so `x > 1` counted twice.
        (
            LANG::Ruby,
            "def f\n  case\n  when (x > 1)\n    y\n  end\nend\n",
            "def f\n  case\n  when ( # c\n x > 1)\n    y\n  end\nend\n",
            (1, 0),
        ),
        // Elixir's match operator, read at child(1), lost to a comment
        // before the `=` — an assignment rather than a condition.
        (
            LANG::Elixir,
            "defmodule M do\n def f do\n  a = 1\n end\nend\n",
            "defmodule M do\n def f do\n  a # c\n = 1\n end\nend\n",
            (0, 1),
        ),
    ];

    #[test]
    fn a_slot_is_read_by_role() {
        let mut checked = 0;
        for &(lang, plain, variant, expected) in ROWS.iter().filter(|row| row.0.is_enabled()) {
            let without = abc(lang, plain);
            assert_eq!(
                abc(lang, variant),
                without,
                "{lang:?}: the variant scored differently\n  plain:   {plain}\n  variant: {variant}"
            );
            assert_eq!(without, expected, "{lang:?}: {plain}");
            checked += 1;
        }
        assert!(
            checked > 0,
            "no row language enabled; this test asserted nothing"
        );
    }
}