big_code_analysis/metrics/

halstead.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::doc_markdown,
    clippy::enum_glob_use,
    clippy::match_wildcard_for_single_variants,
    clippy::similar_names,
    clippy::unused_self,
    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::collections::HashMap;

use std::fmt;

// The operator / operand classification is syntactic and lives beside
// the per-language `Getter` tables that produce it; re-exported here
// because this metric is what consumes it.
pub use crate::token_role::TokenRole;

/// The former name of [`TokenRole`], kept so the
/// `metrics::halstead::HalsteadType` path still resolves.
///
/// The classification never was Halstead-specific — it answers whether
/// a node acts as an operator or an operand, which the grammar decides
/// and other consumers can use (#1376). Renaming it outright would be a
/// SemVer break, so the old spelling stays until the next major.
#[deprecated(
    since = "2.3.0",
    note = "renamed to `TokenRole`: the classification is syntactic, not Halstead-specific"
)]
pub type HalsteadType = TokenRole;

use crate::checker::Checker;
use crate::getter::Getter;
use crate::int_hash::IntKeyHashMap;
use crate::macros::implement_metric_trait;

use crate::*;

/// The `Halstead` metric suite.
#[derive(Default, Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Stats {
    u_operators: u64,
    operators: u64,
    u_operands: u64,
    operands: u64,
}

/// Per-space operator / operand occurrence maps used to compute the
/// Halstead `Stats` struct. One map per distinct operator (`kind_id`)
/// and one per distinct operand (`text`); merged across nested spaces.
#[derive(Debug, Default, Clone, PartialEq)]
pub struct HalsteadMaps<'a> {
    /// Keyed by `kind_id`, so it is hashed with [`crate::int_hash`]'s
    /// integer hasher rather than SipHash: the key is a grammar symbol
    /// this crate generated, drawn from an alphabet of at most a few
    /// hundred values, so there is nothing for a keyed hash to defend.
    pub(crate) operators: IntKeyHashMap<u16, u64>,
    /// Primitive-type operators stored by text so each distinct primitive
    /// (e.g. `int` vs `double`) counts as a separate distinct operator,
    /// even when the grammar maps them all to a single kind_id.
    ///
    /// Text-keyed, so it keeps SipHash — see the module doc on
    /// [`crate::int_hash`] for why analysed source text does not qualify
    /// for the fast hasher.
    pub(crate) primitive_operators: HashMap<&'a [u8], u64>,
    /// Text-keyed, and on SipHash for the same reason as
    /// `primitive_operators`.
    pub(crate) operands: HashMap<&'a [u8], u64>,
}

impl<'a> HalsteadMaps<'a> {
    pub(crate) fn new() -> Self {
        Self::default()
    }

    pub(crate) fn merge(&mut self, other: &HalsteadMaps<'a>) {
        for (k, v) in &other.operators {
            *self.operators.entry(*k).or_insert(0) += v;
        }
        for (k, v) in &other.primitive_operators {
            *self.primitive_operators.entry(*k).or_insert(0) += v;
        }
        for (k, v) in &other.operands {
            *self.operands.entry(*k).or_insert(0) += v;
        }
    }

    pub(crate) fn finalize(&self, stats: &mut Stats) {
        stats.u_operators = (self.operators.len() + self.primitive_operators.len()) as u64;
        stats.operators =
            self.operators.values().sum::<u64>() + self.primitive_operators.values().sum::<u64>();
        stats.u_operands = self.operands.len() as u64;
        stats.operands = self.operands.values().sum::<u64>();
    }
}

impl fmt::Display for Stats {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "unique_operators: {}, \
             total_operators: {}, \
             unique_operands: {}, \
             total_operands: {}, \
             length: {}, \
             estimated_program_length: {}, \
             purity_ratio: {}, \
             size: {}, \
             volume: {}, \
             difficulty: {}, \
             level: {}, \
             effort: {}, \
             time: {}, \
             bugs: {}",
            self.unique_operators(),
            self.total_operators(),
            self.unique_operands(),
            self.total_operands(),
            self.length(),
            self.estimated_program_length(),
            self.purity_ratio(),
            self.vocabulary(),
            self.volume(),
            self.difficulty(),
            self.level(),
            self.effort(),
            self.time(),
            self.bugs(),
        )
    }
}

impl Stats {
    // Intentionally a no-op. Halstead distinct-counts (`u_operators` /
    // `u_operands`) cannot be summed across sibling spaces without
    // double-counting operators/operands they share. Cross-space
    // aggregation is instead done by unioning the occurrence maps
    // (`HalsteadMaps::merge`) and re-running `finalize` on the parent
    // (see `spaces/compute.rs`). Summing the finalized fields here —
    // mirroring the sibling metrics' `merge` — would silently inflate
    // every parent space's n1/n2/N1/N2.
    pub(crate) fn merge(&mut self, _other: &Stats) {}

    /// Returns `η1`, the number of distinct operators
    #[inline]
    #[must_use]
    pub fn unique_operators(&self) -> u64 {
        self.u_operators
    }

    /// Returns `N1`, the number of total operators
    #[inline]
    #[must_use]
    pub fn total_operators(&self) -> u64 {
        self.operators
    }

    /// Returns `η2`, the number of distinct operands
    #[inline]
    #[must_use]
    pub fn unique_operands(&self) -> u64 {
        self.u_operands
    }

    /// Returns `N2`, the number of total operands
    #[inline]
    #[must_use]
    pub fn total_operands(&self) -> u64 {
        self.operands
    }

    /// Returns the program length
    ///
    /// Computed as `N = N1 + N2`, the sum of [`Self::total_operators`] and
    /// [`Self::total_operands`].
    #[inline]
    #[must_use]
    pub fn length(&self) -> u64 {
        self.total_operands() + self.total_operators()
    }

    /// Returns the calculated estimated program length
    ///
    /// Computed as `N^ = n1 * log2(n1) + n2 * log2(n2)`, where `n1` is
    /// [`Self::unique_operators`] and `n2` is [`Self::unique_operands`]. Each term is
    /// treated as `0` when its unique count is `0`.
    #[inline]
    #[must_use]
    pub fn estimated_program_length(&self) -> f64 {
        let uo = self.unique_operators() as f64;
        let ud = self.unique_operands() as f64;
        let uo_term = if uo == 0.0 { 0.0 } else { uo * uo.log2() };
        let ud_term = if ud == 0.0 { 0.0 } else { ud * ud.log2() };
        uo_term + ud_term
    }

    /// Returns the purity ratio
    ///
    /// Computed as `PR = N^ / N`, the ratio of
    /// [`Self::estimated_program_length`] to [`Self::length`].
    #[inline]
    #[must_use]
    pub fn purity_ratio(&self) -> f64 {
        let len = self.length() as f64;
        if len == 0.0 {
            0.0
        } else {
            self.estimated_program_length() / len
        }
    }

    /// Returns the program vocabulary
    ///
    /// Computed as `n = n1 + n2`, the sum of [`Self::unique_operators`] and
    /// [`Self::unique_operands`].
    #[inline]
    #[must_use]
    pub fn vocabulary(&self) -> u64 {
        self.unique_operands() + self.unique_operators()
    }

    /// Returns the program volume.
    ///
    /// Computed as `V = N * log2(n)`, where `N` is [`Self::length`] and `n`
    /// is [`Self::vocabulary`]. Returns `0` when the vocabulary is `<= 1`,
    /// since `log2` would be non-positive.
    ///
    /// Unit of measurement: bits
    #[inline]
    #[must_use]
    pub fn volume(&self) -> f64 {
        // Assumes a uniform binary encoding for the vocabulary is used.
        let vocab = self.vocabulary() as f64;
        if vocab <= 1.0 {
            0.0
        } else {
            self.length() as f64 * vocab.log2()
        }
    }

    /// Returns the estimated difficulty required to program
    ///
    /// Computed as `D = (n1 / 2) * (N2 / n2)`, where `n1` is
    /// [`Self::unique_operators`], `N2` is [`Self::total_operands`], and `n2` is
    /// [`Self::unique_operands`].
    #[inline]
    #[must_use]
    pub fn difficulty(&self) -> f64 {
        let ud = self.unique_operands() as f64;
        if ud == 0.0 {
            0.0
        } else {
            self.unique_operators() as f64 / 2. * self.total_operands() as f64 / ud
        }
    }

    /// Returns the estimated level of difficulty required to program
    ///
    /// Computed as `L = 1 / D`, the reciprocal of [`Self::difficulty`].
    #[inline]
    #[must_use]
    pub fn level(&self) -> f64 {
        let d = self.difficulty();
        if d == 0.0 { 0.0 } else { 1. / d }
    }

    /// Returns the estimated effort required to program
    ///
    /// Computed as `E = D * V`, the product of [`Self::difficulty`] and
    /// [`Self::volume`].
    #[inline]
    #[must_use]
    pub fn effort(&self) -> f64 {
        self.difficulty() * self.volume()
    }

    /// Returns the estimated time required to program.
    ///
    /// Computed as `T = E / 18`, where `E` is [`Self::effort`] and `18` is
    /// the Stroud number (see the divisor rationale below).
    ///
    /// Unit of measurement: seconds
    #[inline]
    #[must_use]
    pub fn time(&self) -> f64 {
        // The floating point `18.` aims to describe the processing rate of the
        // human brain. It is called Stoud number, S, and its
        // unit of measurement is moments/seconds.
        // A moment is the time required by the human brain to carry out the
        // most elementary decision.
        // 5 <= S <= 20. Halstead uses 18.
        // The value of S has been empirically developed from psychological
        // reasoning, and its recommended value for
        // programming applications is 18.
        //
        // Source: https://www.geeksforgeeks.org/software-engineering-halsteads-software-metrics/
        self.effort() / 18.
    }

    /// Returns the estimated number of delivered bugs.
    ///
    /// This metric represents the average amount of work a programmer can do
    /// without introducing an error.
    ///
    /// Computed as `B = E^(2/3) / 3000`, where `E` is [`Self::effort`]. This
    /// is the effort-based variant of Halstead's delivered-bugs estimate
    /// rather than the more commonly cited volume-based form `B = V / 3000`;
    /// it matches the formula used by upstream `rust-code-analysis`.
    #[inline]
    #[must_use]
    pub fn bugs(&self) -> f64 {
        // The floating point `3000.` represents the number of elementary
        // mental discriminations.
        // A mental discrimination, in psychology, is the ability to perceive
        // and respond to differences among stimuli.
        //
        // The value above is obtained starting from a constant that
        // is different for every language and assumes that natural language is
        // the language of the brain.
        // For programming languages, the English language constant
        // has been considered.
        //
        // After every 3000 mental discriminations a result is produced.
        // This result, whether correct or incorrect, is more than likely
        // either used as an input for the next operation or is output to the
        // environment.
        // If incorrect the error should become apparent.
        // Thus, an opportunity for error occurs every 3000
        // mental discriminations.
        //
        // Source: https://docs.lib.purdue.edu/cgi/viewcontent.cgi?article=1145&context=cstech
        self.effort().powf(2. / 3.) / 3000.
    }
}

#[doc(hidden)]
/// Per-language extraction of Halstead operator/operand maps.
pub(crate) trait Halstead
where
    Self: Checker + Getter,
{
    /// Walk `node` and update `stats` with this metric for the language
    /// implementing the trait.
    ///
    /// `ancestors` is the chain the walker descended through; it is
    /// handed to [`Getter::get_op_type`], six of whose impls classify a
    /// token by what encloses it (#1096).
    fn compute<'a>(
        node: &Node<'a>,
        code: &'a [u8],
        ancestors: Ancestors<'a, '_>,
        halstead_maps: &mut HalsteadMaps<'a>,
    );
}

#[inline]
fn get_id<'a>(node: &Node<'a>, code: &'a [u8]) -> &'a [u8] {
    &code[node.start_byte()..node.end_byte()]
}

#[inline]
fn compute_halstead<'a, T: Getter + Checker>(
    node: &Node<'a>,
    code: &'a [u8],
    ancestors: Ancestors<'a, '_>,
    halstead_maps: &mut HalsteadMaps<'a>,
) {
    match T::get_op_type_with_code(node, code, ancestors) {
        TokenRole::Operator => {
            if T::is_primitive(node) {
                // Store primitive-type operators by text so distinct
                // primitives (e.g. `int` vs `double`) that share a
                // single kind_id are counted separately in n1/N1.
                *halstead_maps
                    .primitive_operators
                    .entry(get_id(node, code))
                    .or_insert(0) += 1;
            } else {
                *halstead_maps.operators.entry(node.kind_id()).or_insert(0) += 1;
            }
        }
        TokenRole::Operand => {
            *halstead_maps
                .operands
                .entry(T::get_operand_id(node, code, ancestors))
                .or_insert(0) += 1;
        }
        _ => {}
    }
}

// Every language's `Halstead::compute` is the same forward to
// `compute_halstead`, which classifies each node through the language's
// own `Getter` / `Checker`. Nothing per-language lives here — it lives
// in `big-code-analysis-ast/src/getter/<lang>.rs` — so writing the
// impls out was 23 copies of one signature. (This is the only metric
// whose per-language impls are all identical; every other trait has
// real per-language bodies.)
macro_rules! impl_halstead_forwarding {
    ($($code:ty),+ $(,)?) => {
        $(
            impl Halstead for $code {
                fn compute<'a>(
                    node: &Node<'a>,
                    code: &'a [u8],
                    ancestors: Ancestors<'a, '_>,
                    halstead_maps: &mut HalsteadMaps<'a>,
                ) {
                    compute_halstead::<Self>(node, code, ancestors, halstead_maps);
                }
            }
        )+
    };
}

impl_halstead_forwarding!(
    PythonCode,
    MozjsCode,
    JavascriptCode,
    TypescriptCode,
    TsxCode,
    RustCode,
    CppCode,
    CCode,
    ObjcCode,
    MozcppCode,
    JavaCode,
    GroovyCode,
    CsharpCode,
    GoCode,
    PerlCode,
    KotlinCode,
    LuaCode,
    PhpCode,
    RubyCode,
    ElixirCode,
    BashCode,
    TclCode,
    IrulesCode,
);

// Real defaults — no operators / operands to count. Audited in #188.
implement_metric_trait!(Halstead, 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 {
    use std::collections::HashSet;
    use std::path::PathBuf;

    use crate::test_support::{ast_has_kind_id, check_metrics_only_shim, for_each_node_with_chain};

    use super::*;

    check_metrics_only_shim!(check_metrics, Halstead);

    // `HalsteadType` is the pre-#1376 name for `TokenRole`, kept as a
    // deprecated alias because removing it before `3.0` would be a
    // SemVer break (STABILITY.md). Nothing in this repository uses the
    // old spelling any more, so only this guard would notice it being
    // dropped — and dropping it silently is exactly what the promise
    // rules out.
    //
    // The `matches!` arms are the assertion: a value typed through the
    // alias can only be matched against `TokenRole`'s variants if the
    // alias still names that enum, so this fails to *compile* if the
    // alias is removed or re-pointed, rather than failing at runtime.
    // `TokenRole` derives nothing, so there is no `assert_eq!` to reach
    // for here.
    #[test]
    #[allow(deprecated)]
    fn halstead_type_alias_still_names_token_role() {
        let via_alias: HalsteadType = HalsteadType::Operand;
        assert!(matches!(via_alias, TokenRole::Operand));
        assert!(!matches!(via_alias, TokenRole::Operator));
    }

    /// Runs the `--ops` walk over `source` and returns the root space's
    /// merged vocabulary, with every nested space still reachable
    /// through [`crate::ops::Ops::spaces`].
    #[cfg(any(
        feature = "c",
        feature = "cpp",
        feature = "csharp",
        feature = "groovy",
        feature = "irules",
        feature = "java",
        feature = "kotlin",
        feature = "mozcpp",
        feature = "objc",
        feature = "perl",
        feature = "ruby",
        feature = "tcl",
    ))]
    fn ops_of<T: crate::MetricSuite>(source: &str, file: &str) -> crate::ops::Ops {
        let path = PathBuf::from(file);
        let parser = T::new(source.as_bytes().to_vec(), &path, None);
        crate::ops::ops_inner(&parser, None).expect("ops walk succeeds")
    }

    // Pins the lesson-4 invariant `n2 == len(dedupe(ops.operands))` by
    // running `operands_and_operators` (the text-keyed `--ops` store)
    // on the same source and comparing its deduplicated operand count
    // to the expected `n2`. The metrics store and the ops store are
    // independent (lesson 4); this catches a classification change that
    // moves one without the other.
    // `#[track_caller]` so a failure reports the *caller's* line rather
    // than this helper's. Callers that wrap it in a per-language helper
    // (`assert_char_literal_operands`, #1316) are tracked too, so the
    // reported location names the language row instead of a shared line
    // no assertion message distinguishes.
    #[cfg(any(
        feature = "c",
        feature = "cpp",
        feature = "groovy",
        feature = "irules",
        feature = "kotlin",
        feature = "mozcpp",
        feature = "objc",
        feature = "perl",
        feature = "ruby",
        feature = "tcl",
    ))]
    #[track_caller]
    fn assert_ops_operands<T: crate::MetricSuite>(
        source: &str,
        file: &str,
        expected_n2: usize,
        mut expected_operands: Vec<&str>,
    ) {
        let ops = ops_of::<T>(source, file);

        let unique: HashSet<&str> = ops.operands.iter().map(String::as_str).collect();
        assert_eq!(
            unique.len(),
            expected_n2,
            "dedupe(ops.operands) must equal n2; operands were {:?}",
            ops.operands
        );

        let mut got: Vec<&str> = unique.into_iter().collect();
        got.sort_unstable();
        expected_operands.sort_unstable();
        assert_eq!(got, expected_operands, "operand vocabulary for {file}");
    }

    /// Asserts each keyword in `keywords` reaches the operand vocabulary
    /// and reaches the operator vocabulary nowhere.
    ///
    /// Both halves are load-bearing for #1380. A keyword listed in two
    /// arms is billed twice — once into `n1`/`N1` and once into
    /// `n2`/`N2` — and an assertion that only looked for its arrival
    /// among the operands would pass on that. The operator side is what
    /// pins the removal.
    #[cfg(any(
        feature = "csharp",
        feature = "groovy",
        feature = "java",
        feature = "kotlin"
    ))]
    #[track_caller]
    fn assert_keywords_are_operands_only<T: crate::MetricSuite>(
        source: &str,
        file: &str,
        keywords: &[&str],
    ) {
        let ops = ops_of::<T>(source, file);

        for keyword in keywords {
            assert!(
                ops.operands.iter().any(|o| o == keyword),
                "{file}: `{keyword}` must be an operand; operands were {:?}",
                ops.operands
            );
            assert!(
                !ops.operators.iter().any(|o| o == keyword),
                "{file}: `{keyword}` must not be an operator; operators were {:?}",
                ops.operators
            );
        }
    }

    /// How one space's vocabularies classify a single keyword.
    #[derive(Debug, PartialEq, Eq)]
    enum Role {
        OperatorOnly,
        OperandOnly,
        Both,
    }

    /// Records `keyword`'s role in `ops` and in every space below it.
    ///
    /// A space that bills the keyword in neither vocabulary contributes
    /// no row, so the result is the set of places the keyword actually
    /// reaches — which is what distinguishes a parent gate from its own
    /// inverse, and what the merged root vocabulary cannot show.
    #[cfg(feature = "csharp")]
    fn collect_keyword_roles(ops: &crate::ops::Ops, keyword: &str, out: &mut Vec<Role>) {
        let operator = ops.operators.iter().any(|o| o == keyword);
        let operand = ops.operands.iter().any(|o| o == keyword);
        match (operator, operand) {
            (true, true) => out.push(Role::Both),
            (true, false) => out.push(Role::OperatorOnly),
            (false, true) => out.push(Role::OperandOnly),
            (false, false) => {}
        }
        for space in &ops.spaces {
            collect_keyword_roles(space, keyword, out);
        }
    }

    /// Pins the three grammar facts every #1380 operand arm rests on,
    /// over a fixture that samples one self- or super-reference per
    /// syntactic position the language allows.
    ///
    /// Each `keywords` row is `(spelling, kind_id, occurrences)`.
    ///
    /// * **Grammar-dispatch section 1.** Every node the grammar spells
    ///   `this` / `super` / `base` / `this@` / `super@` carries the one
    ///   `kind_id` its arm lists. An alias arises in a *different*
    ///   syntactic position, which no fixture can enumerate, so this is
    ///   the weaker half of the alias evidence — the strong half is that
    ///   these generated enums carry numeric-suffix aliases in quantity
    ///   and none spells a `This2`. What this loop catches is a grammar
    ///   bump introducing one under an existing fixture.
    /// * **Grammar-dispatch section 5.** Each is a childless leaf and no
    ///   node *containing* it is classified, so the reference cannot be
    ///   billed twice. Every ancestor is checked, not just the parent:
    ///   Kotlin puts `this_expression` *and* `navigation_expression`
    ///   between the leaf and the nearest classified node, and the claim
    ///   the arms make is about containment, not parentage.
    /// * **Grammar-dispatch section 11.** The arm is unconditional. A
    ///   parent-scoped guard added later — the shape the two deliberate
    ///   carve-outs use, and so the shape a reviewer might reasonably
    ///   add — would satisfy the single-position count tests and still
    ///   drop `this` in a method reference or a constructor delegation.
    ///
    /// The fixtures deliberately exclude the two gated positions (C#'s
    /// indexer declarator, Java's wildcard bound); those are operators,
    /// and their own tests pin them.
    #[cfg(any(feature = "csharp", feature = "java", feature = "kotlin"))]
    #[track_caller]
    fn assert_self_reference_leaves<L: LanguageInfo + Getter>(
        source: &str,
        keywords: &[(&str, u16, usize)],
        label: &str,
    ) {
        let code = source.as_bytes();
        let mut seen = vec![0_usize; keywords.len()];

        for_each_node_with_chain::<L>(code, |node, chain| {
            let Some(index) = keywords.iter().position(|(kw, _, _)| *kw == node.kind()) else {
                return;
            };
            let (keyword, kind_id, _) = keywords[index];
            seen[index] += 1;

            assert_eq!(
                node.kind_id(),
                kind_id,
                "{label}: a `{keyword}` carries kind_id {} rather than the {kind_id} its arm \
                 lists — an alias the arm cannot see",
                node.kind_id()
            );
            assert_eq!(
                node.child_count(),
                0,
                "{label}: `{keyword}` grew children, which the operand arm would now \
                 double-count against"
            );
            for (depth, ancestor) in chain.iter().enumerate() {
                assert!(
                    matches!(
                        L::get_op_type_with_code(ancestor, code, Ancestors::known(&chain[..depth])),
                        TokenRole::Unknown
                    ),
                    "{label}: `{}` contains a `{keyword}` and is itself classified, so the \
                     reference now counts twice",
                    ancestor.kind()
                );
            }
            // `_with_code` is the spelling `compute_halstead` calls. The
            // default forwards to the byte-less form, so asking the wrong
            // one reads as correct right up until a language grows an
            // override (grammar-dispatch section 7).
            assert!(
                matches!(
                    L::get_op_type_with_code(node, code, Ancestors::known(chain)),
                    TokenRole::Operand
                ),
                "{label}: a `{keyword}` under `{}` is not an operand",
                chain.last().map_or("<root>", Node::kind)
            );
        });

        for ((keyword, _, expected), got) in keywords.iter().zip(&seen) {
            assert_eq!(
                got, expected,
                "{label}: fixture holds {got} `{keyword}` rather than {expected}"
            );
        }
    }

    /// Asserts the root space's `[n1, N1, n2, N2]`, naming `label` when
    /// it does not hold.
    ///
    /// The delimiter-invariance tests (#1256 Elixir, #1312 Ruby and
    /// Perl) each loop over spellings of one literal and need the
    /// spelling in the failure message; `check_metrics` expands to a
    /// plain `fn` that cannot capture a loop variable, so they reach
    /// for the closure-taking helper it wraps. Three copies of that
    /// dance is two too many.
    #[cfg(any(
        feature = "bash",
        feature = "c",
        feature = "cpp",
        feature = "csharp",
        feature = "elixir",
        feature = "groovy",
        feature = "irules",
        feature = "java",
        feature = "javascript",
        feature = "kotlin",
        feature = "mozcpp",
        feature = "mozjs",
        feature = "objc",
        feature = "perl",
        feature = "php",
        feature = "ruby",
        feature = "tcl",
        feature = "typescript",
    ))]
    fn assert_halstead_counts<T: crate::MetricSuite>(
        source: &str,
        file: &str,
        expected: [u64; 4],
        label: &str,
    ) {
        crate::test_support::check_func_space_only::<T, _>(
            source,
            file,
            &[crate::Metric::Halstead],
            |space| {
                let halstead = &space.metrics.halstead;
                assert_eq!(
                    [
                        halstead.unique_operators(),
                        halstead.total_operators(),
                        halstead.unique_operands(),
                        halstead.total_operands(),
                    ],
                    expected,
                    "{label}"
                );
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_operators_and_operands() {
        check_metrics::<PythonParser>(
            "def foo():
                 def bar():
                     def toto():
                        a = 1 + 1
                     b = 2 + a
                 c = 3 + 3",
            "foo.py",
            |metric| {
                // unique operators: def, =, +
                // operators: def, def, def, =, =, =, +, +, +
                // unique operands: foo, bar, toto, a, b, c, 1, 2, 3
                // operands: foo, bar, toto, a, b, c, 1, 1, 2, a, 3, 3
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 3,
                  "total_operators": 9,
                  "unique_operands": 9,
                  "total_operands": 12,
                  "length": 21,
                  "estimated_program_length": 33.284212515144276,
                  "purity_ratio": 1.584962500721156,
                  "vocabulary": 12,
                  "volume": 75.28421251514428,
                  "difficulty": 2.0,
                  "level": 0.5,
                  "effort": 150.56842503028855,
                  "time": 8.364912501682698,
                  "bugs": 0.0094341190071077
                }
                "#
                );
            },
        );
    }

    /// Pointer-arithmetic operators: `*` (dereference), `&` (address-of),
    /// `->` (member-of-pointer), `+` (pointer + offset). Each is counted
    /// once in `n1`; multiple uses bump `N1`. The headline integer values
    /// (`u_operators`, `u_operands`) anchor the snapshot per the
    /// snapshot-anchor policy.
    #[cfg(feature = "c")]
    #[test]
    fn c_pointer_arithmetic_operators() {
        check_metrics::<CParser>(
            "int g(int* p, int* q) {
                 return *(p + 1) + *q;
             }",
            "foo.c",
            |metric| {
                // Unique operators: int, *, (), {, }, +, ;, return  (= 8)
                //   `*` covers both pointer-type and dereference; the grammar
                //   does NOT split them.  `,` does not appear (only one
                //   parameter on each side of the body).
                // Unique operands: g, p, q, 1                       (= 4)
                assert_eq!(metric.halstead.unique_operators(), 8);
                assert_eq!(metric.halstead.unique_operands(), 4);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    /// Bitwise (`&`, `|`, `^`, `~`, `<<`, `>>`) and logical (`&&`, `||`,
    /// `!`) operators are distinct kind_ids and count as separate unique
    /// operators in Halstead.  `&` (bitwise-and) and `&&` (logical-and)
    /// must NOT collapse, even though both render as ampersands.
    #[cfg(feature = "c")]
    #[test]
    fn c_bitwise_and_logical_operators() {
        check_metrics::<CParser>(
            "int f(int a, int b) {
                 int x = (a & b) | (a ^ b);
                 int y = ~a;
                 int z = (a << 1) >> 2;
                 return (a && b) || !x;
             }",
            "foo.c",
            |metric| {
                // Expect: 6 bitwise op kinds (& | ^ ~ << >>), 3 logical (&& || !).
                // Plus int, (), {, }, =, ;, return, , — 8 syntactic / arithmetic
                // operator kinds.  Six bitwise + three logical + eight = 17 unique
                // operators is the upper bound; actuals depend on grammar collapse,
                // so we assert a lower-bound and anchor via snapshot below.
                let s = &metric.halstead;
                assert!(
                    s.unique_operators() >= 14,
                    "expected >= 14 unique operators (bitwise + logical + syntax), got {}",
                    s.unique_operators(),
                );
                assert_eq!(s.unique_operands(), 8); // f, a, b, x, y, z, 1, 2
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    /// Increment / decrement (`++`, `--`) and `sizeof` / cast operators
    /// each contribute distinct unique operators.  C-style casts in the
    /// tree-sitter grammar surface as `cast_expression` with the type
    /// token classified as a primitive_type operator.
    #[cfg(feature = "c")]
    #[test]
    fn c_increment_decrement_and_sizeof() {
        check_metrics::<CParser>(
            "void f(int* p) {
                 int n = sizeof(int);
                 ++p;
                 --n;
                 long w = (long) n;
             }",
            "foo.c",
            |metric| {
                // Unique operators include: void, int, long, *, =, sizeof, ++, --, (), {, }, ;
                // Unique operands: f, p, n, w
                let s = &metric.halstead;
                assert!(
                    s.unique_operators() >= 10,
                    "expected >= 10 unique operators including ++ / -- / sizeof / cast, got {}",
                    s.unique_operators(),
                );
                assert_eq!(s.unique_operands(), 4);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_operators_and_operands() {
        // Define operators and operands for C/C++ grammar according to this specification:
        // https://www.verifysoft.com/en_halstead_metrics.html
        // The only difference with the specification above is that
        // primitive types are treated as operators, since the definition of a
        // primitive type can be seen as the creation of a slot of a certain size.
        // i.e. The `int a;` definition creates a n-bytes slot.
        check_metrics::<CppParser>(
            "main()
            {
              int a, b, c, avg;
              scanf(\"%d %d %d\", &a, &b, &c);
              avg = (a + b + c) / 3;
              printf(\"avg = %d\", avg);
            }",
            "foo.c",
            |metric| {
                // unique operators: (), {}, int, &, =, +, /, ,, ;
                // unique operands: main, a, b, c, avg, scanf, "%d %d %d", 3, printf, "avg = %d"
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 9,
                  "total_operators": 24,
                  "unique_operands": 10,
                  "total_operands": 18,
                  "length": 42,
                  "estimated_program_length": 61.74860596185444,
                  "purity_ratio": 1.470204903853677,
                  "vocabulary": 19,
                  "volume": 178.41295556463058,
                  "difficulty": 8.1,
                  "level": 0.1234567901234568,
                  "effort": 1445.1449400735075,
                  "time": 80.28583000408375,
                  "bugs": 0.04260752914034329
                }
                "#
                );
            },
        );
    }

    /// A `sized_type_specifier` carries its `unsigned`/`signed`/`long`/
    /// `short` modifiers as bare keyword tokens (distinct kind_ids), not
    /// as `primitive_type` children. Prior to issue #466 those tokens
    /// fell through to the `Unknown` arm and were dropped from `n1`/`N1`,
    /// so `unsigned int` collapsed to just `int` and `signed long`
    /// contributed nothing. They must each count as a distinct operator,
    /// while `long long`'s two `long` tokens fold to one `n1` entry but
    /// two `N1` hits. Regression test for issue #466.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_sized_type_specifier_operators() {
        let source = "unsigned int u = 3; signed long b = 4; long long c = 5;";
        check_metrics::<CppParser>(source, "foo.cpp", |metric| {
            // Distinct operators (n1): unsigned, signed, long, int, =, ; = 6
            // Total operators (N1):
            //   unsigned(1) + int(1) + =(3) + ;(3) + signed(1) + long(3) = 12
            //   (`long` appears once in `signed long` and twice in `long long`)
            // Distinct/total operands: u, b, c, 3, 4, 5 = 6 / 6
            assert_eq!(metric.halstead.unique_operators(), 6);
            assert_eq!(metric.halstead.total_operators(), 12);
            assert_eq!(metric.halstead.unique_operands(), 6);
            assert_eq!(metric.halstead.total_operands(), 6);
        });

        // Pin the lesson-4 `n1 == dedupe(ops.operators)` invariant: the
        // kind_id-keyed metrics store and the text-keyed `--ops` store are
        // independent, so a modifier classified in one but not the other
        // would diverge here.
        let path = PathBuf::from("foo.cpp");
        let parser = CppParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        let unique_operators: HashSet<&str> = ops.operators.iter().map(String::as_str).collect();
        assert_eq!(
            unique_operators.len(),
            6,
            "dedupe(ops.operators) must equal n1; operators were {:?}",
            ops.operators
        );
        for modifier in ["unsigned", "signed", "long"] {
            assert!(
                unique_operators.contains(modifier),
                "sized_type_specifier modifier {modifier:?} missing from ops.operators: {:?}",
                ops.operators
            );
        }
    }

    /// C++20 spaceship operator `<=>` (`Cpp::LTEQGT`) is a comparison
    /// operator and must be counted in Halstead, like its sibling
    /// comparison operators `<`, `>`, `<=`, `>=`, `==`, `!=`. Prior to
    /// this fix it fell through to the `Unknown` arm and was silently
    /// dropped from `n1` / `N1`, under-reporting volume / effort on any
    /// C++20+ codebase that defines `operator<=>`. Regression test for
    /// issue #197.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_spaceship_operator_is_halstead_operator() {
        check_metrics::<CppParser>(
            "int f(int a, int b) {
                 return (a <=> b) != 0;
             }",
            "foo.cpp",
            |metric| {
                // Unique operators (grammar collapses matched delimiters
                // to a single kind_id): int, (), {}, <=>, !=, return, ;, ,
                //   `<=>` is the regression target — without the fix it
                //   would be Unknown and `u_operators` would be 7.
                // Unique operands: f, a, b, 0
                let s = &metric.halstead;
                assert_eq!(s.unique_operators(), 8);
                assert_eq!(s.unique_operands(), 4);
                insta::assert_json_snapshot!(
                    s,
                    @r#"
                {
                  "unique_operators": 8,
                  "total_operators": 11,
                  "unique_operands": 4,
                  "total_operands": 6,
                  "length": 17,
                  "estimated_program_length": 32.0,
                  "purity_ratio": 1.8823529411764706,
                  "vocabulary": 12,
                  "volume": 60.94436251225965,
                  "difficulty": 6.0,
                  "level": 0.16666666666666666,
                  "effort": 365.6661750735579,
                  "time": 20.31478750408655,
                  "bugs": 0.01704519358507665
                }
                "#
                );
            },
        );
    }

    /// C++ compound subtract-assign `-=` (`Cpp::DASHEQ`) must be counted
    /// in Halstead like every other compound assignment (`+=`, `*=`,
    /// `/=`, etc.). Prior to the fix it fell through to the `Unknown`
    /// arm and was silently dropped from `n1` / `N1` — under-reporting
    /// volume / effort wherever C++ code subtracts in place. Regression
    /// test for issue #198.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_dash_eq_is_halstead_operator() {
        check_metrics::<CppParser>("void f(int a, int b) { a -= b; }", "foo.cpp", |metric| {
            // Unique operators: void, (), {}, int, ,, -=, ;
            //   `-=` is the regression target — without the fix it
            //   would be Unknown and `u_operators` would be 6.
            // Unique operands: f, a, b
            let s = &metric.halstead;
            assert_eq!(s.unique_operators(), 7);
            assert_eq!(s.unique_operands(), 3);
        });
    }

    /// C++ pointer-to-member access `.*` (`Cpp::DOTSTAR`) must be
    /// counted in Halstead. Prior to the fix it fell through to the
    /// `Unknown` arm and was silently dropped from `n1` / `N1`.
    /// Regression test for issue #198.
    ///
    /// The snippet uses an `operator.*` declaration because that is
    /// where the C++ tree-sitter grammar reliably emits a single
    /// `DOTSTAR` leaf; in expression position (`a.*b`) some grammar
    /// versions split the token into `DOT` + `STAR` and the regression
    /// would be masked.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_dot_star_is_halstead_operator() {
        check_metrics::<CppParser>("struct S { void operator.*(int); };", "foo.cpp", |metric| {
            // Unique operators with fix: {}, ;, (), int, void, .*
            //   `.*` is the regression target — without the fix it
            //   falls through to `Unknown` and `u_operators` is 5.
            // Unique operands: S
            let s = &metric.halstead;
            assert_eq!(s.unique_operators(), 6);
            assert_eq!(s.unique_operands(), 1);
        });
    }

    /// C++ pointer-to-member access through pointer `->*`
    /// (`Cpp::DASHGTSTAR`) must be counted in Halstead. Prior to the
    /// fix it fell through to the `Unknown` arm and was silently
    /// dropped from `n1` / `N1`. Regression test for issue #198.
    ///
    /// The snippet uses an `operator->*` declaration because that is
    /// where the C++ tree-sitter grammar reliably emits a single
    /// `DASHGTSTAR` leaf; in expression position (`a->*b`) the grammar
    /// splits the token into `DASHGT` + `STAR` and the regression would
    /// be masked.
    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_dash_gt_star_is_halstead_operator() {
        check_metrics::<CppParser>(
            "struct S { void operator->*(int); };",
            "foo.cpp",
            |metric| {
                // Unique operators with fix: {}, ;, (), int, void, ->*
                //   `->*` is the regression target — without the fix it
                //   falls through to `Unknown` and `u_operators` is 5.
                // Unique operands: S
                let s = &metric.halstead;
                assert_eq!(s.unique_operators(), 6);
                assert_eq!(s.unique_operands(), 1);
            },
        );
    }

    #[cfg(feature = "cpp")]
    #[test]
    fn cpp_raw_string_delimiter_is_not_an_operator() {
        // Regression: issue #1314, the C++ sibling of Elixir #1256 and
        // Ruby/Perl #1312. A `raw_string_literal` carries its `R"(`
        // opener as a bare `LPAREN` child — the kind id a call uses —
        // so `auto a = R"(raw)";` reported a `()` operator with no call
        // in the source.
        //
        // The fixture holds both sides at once: two raw strings and one
        // real call. A guard widened past the literal would drop
        // `f(a)`'s parenthesis and fail here rather than silently
        // passing.
        //
        // The second literal uses the custom-delimiter form to pin that
        // shape too — it adds a `raw_string_delimiter` child but keeps
        // the same `(` — and its distinct text makes n2 differ from N2.
        //
        // expected: operators `;` × 3, `=` × 3, `int`, `()` × 1 →
        // n1 = 4, N1 = 8. Operands the two literals, `a` × 2, `b`, `c`,
        // `f` → n2 = 6, N2 = 7. Before the guard the two openers added
        // two more `()` → N1 = 10.
        check_metrics::<CppParser>(
            "auto a = R\"(raw)\";\nauto b = R\"tag(raw)tag\";\nint c = f(a);\n",
            "foo.cpp",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 4);
                assert_eq!(metric.halstead.total_operators(), 8);
                assert_eq!(metric.halstead.unique_operands(), 6);
                assert_eq!(metric.halstead.total_operands(), 7);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_operators_and_operands() {
        check_metrics::<RustParser>(
            "fn main() {
              let a = 5; let b = 5; let c = 5;
              let avg = (a + b + c) / 3;
              println!(\"{}\", avg);
            }",
            "foo.rs",
            |metric| {
                // unique operators: fn, (), {}, let, =, +, /, ;, !, ,
                // unique operands: main, a, b, c, avg, 5, 3, println, "{}"
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 10,
                  "total_operators": 23,
                  "unique_operands": 9,
                  "total_operands": 15,
                  "length": 38,
                  "estimated_program_length": 61.74860596185444,
                  "purity_ratio": 1.624963314785643,
                  "vocabulary": 19,
                  "volume": 161.42124551085624,
                  "difficulty": 8.333333333333334,
                  "level": 0.12,
                  "effort": 1345.177045923802,
                  "time": 74.7320581068779,
                  "bugs": 0.040619232256751396
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_aliased_primitive_type_classification() {
        // Regression for issue #95 (lesson #2): the Rust grammar emits 17
        // distinct `kind_id`s for `primitive_type` (one base plus 16
        // numeric-suffixed alias variants). `RustCode::is_primitive` in
        // `big-code-analysis-ast/src/checker.rs` must list every variant;
        // if a future regression omits one, primitive type names emitted
        // in that aliased position silently drop into the kind_id-keyed
        // operators bucket instead of the text-keyed primitive_operators
        // map, miscounting Halstead n1.
        //
        // The snippet exercises every primitive scalar type across many
        // syntactic positions (function parameter types, return types,
        // let-binding annotations, `as` casts, const items, type aliases,
        // struct fields, function pointer types, tuple types, array types,
        // reference types, generic type arguments). Empirically, ordinary
        // Rust source emits the base `Rust::PrimitiveType` variant from
        // all of these positions; the 16 suffixed alias variants are
        // produced by specific grammar productions not reachable from
        // user-written code. Mutation-verified: dropping
        // `Rust::PrimitiveType` from `is_primitive` fails this test
        // (u_operators 30→15). Dropping any single suffixed variant
        // currently leaves the test passing; if a future grammar bump
        // makes any suffixed variant reachable from idiomatic source,
        // extend the snippet so the test fires for that variant too.
        check_metrics::<RustParser>(
            "const C: u8 = 0;
            type T = i64;
            struct S { x: u32, y: u64 }
            fn g(p: fn(u8) -> u16) -> bool { let _ = p(0); true }
            fn f(a: u8, b: u16, c: u32, d: u64) -> u128 {
                let _x: i8 = 0;
                let _y: i16 = 0;
                let _z: i32 = 0;
                let _w: i64 = 0;
                let _v: i128 = 0;
                let _p: f32 = 1.0;
                let _q: f64 = 2.0;
                let _r: bool = true;
                let _s: char = 'x';
                let _t: usize = 0;
                let _u: isize = 0;
                let _arr: [u32; 4] = [0; 4];
                let _ref: &u8 = &0;
                let _tup: (u32, u64) = (0, 0);
                let _opt: Option<u32> = None;
                a as u128 + b as u128 + c as u128 + d
            }",
            "foo.rs",
            |metric| {
                // Headline: u_operators is the load-bearing assertion —
                // the 16 distinct primitive type names dedupe by text in
                // the primitive_operators map. Total operators (N1) and
                // operand counts pin the rest of the Halstead state.
                // Grew from 30 → 33 with the issue #394 fix: `const`,
                // `type`, and `struct` keywords are now classified as
                // operators (one occurrence each).
                assert_eq!(metric.halstead.unique_operators(), 33);
                assert_eq!(metric.halstead.total_operators(), 121);
                // u_operands / operands grew (was 31/50 before #390): the
                // fix now classifies TypeIdentifier (`T`, `S`, `Option`)
                // and FieldIdentifier (struct fields `x`, `y`) as operands
                // alongside the existing primitive type names.
                assert_eq!(metric.halstead.unique_operands(), 36);
                assert_eq!(metric.halstead.total_operands(), 55);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_field_identifier_is_operand() {
        // Regression for issue #390: prior to the fix, `FieldIdentifier`
        // (e.g. the `x` / `y` in `p.x`, `p.y`) fell through to
        // `TokenRole::Unknown`, so the field names were not counted
        // as operands. Both C++ and Go already classify FieldIdentifier
        // as an operand. After the fix:
        //   unique operators: fn, (), {}, let, =, +, ;, .
        //   unique operands : main, p, Point, x, y, sum, 0, 1
        // Field names `x` and `y` each appear twice (`p.x + p.y` and
        // the struct literal `Point { x: 0, y: 1 }`).
        check_metrics::<RustParser>(
            "fn main() {
              let p = Point { x: 0, y: 1 };
              let sum = p.x + p.y;
            }",
            "foo.rs",
            |metric| {
                // Headline: pre-fix, FieldIdentifier (`x`, `y`) and
                // TypeIdentifier (`Point`) fell through to Unknown, so
                // u_operands was 5 (main, p, sum, 0, 1). After the
                // fix, +Point, +x, +y → 8 distinct names.
                assert_eq!(metric.halstead.unique_operands(), 8);
                assert_eq!(metric.halstead.total_operands(), 12);
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 9,
                  "total_operators": 14,
                  "unique_operands": 8,
                  "total_operands": 12,
                  "length": 26,
                  "estimated_program_length": 52.529325012980806,
                  "purity_ratio": 2.0203586543454155,
                  "vocabulary": 17,
                  "volume": 106.27403387250882,
                  "difficulty": 6.75,
                  "level": 0.14814814814814814,
                  "effort": 717.3497286394346,
                  "time": 39.85276270219081,
                  "bugs": 0.026711567292222575
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_type_identifier_is_operand() {
        // Regression for issue #390: `TypeIdentifier` (e.g. `Vec`,
        // `HashMap`, `String` when used as a path name) was dropped to
        // `TokenRole::Unknown` for Rust. C++ and Go classify them as
        // operands. After the fix, u_operands = 8:
        //   main, v, m, Vec, HashMap, new, K, V
        // (`i32` is a primitive type, classified as an operator.)
        //
        // Also covers issue #394: `::` is now an operator. The snippet
        // has two `::` tokens (`Vec::new`, `HashMap::new`), so n1 grew
        // from 10 → 11 and N1 from 17 → 19.
        check_metrics::<RustParser>(
            "fn main() {
              let v: Vec<i32> = Vec::new();
              let m: HashMap<K, V> = HashMap::new();
            }",
            "foo.rs",
            |metric| {
                // Headline: u_operands includes `Vec`, `HashMap`, `K`,
                // `V` (and `i32` as a primitive operator). Without the
                // fix, Vec/HashMap/K/V silently dropped to Unknown.
                assert_eq!(metric.halstead.unique_operands(), 8);
                assert_eq!(metric.halstead.total_operands(), 11);
                // `::` appears twice (Vec::new, HashMap::new); without
                // the #394 fix u_operators was 10 and operators 17.
                assert_eq!(metric.halstead.unique_operators(), 11);
                assert_eq!(metric.halstead.total_operators(), 19);
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 11,
                  "total_operators": 19,
                  "unique_operands": 8,
                  "total_operands": 11,
                  "length": 30,
                  "estimated_program_length": 62.05374780501027,
                  "purity_ratio": 2.068458260167009,
                  "vocabulary": 19,
                  "volume": 127.43782540330756,
                  "difficulty": 7.5625,
                  "level": 0.1322314049586777,
                  "effort": 963.7485546125134,
                  "time": 53.54158636736186,
                  "bugs": 0.03252279825177962
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_path_separator_is_operator() {
        // Regression for issue #394: `::` (`COLONCOLON`) was missing
        // from the Rust `get_op_type` operator arm even though C++,
        // Java, C#, and Kotlin all classify it as an operator. Path-
        // heavy code (`std::collections::HashMap`, `Vec::new`,
        // `T::method`) had every `::` silently dropped into
        // TokenRole::Unknown.
        //
        // Snippet has three `::` tokens (`std::collections::HashMap`,
        // counted as two `::` separators, plus `HashMap::new`).
        check_metrics::<RustParser>(
            "fn main() {
              let m = std::collections::HashMap::new();
            }",
            "foo.rs",
            |metric| {
                // `::` appears 3 times across the two path expressions
                // (`std::collections::HashMap` contributes two; the
                // `HashMap::new` contributes one). Pre-fix all three
                // dropped to Unknown: u_operators would be 6 (no `::`
                // distinct) and total_operators() would be 7 (minus 3 `::`
                // occurrences). With the fix u_operators=7 and
                // operators=10.
                //
                // unique operators (post-fix): fn, LPAREN, LBRACE,
                // let, =, ::, ;. unique operands: main, m, std,
                // collections, HashMap, new.
                assert_eq!(metric.halstead.unique_operators(), 7);
                assert_eq!(metric.halstead.total_operators(), 10);
                assert_eq!(metric.halstead.unique_operands(), 6);
                assert_eq!(metric.halstead.total_operands(), 6);
            },
        );
    }

    #[cfg(feature = "rust")]
    #[test]
    fn rust_declaration_keywords_are_operators() {
        // Regression for issue #394: the Rust impl already accepted 17
        // keywords as operators (As, Async, Await, …, Fn) but omitted
        // 14 declaration / visibility keywords. The fix adds `Const`,
        // `Static`, `Enum`, `Struct`, `Trait`, `Impl`, `Use`, `Mod`,
        // `Pub`, `Type`, `Union`, `Where`, `Extern`, `Dyn`.
        //
        // Snippet exercises `use`, `pub`, `struct`, and `impl` (one of
        // each); together they account for 4 new operator occurrences
        // and 4 new unique operators.
        check_metrics::<RustParser>(
            "use std::fmt;
            pub struct S;
            impl S { fn n() -> u8 { 0 } }",
            "foo.rs",
            |metric| {
                // expected: unique operators (11) = use, ::, ;, pub,
                // struct, impl, LBRACE, fn, LPAREN, DASHGT, u8. Without
                // the #394 fix, `use`, `pub`, `struct`, and `impl`
                // would each drop to Unknown and u_operators would be
                // 7. unique operands (5): std, fmt, S, n, 0.
                assert_eq!(metric.halstead.unique_operators(), 11);
                assert_eq!(metric.halstead.total_operators(), 13);
                assert_eq!(metric.halstead.unique_operands(), 5);
                assert_eq!(metric.halstead.total_operands(), 6);
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_operators_and_operands() {
        check_metrics::<JavascriptParser>(
            "function main() {
              var a, b, c, avg;
              a = 5; b = 5; c = 5;
              avg = (a + b + c) / 3;
              console.log(\"{}\", avg);
            }",
            "foo.js",
            |metric| {
                // unique operators: function, (), {}, var, =, +, /, ,, ., ;
                // unique operands: main, a, b, c, avg, 3, 5, console, log, "{}"
                // `console.log` is the `.` operator applied to the two
                // identifier leaves; the composite `member_expression`
                // text is deliberately not a third operand (#1263), so
                // n2/N2 are 10/20 rather than the pre-#1263 11/21.
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 10,
                  "total_operators": 24,
                  "unique_operands": 10,
                  "total_operands": 20,
                  "length": 44,
                  "estimated_program_length": 66.43856189774725,
                  "purity_ratio": 1.5099673158578921,
                  "vocabulary": 20,
                  "volume": 190.16483617504394,
                  "difficulty": 10.0,
                  "level": 0.1,
                  "effort": 1901.6483617504396,
                  "time": 105.64713120835775,
                  "bugs": 0.05116412536051621
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_operators_and_operands() {
        check_metrics::<MozjsParser>(
            "function main() {
              var a, b, c, avg;
              a = 5; b = 5; c = 5;
              avg = (a + b + c) / 3;
              console.log(\"{}\", avg);
            }",
            "foo.js",
            |metric| {
                // unique operators: function, (), {}, var, =, +, /, ,, ., ;
                // unique operands: main, a, b, c, avg, 3, 5, console, log, "{}"
                // `console.log` is the `.` operator applied to the two
                // identifier leaves; the composite `member_expression`
                // text is deliberately not a third operand (#1263), so
                // n2/N2 are 10/20 rather than the pre-#1263 11/21.
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 10,
                  "total_operators": 24,
                  "unique_operands": 10,
                  "total_operands": 20,
                  "length": 44,
                  "estimated_program_length": 66.43856189774725,
                  "purity_ratio": 1.5099673158578921,
                  "vocabulary": 20,
                  "volume": 190.16483617504394,
                  "difficulty": 10.0,
                  "level": 0.1,
                  "effort": 1901.6483617504396,
                  "time": 105.64713120835775,
                  "bugs": 0.05116412536051621
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_operators_and_operands() {
        check_metrics::<TypescriptParser>(
            "function main() {
              var a, b, c, avg;
              a = 5; b = 5; c = 5;
              avg = (a + b + c) / 3;
              console.log(\"{}\", avg);
            }",
            "foo.ts",
            |metric| {
                // unique operators: function, (), {}, var, =, +, /, ,, ., ;
                // unique operands: main, a, b, c, avg, 3, 5, console, log, "{}"
                // `console.log` is the `.` operator applied to the two
                // identifier leaves; the composite `member_expression`
                // text is deliberately not a third operand (#1263), so
                // n2/N2 are 10/20 rather than the pre-#1263 11/21.
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 10,
                  "total_operators": 24,
                  "unique_operands": 10,
                  "total_operands": 20,
                  "length": 44,
                  "estimated_program_length": 66.43856189774725,
                  "purity_ratio": 1.5099673158578921,
                  "vocabulary": 20,
                  "volume": 190.16483617504394,
                  "difficulty": 10.0,
                  "level": 0.1,
                  "effort": 1901.6483617504396,
                  "time": 105.64713120835775,
                  "bugs": 0.05116412536051621
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_operators_and_operands() {
        check_metrics::<TsxParser>(
            "function main() {
              var a, b, c, avg;
              a = 5; b = 5; c = 5;
              avg = (a + b + c) / 3;
              console.log(\"{}\", avg);
            }",
            "foo.ts",
            |metric| {
                // unique operators: function, (), {}, var, =, +, /, ,, ., ;
                // unique operands: main, a, b, c, avg, 3, 5, console, log, "{}"
                // `console.log` is the `.` operator applied to the two
                // identifier leaves; the composite `member_expression`
                // text is deliberately not a third operand (#1263), so
                // n2/N2 are 10/20 rather than the pre-#1263 11/21.
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 10,
                  "total_operators": 24,
                  "unique_operands": 10,
                  "total_operands": 20,
                  "length": 44,
                  "estimated_program_length": 66.43856189774725,
                  "purity_ratio": 1.5099673158578921,
                  "vocabulary": 20,
                  "volume": 190.16483617504394,
                  "difficulty": 10.0,
                  "level": 0.1,
                  "effort": 1901.6483617504396,
                  "time": 105.64713120835775,
                  "bugs": 0.05116412536051621
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_template_string_plain_is_operand() {
        // Regression: issue #192. A backtick-delimited `` `hello` ``
        // without `${...}` is semantically identical to `"hello"` /
        // `'hello'` and must contribute exactly one operand — before
        // the fix `TemplateString` fell through to `TokenRole::Unknown`
        // and contributed zero. expected: operands are `f` (function
        // name) and the wrapping `` `hello` `` template literal →
        // u_operands = 2, N2 = 2 (matches the equivalent
        // `function f() { return "hello"; }` baseline).
        check_metrics::<JavascriptParser>("function f() { return `hello`; }", "foo.js", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
    }

    /// Regression for #695. The `get` / `set` property-accessor keywords
    /// are operators, matching the C# getter's `Get | Set | Init | Add |
    /// Remove` accessor arm. Before #695 the JS family classified them as
    /// operands, so the same accessor keyword landed in opposite Halstead
    /// groups across languages. This pins them in the operator store and
    /// out of the operand store.
    #[cfg(feature = "javascript")]
    #[test]
    fn js_get_set_accessors_are_operators() {
        let source = "class C { get x() { return 1; } set x(v) { this._x = v; } }";
        let path = PathBuf::from("foo.js");
        let parser = JavascriptParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        assert!(
            ops.operators.iter().any(|o| o.as_str() == "get")
                && ops.operators.iter().any(|o| o.as_str() == "set"),
            "`get`/`set` accessors must be operators; operators were {:?}",
            ops.operators
        );
        assert!(
            !ops.operands.iter().any(|o| o.as_str() == "get")
                && !ops.operands.iter().any(|o| o.as_str() == "set"),
            "`get`/`set` accessors must not be operands; operands were {:?}",
            ops.operands
        );
    }

    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_template_string_interpolation_no_double_count() {
        // Regression: issue #192. An interpolated template literal
        // `` `Hi ${name}!` `` used to fall through to `Unknown`,
        // dropping the wrapper from the count entirely; the inner
        // `name` was still walked and counted via the
        // `TemplateSubstitution` child. Mirrors #183 (C#), #191
        // (Kotlin), #199 (Perl): the wrapper is skipped when a
        // `TemplateSubstitution` child is present so the inner
        // expression is not double-counted.
        //
        // expected: for `function f(name) { return ` + "`Hi ${name}!`"
        // + `; }`, operands are `f` and `name` (twice — `name` as the
        // parameter, then again inside the interpolation), so
        // u_operands = 2 and N2 = 3. Without the wrapper-skip guard
        // the wrapping literal would also be counted, lifting
        // u_operands to 3 and N2 to 4.
        check_metrics::<JavascriptParser>(
            "function f(name) { return `Hi ${name}!`; }",
            "foo.js",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 3);
            },
        );
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_template_string_plain_is_operand() {
        // Regression: issue #192. Mirrors
        // `javascript_template_string_plain_is_operand` for the
        // Firefox-mode dialect — the four JS-family `get_op_type`
        // impls share the same template-literal handling.
        check_metrics::<MozjsParser>("function f() { return `hello`; }", "foo.js", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_template_string_interpolation_no_double_count() {
        // Regression: issue #192. Mirrors
        // `javascript_template_string_interpolation_no_double_count`
        // for the Firefox-mode dialect.
        check_metrics::<MozjsParser>(
            "function f(name) { return `Hi ${name}!`; }",
            "foo.js",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 3);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_template_string_plain_is_operand() {
        // Regression: issue #192. Mirrors
        // `javascript_template_string_plain_is_operand` for
        // TypeScript — the four JS-family `get_op_type` impls share
        // the same template-literal handling.
        //
        // The `: string` annotation contributes no operand — its
        // keyword counts once, as the text-keyed operator (#1261) — so
        // the operands are `f` and `` `hello` `` (2 each). The headline
        // of this test — that the plain template literal contributes
        // one operand — is unaffected.
        check_metrics::<TypescriptParser>(
            "function f(): string { return `hello`; }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 2);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_template_string_interpolation_no_double_count() {
        // Regression: issue #192. Mirrors
        // `javascript_template_string_interpolation_no_double_count`
        // for TypeScript.
        //
        // The `: string` annotations contribute no operands (#1261).
        // Unique operands: `f`, `name` (2). Total operands: `f`, `name`
        // (param), `name` (in the interpolation) (3). The interpolation
        // guard from #192 still holds — the wrapping `` `Hi ${name}!` ``
        // is `Unknown`, not double-counted.
        check_metrics::<TypescriptParser>(
            "function f(name: string): string { return `Hi ${name}!`; }",
            "foo.ts",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 3);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_template_string_plain_is_operand() {
        // Regression: issue #192. Mirrors
        // `javascript_template_string_plain_is_operand` for the
        // TSX (TypeScript + JSX) variant.
        //
        // TSX's type-keyword `string` (`String3`) contributes no
        // operand, mirroring TS::String2 (#1261): operands are `f` and
        // `` `hello` `` (2 each).
        check_metrics::<TsxParser>(
            "function f(): string { return `hello`; }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 2);
            },
        );
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_template_string_interpolation_no_double_count() {
        // Regression: issue #192. Mirrors
        // `javascript_template_string_interpolation_no_double_count`
        // for the TSX (TypeScript + JSX) variant.
        //
        // The `: string` annotations contribute no `String3` operands
        // (#1261); see `typescript_template_string_…` for the count
        // derivation.
        check_metrics::<TsxParser>(
            "function f(name: string): string { return `Hi ${name}!`; }",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 3);
            },
        );
    }

    /// The JS-family regex fixture, asserted against all four grammars.
    ///
    /// `impl_js_family_get_op_type!` is instantiated four times against
    /// four distinct `kind_id` enums (`SLASH` 87/81/90/87, `Regex`
    /// 224/250/264/225), so each expansion is a separate compiled arm
    /// and a drift in one grammar is invisible if only one is checked
    /// (grammar-dispatch section 11).
    #[cfg(any(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    fn assert_js_family_counts(source: &str, expected: [u64; 4]) {
        assert_halstead_counts::<JavascriptParser>(source, "foo.js", expected, "javascript");
        assert_halstead_counts::<MozjsParser>(source, "foo.jsm", expected, "mozjs");
        assert_halstead_counts::<TypescriptParser>(source, "foo.ts", expected, "typescript");
        assert_halstead_counts::<TsxParser>(source, "foo.tsx", expected, "tsx");
    }

    #[cfg(all(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    #[test]
    fn js_family_regex_delimiters_are_not_operators() {
        // Regression: issue #1314, the JS-family sibling of Elixir
        // #1256 and Ruby/Perl #1312. A `regex` literal spells both of
        // its delimiters `SLASH` — the kind id real division uses — so
        // `const a = /abc/g;` reported a `/` operator with no division
        // in the source, and n1/N1 counted the literal's punctuation as
        // arithmetic.
        //
        // The same fixture pins the second, independent half: `Regex`
        // was in neither arm, so the literal contributed no operand
        // either and reached the vocabulary from *neither* side.
        //
        // expected: operators `const`, `=`, `;`, `let` → n1 = 4;
        // `const` `=` `;` on line 1, `let` `=` `;` on line 2, `=` `;`
        // on line 3 → N1 = 8. Operands `a`, `/abc/g`, `b` → n2 = 3,
        // with `a` used three times and `b` twice → N2 = 6.
        //
        // Before the fix: n1 = 5 and N1 = 10 (the two fabricated `/`),
        // n2 = 2 and N2 = 5 (no operand for the literal).
        //
        // The four values are deliberately distinct so no transposition
        // of the unique-vs-total axes inside `assert_halstead_counts`
        // can pass (#1312).
        assert_js_family_counts("const a = /abc/g;\nlet b = a;\nb = a;\n", [4, 8, 3, 6]);
    }

    #[cfg(all(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    #[test]
    fn js_family_division_survives_the_regex_guard() {
        // Control for #1314: the guard is scoped to a `Regex` parent,
        // so real division must still count. This fixture holds both
        // sides at once — two divisions and one regex literal — so a
        // guard widened to every `SLASH` fails here rather than
        // silently passing the test above.
        //
        // expected: operators `const`, `=`, `;`, `/` → n1 = 4; two
        // `const`, two `=`, two `;` and two `/` → N1 = 8. Operands
        // `q`, `a`, `b`, `c`, `r`, `/x/` → n2 = N2 = 6.
        assert_js_family_counts("const q = a / b / c;\nconst r = /x/;\n", [4, 8, 6, 6]);
    }

    #[cfg(all(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    #[test]
    fn js_regex_delimiter_guard_is_parent_scoped_is_unobservable() {
        // Companion to the two above, and a statement of what they do
        // *not* cover. Ruby's guard has
        // `ruby_regex_guard_is_parent_scoped_not_ancestor_scoped`
        // because a division inside `#{…}` sits under a `Regex`
        // ancestor without being its child. No JS fixture can do that:
        // a regex literal admits no nested expression at all, its
        // `regex_pattern` and `regex_flags` children being leaves. So
        // the ancestor-scoped mutant of this guard — the one #1256's
        // post-mortem says survives every ordinary fixture — is
        // unobservable here. Measured, not assumed.
        //
        // Rather than write a fixture that would pass under both
        // spellings and read as coverage, pin the grammar property the
        // claim rests on: within a fixture that puts a division, a
        // template substitution and a regex in one file, every `SLASH`
        // reachable *below* a `Regex` is its immediate child. Should a
        // bump start nesting expressions inside a regex, this turns red
        // and the distinction becomes both observable and worth a real
        // test.
        //
        // Checked against all four grammars, not just JavaScript: the
        // guard is instantiated four times against four distinct enums,
        // and the property this test exists to watch could hold in one
        // and lapse in another.
        let source = b"const a = /abc/g;\nconst q = x / y;\nconst t = `p ${x / y} ${/zz/} q`;\n";
        assert_regex_slashes_are_immediate_children::<crate::langs::JavascriptCode>(
            source,
            Javascript::SLASH as u16,
            Javascript::Regex as u16,
            "javascript",
        );
        assert_regex_slashes_are_immediate_children::<crate::langs::MozjsCode>(
            source,
            Mozjs::SLASH as u16,
            Mozjs::Regex as u16,
            "mozjs",
        );
        assert_regex_slashes_are_immediate_children::<crate::langs::TypescriptCode>(
            source,
            Typescript::SLASH as u16,
            Typescript::Regex as u16,
            "typescript",
        );
        assert_regex_slashes_are_immediate_children::<crate::langs::TsxCode>(
            source,
            Tsx::SLASH as u16,
            Tsx::Regex as u16,
            "tsx",
        );
    }

    /// Asserts every `slash` token below a `regex` node in `source` is
    /// that node's *immediate* child, for one grammar.
    ///
    /// Backs `js_regex_delimiter_guard_is_parent_scoped_is_unobservable`
    /// — see there for why the property is worth pinning.
    #[cfg(any(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    fn assert_regex_slashes_are_immediate_children<L: crate::traits::LanguageInfo>(
        source: &[u8],
        slash: u16,
        regex: u16,
        label: &str,
    ) {
        let mut slashes_below_a_regex = 0;
        let visited = for_each_node_with_chain::<L>(source, |node: &Node<'_>, chain| {
            if node.kind_id() != slash {
                return;
            }
            let Some(depth) = chain.iter().position(|a| a.kind_id() == regex) else {
                return;
            };
            slashes_below_a_regex += 1;
            assert_eq!(
                depth,
                chain.len() - 1,
                "{label}: a slash at row {} has a regex ancestor that is not its parent, so \
                 the parent-vs-ancestor mutant is now observable and needs a real test",
                node.start_row()
            );
        });
        assert!(visited > 20, "{label}: fixture is too small to prove much");
        // Without this the assertion above is vacuous whenever the
        // fixture stops containing a regex at all — the failure mode a
        // filter that matches nothing always has.
        assert_eq!(
            slashes_below_a_regex, 4,
            "{label}: expected the two regex literals' four delimiters; the fixture no \
             longer exercises what this test claims"
        );
    }

    // Issue #281: optional chaining (`?.`) was double-counted as a
    // Halstead operator in TypeScript and TSX because the grammar
    // exposes both an `optional_chain` named wrapper AND a child
    // `?.` token, and both were classified as `Operator`. The fix
    // counts only the bare `?.` token (`QMARKDOT`) in TS/TSX so each
    // textual `?.` contributes exactly once, matching JS / MozJS
    // (whose grammars expose only `OptionalChain` — the `?.` token
    // itself).
    //
    // The four assertions below all compare against the same totals:
    // for `function f(a) { return a?.b?.c; }` the operator stream is
    // `function`, `(`, `{`, `return`, `?.`, `?.`, `;` (7 total, 6
    // unique — `LPAREN`/`LBRACE` count once, closing tokens are not
    // in the operator set). Before the fix, TS/TSX reported 9/7
    // instead of 7/6.
    #[cfg(feature = "javascript")]
    #[test]
    fn javascript_optional_chain_not_double_counted_in_halstead_281() {
        check_metrics::<JavascriptParser>("function f(a) { return a?.b?.c; }", "foo.js", |m| {
            assert_eq!(m.halstead.unique_operators(), 6);
            assert_eq!(m.halstead.total_operators(), 7);
        });
    }

    #[cfg(feature = "mozjs")]
    #[test]
    fn mozjs_optional_chain_not_double_counted_in_halstead_281() {
        check_metrics::<MozjsParser>("function f(a) { return a?.b?.c; }", "foo.js", |m| {
            assert_eq!(m.halstead.unique_operators(), 6);
            assert_eq!(m.halstead.total_operators(), 7);
        });
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn typescript_optional_chain_not_double_counted_in_halstead_281() {
        // The TS grammar wraps member-expression `?.` in an
        // `optional_chain` named node containing the bare `?.`
        // token; classifying both as `Operator` double-counted the
        // chain. We now count only the bare token, so TS matches JS.
        check_metrics::<TypescriptParser>("function f(a) { return a?.b?.c; }", "foo.ts", |m| {
            assert_eq!(m.halstead.unique_operators(), 6);
            assert_eq!(m.halstead.total_operators(), 7);
        });
    }

    #[cfg(feature = "typescript")]
    #[test]
    fn tsx_optional_chain_not_double_counted_in_halstead_281() {
        check_metrics::<TsxParser>("function f(a) { return a?.b?.c; }", "foo.tsx", |m| {
            assert_eq!(m.halstead.unique_operators(), 6);
            assert_eq!(m.halstead.total_operators(), 7);
        });
    }

    // Issue #299: parity guard for the JS-family `get_op_type` macro
    // on the optional-chain operator token (#281's prior regression
    // surface). All four languages must classify the bare `?.` token
    // identically — `OptionalChain` in JS/MozJS, `QMARKDOT` in
    // TS/TSX — and emit the same totals for
    // `function f(a) { return a?.b?.c; }`:
    //
    // * Operators: `function`, `(`, `{`, `return`, `?.`, `?.`, `;`
    //   (7 total, 6 unique).
    // * Operands: `f`, `a` (parameter), `a`, `b`, `c` — the identifier
    //   and property leaves only (5 total, 4 unique). Until #1263 the
    //   two wrapping member expressions (`a?.b`, `a?.b?.c`) were
    //   classified as `MemberExpression*` operands on top of the leaves
    //   they contain, making this 7 total / 6 unique.
    //
    // Verified by test-via-revert: dropping `OptionalChain` from
    // JS/MozJS, or `QMARKDOT` from TS/TSX, trips the test
    // (u_operators 6→5). This input does NOT exercise every operand
    // alias in the per-language `operand_extras` (`Identifier2`, the
    // JS/MozJS/TSX string-literal `String2`); drift in
    // those is out of scope for this regression guard and would need a
    // separate fixture. The `PredefinedType` operator path (`: void`
    // double-count) is now covered by `ts_void_return_type_single_operator_453`
    // below.
    #[cfg(all(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    #[test]
    fn js_family_get_op_type_parity_optional_chain_member_299() {
        // Non-capturing closure (coerced to the `fn` pointer that
        // `check_metrics` accepts) avoids the
        // `clippy::needless_pass_by_value` warning that a free `fn`
        // taking `CodeMetrics` by value would trigger.
        #[cfg(any(feature = "javascript", feature = "mozjs", feature = "typescript"))]
        const SRC: &str = "function f(a) { return a?.b?.c; }";
        let check = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operators(), 6);
            assert_eq!(m.halstead.total_operators(), 7);
            assert_eq!(m.halstead.unique_operands(), 4);
            assert_eq!(m.halstead.total_operands(), 5);
        };

        check_metrics::<JavascriptParser>(SRC, "foo.js", check);
        check_metrics::<MozjsParser>(SRC, "foo.js", check);
        check_metrics::<TypescriptParser>(SRC, "foo.ts", check);
        check_metrics::<TsxParser>(SRC, "foo.tsx", check);
    }

    // Issue #1263: a member access contributes its leaves and the `.`
    // operator, never the `member_expression` composite as well. The
    // classification does not stop the walk, so `a` and `b` were always
    // counted; listing the wrapper billed a third operand keyed on the
    // whole `a.b` text, which no other language here does.
    //
    // expected, for `var r = a.b;`:
    //
    // * Operators: `var`, `=`, `.`, `;` — 4 total, 4 unique.
    // * Operands: `r`, `a`, `b` — 3 total, 3 unique. Before the fix
    //   the `member_expression` wrapper added `a.b`, making both 4.
    //
    // All four JS-family languages are asserted because
    // `impl_js_family_get_op_type!` emits one shared operand arm: the
    // lockstep is the point of the macro, and a per-language extras
    // list is exactly where a future edit could break it.
    #[cfg(all(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    #[test]
    fn js_family_member_access_counts_leaves_not_the_composite_1263() {
        #[cfg(any(feature = "javascript", feature = "mozjs", feature = "typescript"))]
        const SRC: &str = "var r = a.b;";
        let check = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operators(), 4);
            assert_eq!(m.halstead.total_operators(), 4);
            assert_eq!(m.halstead.unique_operands(), 3);
            assert_eq!(m.halstead.total_operands(), 3);
        };

        check_metrics::<JavascriptParser>(SRC, "foo.js", check);
        check_metrics::<MozjsParser>(SRC, "foo.js", check);
        check_metrics::<TypescriptParser>(SRC, "foo.ts", check);
        check_metrics::<TsxParser>(SRC, "foo.tsx", check);
    }

    // Issue #1263, the grammar-dispatch section 6 half: dropping
    // `MemberExpression*` from the operand arm would have regressed
    // private-field access to *zero* operands for the field, because
    // `PrivatePropertyIdentifier` — the `#x` leaf — was in no operand
    // list and the composite `this.#x` had been its only count. Adding
    // the leaf also fixes the declaration site `#x = 1`, which no
    // wrapper covered and which therefore counted nothing at all.
    //
    // expected, for `class C { #x = 1; m() { return this.#x; } }`:
    //
    // * Operators: `{`×2 (class body, method body), `=`, `;`×2, `(`,
    //   `return`, `.` — 8 total, 6 unique. (`class` is not in the
    //   JS-family operator arm, so it contributes nothing; that is
    //   pre-existing and unrelated.)
    // * Operands: `C`, `#x`, `1`, `m`, `this`, `#x` — 6 total, 5
    //   unique under JS/MozJS. Under TS/TSX the class *name* `C`
    //   parses as `type_identifier`, which those getters do not
    //   classify, so both counts drop by one to 5/4 — a pre-existing
    //   divergence this fixture records rather than fixes.
    #[cfg(all(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    #[test]
    fn js_family_private_field_leaf_is_the_operand_1263() {
        #[cfg(any(feature = "javascript", feature = "mozjs", feature = "typescript"))]
        const SRC: &str = "class C { #x = 1; m() { return this.#x; } }";
        let check_js = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operators(), 6);
            assert_eq!(m.halstead.total_operators(), 8);
            assert_eq!(m.halstead.unique_operands(), 5);
            assert_eq!(m.halstead.total_operands(), 6);
        };
        let check_ts = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operators(), 6);
            assert_eq!(m.halstead.total_operators(), 8);
            assert_eq!(m.halstead.unique_operands(), 4);
            assert_eq!(m.halstead.total_operands(), 5);
        };

        check_metrics::<JavascriptParser>(SRC, "foo.js", check_js);
        check_metrics::<MozjsParser>(SRC, "foo.js", check_js);
        check_metrics::<TypescriptParser>(SRC, "foo.ts", check_ts);
        check_metrics::<TsxParser>(SRC, "foo.tsx", check_ts);
    }

    // Issue #1263, the other section 6 half: `meta_property` is the one
    // composite the leaves-not-composites drop has to keep. `import.meta`
    // / `new.target` have no classified leaf — `meta` and `target` are
    // anonymous tokens in no arm — so with `MemberExpression*` gone the
    // meta-object contributed no operand at all while `this.env.x` still
    // yielded three.
    //
    // expected operands, for `var t = import.meta.url; function f() {
    // return new.target; }`: `t`, `import.meta`, `url`, `f`,
    // `new.target` — 5 total, 5 unique. Operators are deliberately not
    // asserted: the `import` / `new` keyword tokens inside the
    // meta-property keep their pre-existing operator classification,
    // which this fixture neither pins nor contests.
    #[cfg(all(feature = "javascript", feature = "mozjs", feature = "typescript"))]
    #[test]
    fn js_family_meta_property_is_one_operand_1263() {
        #[cfg(any(feature = "javascript", feature = "mozjs", feature = "typescript"))]
        const SRC: &str = "var t = import.meta.url; function f() { return new.target; }";
        let check = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operands(), 5);
            assert_eq!(m.halstead.total_operands(), 5);
        };

        check_metrics::<JavascriptParser>(SRC, "foo.js", check);
        check_metrics::<MozjsParser>(SRC, "foo.js", check);
        check_metrics::<TypescriptParser>(SRC, "foo.ts", check);
        check_metrics::<TsxParser>(SRC, "foo.tsx", check);
    }

    // Issue #1263: TS/TSX `nested_identifier` (`namespace N.M`) is the
    // same container/leaf double-count as `member_expression`.
    //
    // expected, for `namespace N.M { }`:
    //
    // * Operators: `.`, `{` — 2 total, 2 unique. (`namespace` is not in
    //   the JS-family operator arm.)
    // * Operands: `N`, `M` — 2 total, 2 unique. Before the fix the
    //   `nested_identifier` added `N.M`, making both 3.
    #[cfg(feature = "typescript")]
    #[test]
    fn ts_nested_identifier_counts_leaves_not_the_composite_1263() {
        const SRC: &str = "namespace N.M { }";
        let check = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operators(), 2);
            assert_eq!(m.halstead.total_operators(), 2);
            assert_eq!(m.halstead.unique_operands(), 2);
            assert_eq!(m.halstead.total_operands(), 2);
        };

        check_metrics::<TypescriptParser>(SRC, "foo.ts", check);
        check_metrics::<TsxParser>(SRC, "foo.tsx", check);
    }

    // Issue #1261 (inverting the #313 pin): the `"string"` type-keyword
    // aliases the TS / TSX grammars expose must contribute NO operand.
    // #313 put them in `operand_extras` for parity with the then-wider
    // `Checker::is_string`, but the `predefined_type` wrapper already
    // counts as the text-keyed `"string"` operator, so one `: string`
    // token tallied as operator AND operand while `: number` counted
    // once. #1261 drops the aliases from both `operand_extras` and
    // `is_string`, so the keyword counts once, as the operator.
    //
    // For the input `let x: string = "y";`:
    //
    // * TypeScript emits `Typescript::String2` for the `string` type
    //   keyword (kind_id 135, in the type-keyword block of the enum).
    // * TSX emits `Tsx::String3` for the same role (kind_id 141).
    //
    // Verified by test-via-revert: restoring `String2` to TS's
    // `operand_extras` (or `String3` to TSX's) trips this test on
    // `u_operands` / `operands` for the affected language.
    #[cfg(feature = "typescript")]
    #[test]
    fn ts_family_type_keyword_counts_once_1261() {
        const SRC: &str = "let x: string = \"y\";";
        // Operators (n1 = 5, N1 = 5):
        //   `let`, `:`, `=`, `;`, plus `string` (PredefinedType wrapper,
        //   routed through `is_primitive` so it's keyed by its lexeme
        //   `"string"` in `primitive_operators`).
        // Operands (n2 = 2, N2 = 2):
        //   `x` and the `"y"` literal. Under #313 the type-keyword
        //   child of `predefined_type` added a third, phantom
        //   `"string"` operand (n2 = 3 / N2 = 3).
        let check = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operators(), 5);
            assert_eq!(m.halstead.total_operators(), 5);
            assert_eq!(m.halstead.unique_operands(), 2);
            assert_eq!(m.halstead.total_operands(), 2);
        };

        check_metrics::<TypescriptParser>(SRC, "foo.ts", check);
        check_metrics::<TsxParser>(SRC, "foo.tsx", check);
    }

    // Issue #1261 regression, the issue's reproducer plus a literal
    // whose contents spell the keyword: `: string` and `: number` must
    // contribute symmetrically — one text-keyed operator each, zero
    // operands — while a string *literal* `"string"` stays an operand
    // (distinct from the keyword: TS kind `String`, TSX kind `String2`,
    // both quoted in the operand key).
    #[cfg(feature = "typescript")]
    #[test]
    fn ts_family_string_annotation_symmetric_with_number_1261() {
        const SRC: &str = "let x: string = \"a\";\nlet y: number = 1;\nlet s = \"string\";";
        // Operators (n1 = 6, N1 = 13):
        //   `let` ×3, `:` ×2, `=` ×3, `;` ×3, `string` ×1, `number` ×1.
        //   Pre-fix N1 was identical — the wrapper operator was always
        //   counted; the defect was the extra operand below.
        // Operands (n2 = 6, N2 = 6):
        //   `x`, `"a"`, `y`, `1`, `s`, `"string"` — one each. Pre-fix
        //   the `: string` keyword added a bare `string` operand
        //   (n2 = 7 / N2 = 7) that `: number` had no analogue of.
        let check = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operators(), 6);
            assert_eq!(m.halstead.total_operators(), 13);
            assert_eq!(m.halstead.unique_operands(), 6);
            assert_eq!(m.halstead.total_operands(), 6);
        };

        check_metrics::<TypescriptParser>(SRC, "foo.ts", check);
        check_metrics::<TsxParser>(SRC, "foo.tsx", check);
    }

    /// Drift marker for #1261 (lesson 34 / grammar-dispatch §2): the
    /// anonymous `string` type-keyword token appears **only** as a
    /// `predefined_type` child.
    ///
    /// That is the whole argument for classifying the keyword without a
    /// parent guard — the wrapper is guaranteed to be there to carry the
    /// operator. The two tests above measure the consequence and would
    /// still pass if the grammar started emitting the keyword somewhere
    /// else, as long as their own two fixtures kept their counts; this one
    /// measures the premise, over every position #1261's dump probes
    /// covered: annotation, parameter and return type, union member,
    /// generic argument, and template-literal type. A string *literal*
    /// spelling `"string"` is a different kind and must not be confused
    /// for the keyword, so one is in the fixture too.
    #[cfg(feature = "typescript")]
    #[test]
    fn ts_family_type_keyword_only_appears_under_predefined_type_1261() {
        // Exercises each position the keyword can take. Valid in both
        // grammars: no angle-bracket cast, which TSX would read as JSX.
        const SRC: &str = "const a: string = \"string\";\n\
                           function f(x: string): string {\n\
                               return x;\n\
                           }\n\
                           type U = string | number;\n\
                           type A = Array<string>;\n\
                           type M = Map<string, number>;\n\
                           type T = `id-${string}`;\n";
        // Seven type positions: `a`, `x`, `f`'s return, the union member,
        // `Array`'s argument, `Map`'s first argument, and the template
        // placeholder. The `"string"` initialiser is a literal, not the
        // keyword, and must not be among them.
        const EXPECTED_OCCURRENCES: usize = 7;

        fn keyword_occurrences<P: ParserTrait>(
            path: &str,
            keyword: u16,
            predefined_type: u16,
        ) -> usize {
            let parser = P::new(SRC.as_bytes().to_vec(), &PathBuf::from(path), None);
            parser
                .root()
                .preorder()
                .filter(|node| node.kind_id() == keyword)
                .inspect(|node| {
                    assert_eq!(
                        node.parent().map(|parent| parent.kind_id()),
                        Some(predefined_type),
                        "the `string` type keyword surfaced outside \
                         `predefined_type` in {path}; the operator is carried \
                         by the wrapper, so `get_op_type` needs a parent guard \
                         before that arm can be trusted (#1261)",
                    );
                })
                .count()
        }

        // Kind ids re-read from the generated enums, not carried over: TS
        // `String2` = 135, TSX `String3` = 141 (TSX's `String2` = 261 is the
        // string-literal production and stays an operand).
        assert_eq!(
            keyword_occurrences::<TypescriptParser>(
                "foo.ts",
                Typescript::String2 as u16,
                Typescript::PredefinedType as u16,
            ),
            EXPECTED_OCCURRENCES,
            "TypeScript no longer emits the `string` type keyword in every \
             position #1261 probed",
        );
        assert_eq!(
            keyword_occurrences::<TsxParser>(
                "foo.tsx",
                Tsx::String3 as u16,
                Tsx::PredefinedType as u16,
            ),
            EXPECTED_OCCURRENCES,
            "TSX no longer emits the `string` type keyword in every position \
             #1261 probed",
        );
    }

    // Issue #453: a `void` return type must contribute exactly one
    // Halstead operator. The TS / TSX grammars parse `: void` as a
    // `predefined_type` wrapper around an inner `void` token. `is_primitive`
    // routes the wrapper into the text-keyed `primitive_operators` map as
    // `"void"`, while the inner `Void` token is independently a standalone
    // expression operator (`void 0`). Pre-fix both classified as operators
    // and one source `void` counted as TWO distinct Halstead operators.
    // The fix suppresses the wrapper when its child is a `Void` token, so
    // only the inner token carries the operator — matching expression
    // `void 0` and keeping the kind_id-keyed count consistent.
    //
    // For `function f(): void { return; }`:
    //
    // * Operators (n1 = 7, N1 = 7): `function`, `()`, `{}`, `:`, `return`,
    //   `;`, and a single `void`. (The untyped form is n1 = 5; the `: void`
    //   annotation adds the `:` operator and one `void`, NOT two — the
    //   issue's "n1 = 6" target overlooked the annotation colon.)
    //
    // Verified by test-via-revert: removing the `predefined_void` guard
    // restores the pre-fix `u_operators` 7 -> 8 with a duplicate `"void"`
    // (one kind_id-keyed, one in `primitive_operators`). Both `metrics()`
    // and the `ops`-list dedup invariant (`ts_void_return_and_expression_*`
    // in `ops.rs`) are pinned per lesson 4.
    #[cfg(feature = "typescript")]
    #[test]
    fn ts_void_return_type_single_operator_453() {
        const SRC: &str = "function f(): void { return; }";
        let check = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operators(), 7);
            assert_eq!(m.halstead.total_operators(), 7);
        };

        check_metrics::<TypescriptParser>(SRC, "foo.ts", check);
        check_metrics::<TsxParser>(SRC, "foo.tsx", check);
    }

    // Issue #453 over-suppression guard: expression `void 0` (a
    // `unary_expression`, NOT a `predefined_type` wrapper) must still
    // count `void` as exactly one operator. The fix keys only on a
    // `predefined_type` whose child is a `Void` token, so the bare
    // expression operator is untouched.
    //
    // For `const x = void 0;`:
    //
    // * Operators (n1 = 4, N1 = 4): `const`, `=`, `void`, `;`.
    // * Operands (n2 = 2, N2 = 2): `x`, `0`.
    #[cfg(feature = "typescript")]
    #[test]
    fn ts_void_expression_still_single_operator_453() {
        const SRC: &str = "const x = void 0;";
        let check = |m: crate::CodeMetrics| {
            assert_eq!(m.halstead.unique_operators(), 4);
            assert_eq!(m.halstead.total_operators(), 4);
            assert_eq!(m.halstead.unique_operands(), 2);
            assert_eq!(m.halstead.total_operands(), 2);
        };

        check_metrics::<TypescriptParser>(SRC, "foo.ts", check);
        check_metrics::<TsxParser>(SRC, "foo.tsx", check);
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_wrong_operators() {
        check_metrics::<PythonParser>("()[]{}", "foo.py", |metric| {
            insta::assert_json_snapshot!(
                metric.halstead,
                @r#"
            {
              "unique_operators": 0,
              "total_operators": 0,
              "unique_operands": 0,
              "total_operands": 0,
              "length": 0,
              "estimated_program_length": 0.0,
              "purity_ratio": 0.0,
              "vocabulary": 0,
              "volume": 0.0,
              "difficulty": 0.0,
              "level": 0.0,
              "effort": 0.0,
              "time": 0.0,
              "bugs": 0.0
            }
            "#
            );
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_check_metrics() {
        check_metrics::<PythonParser>(
            "def f():
                 pass",
            "foo.py",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 2,
                  "total_operators": 2,
                  "unique_operands": 1,
                  "total_operands": 1,
                  "length": 3,
                  "estimated_program_length": 2.0,
                  "purity_ratio": 0.6666666666666666,
                  "vocabulary": 3,
                  "volume": 4.754887502163468,
                  "difficulty": 1.0,
                  "level": 1.0,
                  "effort": 4.754887502163468,
                  "time": 0.26416041678685936,
                  "bugs": 0.0009425525573729414
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_operators_and_operands() {
        check_metrics::<JavaParser>(
            "public class Main {
            public static void main(string args[]) {
                  int a, b, c, avg;
                  a = 5; b = 5; c = 5;
                  avg = (a + b + c) / 3;
                  MessageFormat.format(\"{0}\", avg);
                }
            }",
            "foo.java",
            |metric| {
                // Operators (n1=11): {} void () [] , . ; int = + /
                // Operands (n2=12): Main main args a b c avg 5 3 MessageFormat format "{0}"
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 11,
                  "total_operators": 26,
                  "unique_operands": 12,
                  "total_operands": 22,
                  "length": 48,
                  "estimated_program_length": 81.07329781366414,
                  "purity_ratio": 1.6890270377846697,
                  "vocabulary": 23,
                  "volume": 217.13097389073664,
                  "difficulty": 10.083333333333334,
                  "level": 0.09917355371900825,
                  "effort": 2189.4039867315946,
                  "time": 121.63355481842193,
                  "bugs": 0.05620341201461669
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "java")]
    #[test]
    fn java_primitive_types_and_booleans() {
        check_metrics::<JavaParser>(
            "public class Prims {
                byte a = 1;
                short b = 2;
                int c = 3;
                long d = 4;
                char e = 'x';
                float f = 1.0f;
                double g = 2.0;
                boolean h = true;
                boolean i = false;
            }",
            "foo.java",
            |metric| {
                // Verifies all 8 Java primitive-type keywords (byte, short, int, long,
                // char, float, double, boolean) are counted as distinct operators, and
                // that true/false are counted as operands.
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 11,
                  "total_operators": 28,
                  "unique_operands": 19,
                  "total_operands": 19,
                  "length": 47,
                  "estimated_program_length": 118.76437056043838,
                  "purity_ratio": 2.526901501285923,
                  "vocabulary": 30,
                  "volume": 230.62385799360038,
                  "difficulty": 5.5,
                  "level": 0.18181818181818182,
                  "effort": 1268.4312189648022,
                  "time": 70.46840105360012,
                  "bugs": 0.03905920146699976
                }
                "#
                );
            },
        );
    }

    // #1380: `this` and `super` were swept into the operator arm under a
    // `// Operator: … keywords` heading — classification by lexical
    // class rather than by Halstead role. A member access is
    // `<receiver> <op> <field>`, so billing the receiver as an operator
    // scored `this.x` as a binary operator with one operand while `p.x`
    // is one operator and two operands. Both are operands now, matching
    // the eleven other languages that classify a self-reference.
    #[cfg(feature = "java")]
    #[test]
    fn java_self_and_super_references_are_operands() {
        let source = "class T {\n    int f() { return this.x + super.y; }\n}";
        // Operators (n1=7, N1=9): {} x2, int, (), return, . x2, +, ;
        // Operands (n2=6, N2=6): T, f, this, x, super, y
        // Before the fix this read (9, 11, 4, 4) — `this` and `super`
        // billed into the operator side of both counts.
        assert_halstead_counts::<JavaParser>(
            source,
            "foo.java",
            [7, 9, 6, 6],
            "java self/super references",
        );
        assert_keywords_are_operands_only::<JavaParser>(source, "foo.java", &["this", "super"]);
    }

    // The `super` of a wildcard type bound denotes no value, so it keeps
    // the operator classification `? extends T`'s `extends` already has
    // — the two keywords are siblings under the same `wildcard` node and
    // nothing but the parent separates them from a real self-reference
    // (#1380). The explicit receiver parameter in the same fixture is
    // the independent path through the operand arm (grammar-dispatch
    // section 11): only it can put `this` in the operand vocabulary
    // here, and only the wildcard can put `super` in the operator one.
    #[cfg(feature = "java")]
    #[test]
    fn java_wildcard_super_bound_stays_an_operator() {
        let source = "import java.util.List;\n\
                      class T {\n    \
                      void m(T T.this, List<? super String> a, List<? extends String> b) { }\n\
                      }";
        let ops = ops_of::<JavaParser>(source, "foo.java");

        assert!(
            ops.operators.iter().any(|o| o == "super"),
            "`? super String` must keep `super` an operator; operators were {:?}",
            ops.operators
        );
        assert!(
            !ops.operands.iter().any(|o| o == "super"),
            "a wildcard bound must not bill `super` as an operand; operands were {:?}",
            ops.operands
        );
        assert!(
            ops.operators.iter().any(|o| o == "extends"),
            "the fixture must still contain the `? extends String` \
             bound this arm mirrors; operators were {:?}",
            ops.operators
        );
        assert_keywords_are_operands_only::<JavaParser>(source, "foo.java", &["this"]);
    }

    /// One `this` and one `super` per container the pinned
    /// `tree-sitter-java` can put them in: a delegating constructor
    /// call, an explicit superclass constructor call, a field access, a
    /// method-invocation receiver, a method reference, a call argument,
    /// and the two qualified forms an inner class allows.
    #[cfg(feature = "java")]
    const JAVA_SELF_POSITIONS: &str = "class Pos extends P {
        int x;
        Pos() { this(1); }
        Pos(int v) { super(v); this.x = v; }
        int a() { return this.x; }
        int b() { return super.h(); }
        java.util.function.IntSupplier c() { return this::a; }
        void d() { g(this); }
        void g(Object o) { }
        class In {
            int e() { return Pos.this.x; }
            int f() { return Pos.super.h(); }
        }
    }";

    #[cfg(feature = "java")]
    #[test]
    fn java_self_and_super_leaves_are_unaliased_and_unconditional() {
        assert_self_reference_leaves::<JavaCode>(
            JAVA_SELF_POSITIONS,
            &[
                ("this", Java::This as u16, 6),
                ("super", Java::Super as u16, 3),
            ],
            "java",
        );
    }

    // Groovy's `Super` arm, pinned from all three sides. The pinned
    // grammar emits the `super` token only as a `wildcard` bound, where it
    // is an operator exactly as in Java above; every super-*reference* is
    // a plain `identifier`, and so an operand.
    //
    // Since #1419 the arm carries Java's `Wildcard` parent gate, so the
    // bound half below exercises the gate's operator branch — inverting
    // the gate fails it. The gate's operand branch is unreachable under
    // the pin (only error recovery on invalid Groovy, `List<? super>`,
    // detaches a `super` token from its `wildcard`), so it is
    // deliberately untested rather than pinned against an invalid
    // fixture. The node census is the drift marker for it: a grammar bump
    // that routes a reference to `Groovy::Super` fails here by name.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_wildcard_super_bound_stays_an_operator() {
        let bounds =
            "class T {\n    void m(List<? super String> a, List<? extends String> b) { }\n}";
        let ops = ops_of::<GroovyParser>(bounds, "foo.groovy");
        assert!(
            ops.operators.iter().any(|o| o == "super"),
            "`? super String` must keep `super` an operator; operators were {:?}",
            ops.operators
        );
        assert!(
            !ops.operands.iter().any(|o| o == "super"),
            "a wildcard bound must not bill `super` as an operand; operands were {:?}",
            ops.operands
        );
        assert!(
            ops.operators.iter().any(|o| o == "extends"),
            "the fixture must still contain the `? extends String` bound this arm \
             mirrors; operators were {:?}",
            ops.operators
        );

        let mixed = "class T extends B {\n    void m(List<? super String> a) { super.h() }\n}";
        let mut tokens = 0;
        for_each_node_with_chain::<GroovyCode>(mixed.as_bytes(), |node, chain| {
            if node.kind_id() == Groovy::Super as u16 {
                tokens += 1;
                assert_eq!(
                    chain.last().map(Node::kind_id),
                    Some(Groovy::Wildcard as u16),
                    "groovy: a `super` token outside a wildcard bound now reaches \
                     the gate's operand branch, which the pinned grammar made \
                     unreachable — re-check the arm against the new grammar (#1419)"
                );
            }
        });
        assert_eq!(
            tokens, 1,
            "the fixture's one wildcard bound must still spell `super`, and its \
             `super.h()` reference must not"
        );

        // The reference direction, on valid input the gate must leave
        // alone: every super-reference form the grammar accepts stays an
        // operand, so splitting `Super` out of the operator alternation
        // cannot have moved one. `this` rides along for the same reason
        // Java's test carries it.
        let refs = "class A extends B {\n    A() { super(1) }\n    \
                    def g() { return super.h() }\n    \
                    def i() { return A.super.h() }\n    \
                    def j() { return super::h }\n    \
                    def k() { return super?.h() }\n    \
                    def l() { return this.x }\n}";
        assert_keywords_are_operands_only::<GroovyParser>(refs, "foo.groovy", &["super", "this"]);
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_operators_and_operands() {
        check_metrics::<GroovyParser>(
            "class Main {
                static void main(String[] args) {
                    int a, b, c, avg;
                    a = 5; b = 5; c = 5;
                    avg = (a + b + c) / 3;
                    println(avg);
                }
            }",
            "foo.groovy",
            |metric| {
                // Groovy mirror of `java_operators_and_operands`. The juxt
                // call `println avg` exercises `juxt_function_call` in
                // place of Java's `MessageFormat.format(...)`. amaanq's
                // grammar inherits Java's tokenisation, so n1/N1/n2/N2
                // shapes match Java up to those substitutions.
                // The dekobon grammar parses primitive type names
                // (`void`, `int`, `String`) as `type_identifier`
                // rather than as distinct keyword tokens, so they
                // count as operands here — the prior amaanq grammar
                // treated them as operators. Net shift: −2 unique
                // operators (`void`, `int`), +2 unique operands
                // (`void`, `int` were the only two type_identifiers
                // not already counted as operands, since `String`
                // was already an identifier in the prior grammar's
                // counting).
                assert_eq!(metric.halstead.unique_operators(), 8);
                assert_eq!(metric.halstead.unique_operands(), 13);
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 8,
                  "total_operators": 22,
                  "unique_operands": 13,
                  "total_operands": 23,
                  "length": 45,
                  "estimated_program_length": 72.10571633583419,
                  "purity_ratio": 1.6023492519074265,
                  "vocabulary": 21,
                  "volume": 197.65428402504423,
                  "difficulty": 7.076923076923077,
                  "level": 0.14130434782608697,
                  "effort": 1398.7841638695438,
                  "time": 77.71023132608576,
                  "bugs": 0.04169134280255714
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_primitive_types_and_booleans() {
        check_metrics::<GroovyParser>(
            "class Prims {
                byte a = 1
                short b = 2
                int c = 3
                long d = 4
                char e = 'x'
                float f = 1.0f
                double g = 2.0
                boolean h = true
                boolean i = false
            }",
            "foo.groovy",
            |metric| {
                // The dekobon grammar consolidates the 8 primitive
                // type names (`byte`, `short`, `int`, `long`, `char`,
                // `float`, `double`, `boolean`) under `type_identifier`
                // — so they count as operands, not as distinct
                // operators. Likewise numeric literals collapse to one
                // `NumberLiteral` shape (no Hex/Octal/Binary/Decimal
                // split), and `'x'` parses as `StringLiteral` (Groovy
                // single-quoted strings) rather than as
                // `CharacterLiteral`. Operators remaining in this
                // fixture: `=` and `class`-body braces (only `{` is in
                // the operator set). True/false collapse under one
                // `BooleanLiteral`.
                assert_eq!(metric.halstead.unique_operators(), 2);
                assert_eq!(metric.halstead.unique_operands(), 27);
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 2,
                  "total_operators": 10,
                  "unique_operands": 27,
                  "total_operands": 28,
                  "length": 38,
                  "estimated_program_length": 130.38196255841365,
                  "purity_ratio": 3.4311042778529908,
                  "vocabulary": 29,
                  "volume": 184.60327781484773,
                  "difficulty": 1.037037037037037,
                  "level": 0.9642857142857143,
                  "effort": 191.44043625243467,
                  "time": 10.635579791801925,
                  "bugs": 0.01107221547116606
                }
                "#
                );
            },
        );
    }

    // Issue #1263 swept Groovy alongside the JS family and C#: its
    // operand arm listed `QualifiedName` (a `package` / `import` path)
    // and `QualifiedType` on top of the identifier leaves the walker
    // already reached.
    //
    // Only the `QualifiedName` half was observable. The runtime emits
    // `qualified_type` as the *alias* `QualifiedType2` (kind_id 228),
    // which the arm never named — a lesson-2 miss that, by accident,
    // made that half already leaves-only and is why #1263's issue body
    // recorded Groovy as compliant. Both kinds are gone rather than
    // completed.
    //
    // expected, for `package com.example`: operators `.` (1/1);
    // operands `com`, `example` (2/2). Pre-fix the `qualified_name`
    // added `com.example`, making the operand counts 3/3.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_qualified_name_counts_leaves_not_the_composite_1263() {
        check_metrics::<GroovyParser>("package com.example", "foo.groovy", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 1);
            assert_eq!(metric.halstead.total_operators(), 1);
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
    }

    // The type half of the same arm (#1352). #1263 dropped
    // `QualifiedType` alongside `QualifiedName`, but only the latter
    // was pinned: adding `QualifiedType2` back to the operand arm
    // failed none of the 3,523 tests then in the lib targets, so the
    // leaves-only reading of a qualified *type* was correct by accident
    // rather than by contract. The tempting "fix" for the alias miss
    // #1263 recorded is to complete the list with 228, which is exactly
    // the double count #1263 removed — this test is what stops that.
    //
    // The kind assertions are the grammar-dispatch section 1 / 2 drift
    // marker: if a grammar bump renumbers the alias, the operand
    // assertions below would keep passing while measuring a construct
    // this arm no longer describes.
    //
    // expected, for `java.util.List x = null`: operators `.` × 2 and
    // `=` → n1 = 2, N1 = 3; operands `java`, `util`, `List`, `x`,
    // `null` → n2 = 5, N2 = 5. Listing the wrapper would add the whole
    // span `java.util.List`, making the operand counts 6/6.
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_qualified_type_counts_leaves_not_the_composite_1352() {
        const SOURCE: &str = "java.util.List x = null";

        let parser = GroovyParser::new(
            SOURCE.as_bytes().to_vec(),
            &PathBuf::from("foo.groovy"),
            None,
        );
        assert!(
            ast_has_kind_id(&parser, Groovy::QualifiedType2 as u16),
            "the dekobon grammar no longer emits `qualified_type` as the \
             alias `QualifiedType2`; re-derive the Groovy operand arm \
             before trusting the counts below",
        );
        assert!(
            !ast_has_kind_id(&parser, Groovy::QualifiedType as u16),
            "the unsuffixed `QualifiedType` is now reachable; it is a \
             second wrapper this arm must keep excluded",
        );

        check_metrics::<GroovyParser>(SOURCE, "foo.groovy", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 2);
            assert_eq!(metric.halstead.total_operators(), 3);
            assert_eq!(metric.halstead.unique_operands(), 5);
            assert_eq!(metric.halstead.total_operands(), 5);
        });
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_closure_operators_and_operands() {
        check_metrics::<GroovyParser>("def double = { x -> x * 2 }", "foo.groovy", |metric| {
            // Closure with arrow-style parameter list.
            // Distinct operators: def, =, {}, ->, * = 5.
            // Distinct operands: double, x, 2 = 3.
            assert_eq!(metric.halstead.unique_operators(), 5);
            assert_eq!(metric.halstead.unique_operands(), 3);
        });
    }

    /// Regression for issue #247: every Groovy-specific operator the
    /// prior amaanq grammar dropped to ERROR or mis-shaped as a Java
    /// node now parses as a distinct lexer token in the dekobon
    /// grammar, so Halstead counts each one. The fixture below
    /// exercises Elvis `?:`, safe-nav `?.`, safe-chain `??.`,
    /// spread-dot `*.`, method-pointer `.&`, direct-field `.@`,
    /// identity `===` / `!==`, spaceship `<=>`, regex `=~` / `==~`,
    /// exclusive ranges `..<` / `<..` / `<..<`, `as` coercion, and
    /// `?[` safe index — every distinct operator kind must appear in
    /// `u_operators` (the count grows by exactly the number of new
    /// distinct operator tokens introduced).
    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_dekobon_operator_coverage_247() {
        check_metrics::<GroovyParser>(
            "def f(a, b, list, s) {
                def x = a ?: b
                def y = a?.field
                def z = a??.field
                def items = list*.size()
                def ptr = a.&size
                def fld = a.@field
                def id1 = a === b
                def id2 = a !== b
                def ship = a <=> b
                def find = s =~ /pat/
                def match = s ==~ /^pat\\$/
                def r1 = 0..<10
                def r2 = 0<..10
                def r3 = 0<..<10
                def cast = a as String
                def safe = list?[0]
                return x
            }",
            "foo.groovy",
            |metric| {
                // Exact pin: with the dekobon Groovy grammar this
                // fixture exercises 16 Groovy-specific tokens (`?:`,
                // `?.`, `??.`, `*.`, `.&`, `.@`, `===`, `!==`, `<=>`,
                // `=~`, `==~`, `..<`, `<..`, `<..<`, `as`, `?[`) plus
                // 6 ambient Java-shaped operators the fixture also
                // uses (`def`, `=`, `,`, `{}`, `()`, `return`), for a
                // total of 22 distinct operator kinds. A regression
                // that drops any one of the 16 #247 operators would
                // push the count below 22 and fail this assertion. The
                // complementary AST walk below pins each #247
                // operator's identity individually so a grammar change
                // that adds an unrelated operator (lifting
                // `u_operators` to 23) still flags the loss of a #247
                // operator at the per-token level.
                //
                // Was 23 until #1314. The extra entry was a `/` — the
                // fixture's two slashy literals (`/pat/`, `/^pat\$/`)
                // each spelled their closing delimiter with the
                // division kind, and the arm now guards them. The
                // enumeration above was wrong in two ways at that
                // count: it listed an ambient `[`, which this fixture
                // never emits (`list?[0]` is the single `?[` token),
                // and omitted the fabricated `/` that made up the
                // difference. Both are corrected here.
                assert_eq!(
                    metric.halstead.unique_operators(),
                    22,
                    "u_operators changed; check whether a #247 operator was dropped or an unrelated operator added (and update the comment / token list above accordingly)",
                );
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_gstring_no_double_count() {
        // Issue #454: before the fix Groovy had no interpolation guard
        // at all — `StringLiteral` was classified as a plain operand, so
        // a GString counted the wrapping literal AND descended into its
        // interpolated expression, double-counting the inner identifier
        // in N2. The fix routes `StringLiteral` through
        // `string_operand_type` with both GString interpolation child
        // kinds (`gstring_brace_interpolation` / `gstring_dollar_-
        // interpolation`), so the wrapper is Unknown and only the inner
        // expression contributes.
        //
        // `def greet(name) {\n  return "Hi ${name}"\n}\n`
        //   operands by token text: `greet` × 1, `name` × 2 (param +
        //   inside `${name}`). The wrapping `"Hi ${name}"` is suppressed
        //   → u_operands = 2 (`greet`, `name`), N2 = 3. Without the fix
        //   the wrapping literal would also count → u_operands = 3,
        //   N2 = 4.
        let src = "def greet(name) {\n  return \"Hi ${name}\"\n}\n";
        check_metrics::<GroovyParser>(src, "foo.groovy", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 3);
        });
        assert_ops_operands::<GroovyParser>(src, "foo.groovy", 2, vec!["greet", "name"]);
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_gstring_dollar_form_no_double_count() {
        // Issue #454: the short `$name` GString form emits a distinct
        // `gstring_dollar_interpolation` child whose inner `identifier`
        // text is `$name` (the grammar's identifier node spans the
        // leading `$`). The wrapper is suppressed; the inner `$name`
        // operand is distinct from the bare `name` param.
        //
        // `def greet(name) {\n  return "Hi $name"\n}\n`
        //   operands: `greet`, `name` (param), `$name` (interp) →
        //   u_operands = 3, N2 = 3. Without the fix the wrapping
        //   `"Hi $name"` would also count → u_operands = 4, N2 = 4.
        let src = "def greet(name) {\n  return \"Hi $name\"\n}\n";
        check_metrics::<GroovyParser>(src, "foo.groovy", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 3);
            assert_eq!(metric.halstead.total_operands(), 3);
        });
        assert_ops_operands::<GroovyParser>(src, "foo.groovy", 3, vec!["greet", "name", "$name"]);
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_plain_string_still_operand() {
        // Counterpart to `groovy_gstring_no_double_count`: a plain
        // non-interpolated literal has neither GString interpolation
        // child and must still contribute exactly one operand.
        //
        // `def f() {\n  return "plain"\n}\n`
        //   operands: `f`, `"plain"` → u_operands = 2, N2 = 2.
        let src = "def f() {\n  return \"plain\"\n}\n";
        check_metrics::<GroovyParser>(src, "foo.groovy", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
        assert_ops_operands::<GroovyParser>(src, "foo.groovy", 2, vec!["f", "\"plain\""]);
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_slashy_string_delimiter_is_not_an_operator() {
        // Regression: issue #1314, the Groovy sibling of Elixir #1256
        // and Ruby/Perl #1312. A slashy string is a `StringLiteral`
        // whose closing delimiter is a `SLASH` — the kind id real
        // division uses — so `def b = /xyz/` reported a `/` operator
        // with no division in the source. Only the closer is a child
        // (the grammar folds the opening `/` into the literal's span),
        // so this fabricated one `/` per literal rather than Ruby's two.
        //
        // expected: operators `def` × 3, `=` × 3 → n1 = 2, N1 = 6.
        // Operands `b`, `/xyz/` × 2, `c`, `s` → n2 = 4, N2 = 6. Before
        // the guard the two closers added `/` → n1 = 3, N1 = 8.
        check_metrics::<GroovyParser>(
            "def b = /xyz/\ndef c = /xyz/\ndef s = b\n",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 2);
                assert_eq!(metric.halstead.total_operators(), 6);
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 6);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_division_survives_the_slashy_guard() {
        // Control for #1314: the guard is scoped to a `StringLiteral`
        // parent, so real division must still count. Both sides are in
        // one fixture — two divisions and one slashy literal — so a
        // guard widened to every `SLASH` fails here rather than
        // silently passing the test above.
        //
        // expected: operators `def` × 2, `=` × 2, `/` × 2 → n1 = 3,
        // N1 = 6. Operands `q`, `a`, `b`, `c`, `r`, `/x/` → n2 = N2 = 6.
        check_metrics::<GroovyParser>("def q = a / b / c\ndef r = /x/\n", "foo.groovy", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 3);
            assert_eq!(metric.halstead.total_operators(), 6);
            assert_eq!(metric.halstead.unique_operands(), 6);
            assert_eq!(metric.halstead.total_operands(), 6);
        });
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_slashy_guard_is_parent_scoped_not_ancestor_scoped() {
        // The input that separates the parent-scoped guard from the
        // ancestor-scanning mutant of it — the mutant #1256's
        // post-mortem says survives every ordinary fixture. Groovy is
        // one of only two languages in #1314 where such an input
        // exists at all: a slashy string may carry a GString
        // interpolation, so `/x${a / b}y/` puts a real division under a
        // `StringLiteral` *ancestor* while its parent is the
        // `binary_expression`. An ancestor scan swallows it; the parent
        // check leaves it alone. (The JS, C++ and Tcl/iRules guards
        // have no such input — see
        // `js_regex_delimiter_guard_is_parent_scoped_is_unobservable`.)
        //
        // expected: operators `def` × 2, `=` × 2, `/` (the
        // interpolated division) → n1 = 3, N1 = 5. The wrapping literal
        // is not an operand — it carries an interpolation, so
        // `string_operand_type` yields `Unknown` and the inner
        // expression's operands carry the count (#454) — leaving `r`,
        // `a`, `b`, `s` → n2 = 4, with `a` twice → N2 = 5. Under the
        // ancestor-scoped mutant the division vanishes: n1 = 2, N1 = 4.
        check_metrics::<GroovyParser>(
            "def r = /x${a / b}y/\ndef s = a\n",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 3);
                assert_eq!(metric.halstead.total_operators(), 5);
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 5);
            },
        );
    }

    #[cfg(feature = "groovy")]
    #[test]
    fn groovy_every_string_spelling_scores_alike() {
        // Companion to the three above (#1314). Groovy has five ways to
        // write an inert one-character string, and the choice is
        // spelling rather than semantics, so all five must score
        // identically. Before the guard the two slashy forms reported
        // an extra `/` operator that the other three did not — the
        // author's delimiter choice moved n1/N1.
        //
        // The dollar-slashy and quoted forms are no-change controls:
        // `$/…/$` closes with `/$` (kind 144) and `"…"` with `"` (134),
        // neither of which the operator arm classifies. `'x'` is a
        // childless leaf. The escaped-slash row is the one that would
        // regress if the guard were ever narrowed to a literal whose
        // *only* child is the closer.
        //
        // expected per spelling: operators `def` × 3, `=` × 3 → n1 = 2,
        // N1 = 6; operands `a`, the literal, `b`, `c` → n2 = 4, with
        // `a` used three times → N2 = 6.
        for literal in ["/x/", "$/x/$", "'x'", "\"x\"", r"/esc\/aped/"] {
            assert_halstead_counts::<GroovyParser>(
                &format!("def a = {literal}\ndef b = a\ndef c = a\n"),
                "foo.groovy",
                [2, 6, 4, 6],
                &format!("literal {literal}"),
            );
        }
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_operators_and_operands() {
        // After issue #286, `void`, `string`, and `int` count as three
        // distinct Halstead operators rather than collapsing into one
        // `PredefinedType` kind_id entry, lifting u_operators from 13
        // to 15. Total operators (N1) is unchanged because the same
        // nodes are still counted, just keyed by lexeme.
        check_metrics::<CsharpParser>(
            "public class Main {
                public static void Run(string[] args) {
                    int a, b, c, avg;
                    a = 5; b = 5; c = 5;
                    avg = (a + b + c) / 3;
                    System.Console.WriteLine(\"{0}\", avg);
                }
            }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 15);
                assert_eq!(metric.halstead.total_operators(), 32);
                assert_eq!(metric.halstead.unique_operands(), 13);
                assert_eq!(metric.halstead.total_operands(), 23);
                // Pin every Halstead field; values are whatever the
                // classifier produces and become the regression spec.
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    // Issue #1263: C#'s three name *containers* — `qualified_name`
    // (`System.Text`), `generic_name` (`List<int>`) and
    // `alias_qualified_name` (`global::Foo`) — were operands alongside
    // every leaf the walker already reached, so one occurrence of each
    // billed twice. `member_access_expression` never was, which is why
    // `csharp_operators_and_operands`' `System.Console.WriteLine` is
    // unaffected by this change: the bug lived in the *name* grammar,
    // not in member access.
    //
    // Three fixtures rather than one, so a regression names which
    // container came back. Each is hand-tallied; the removed composite
    // is called out per case.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_name_containers_count_leaves_not_the_composite_1263() {
        // expected: operators `using`, `.`, `;` (3/3); operands
        // `System`, `Text` (2/2). Pre-fix the `qualified_name` added
        // `System.Text`, making the operand counts 3/3.
        check_metrics::<CsharpParser>("using System.Text;", "foo.cs", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 3);
            assert_eq!(metric.halstead.total_operators(), 3);
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });

        // expected: operators `class`, `{`×2, `void`, `(`, `;`, `<`,
        // `>`, `int` — 9 total, 8 unique (`int` is the text-keyed
        // primitive operator, per #286). Operands `C`, `M`, `List`, `l`
        // — 4/4. Pre-fix the `generic_name` added `List<int>`, making
        // them 5/5.
        check_metrics::<CsharpParser>(
            "class C { void M() { List<int> l; } }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 8);
                assert_eq!(metric.halstead.total_operators(), 9);
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );

        // expected: operators `class`, `{`×2, `void`, `(`, `;`, `=`,
        // `::`, `.` — 9 total, 8 unique. `var` has no operator arm.
        // Operands `C`, `M`, `x`, `global`, `Foo`, `Bar` — 6/6. Pre-fix
        // the `alias_qualified_name` added `global::Foo`, making them
        // 7/7. The `::` staying an operator is what makes the leaf-only
        // tally lossless here, so it is asserted by the operator count
        // rather than assumed.
        check_metrics::<CsharpParser>(
            "class C { void M() { var x = global::Foo.Bar; } }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 8);
                assert_eq!(metric.halstead.total_operators(), 9);
                assert_eq!(metric.halstead.unique_operands(), 6);
                assert_eq!(metric.halstead.total_operands(), 6);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_primitive_types_and_booleans() {
        // After issue #286: each of `byte`, `short`, `int`, `long`,
        // `char`, `float`, `double`, `bool`, `object` is now a distinct
        // Halstead operator (9 primitives) rather than collapsing into
        // one `PredefinedType` kind_id entry. u_operators rises from 6
        // to 14 (5 non-primitive operators + 9 distinct primitives);
        // total operators (N1) is unchanged because the same nodes are
        // still counted, just keyed by lexeme.
        //
        // N2 dropped 23 → 21 with issue #1253: `true` and `false` each
        // reached the walker twice — once as `boolean_literal`, once as
        // the keyword leaf under it — so each added one spurious
        // occurrence. n2 is unchanged at 21 because operands are keyed
        // by source text, so the duplicate collapsed into the existing
        // vocabulary entry; that is exactly why the inflation was
        // invisible in n2. Every operand here is distinct, so
        // N2 == n2 == 21 after the fix.
        check_metrics::<CsharpParser>(
            "public class Prims {
                byte a = 1;
                short b = 2;
                int c = 3;
                long d = 4;
                char e = 'x';
                float f = 1.0f;
                double g = 2.0;
                bool h = true;
                bool i = false;
                object j = null;
            }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 14);
                assert_eq!(metric.halstead.total_operators(), 33);
                assert_eq!(metric.halstead.unique_operands(), 21);
                assert_eq!(metric.halstead.total_operands(), 21);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_boolean_literal_counts_once() {
        // Regression: issue #1253. `boolean_literal: choice('true',
        // 'false')` wraps the keyword leaf, and both kinds sat in the
        // operand arm, so every `true` / `false` occurrence added +1 to
        // N2. Operands are keyed by source text, so the duplicate
        // collapsed into the same vocabulary entry and n2 stayed
        // correct — which is why nothing caught it.
        //
        // Source repeats `true` so N2 exceeds n2 and the assertions can
        // tell "counted once per occurrence" from "deduplicated into
        // the vocabulary".
        //
        // Operands by text key: `A`, `M`, `a`, `b`, `c`, `d`, `true` × 2,
        // `false`, `null` ⇒ n2 = 9, N2 = 10. Before the fix the keyword
        // leaves added one occurrence per boolean ⇒ N2 = 13.
        check_metrics::<CsharpParser>(
            "class A {\n    void M() {\n        bool a = true;\n        bool b = false;\n        bool c = true;\n        object d = null;\n    }\n}\n",
            "foo.cs",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 9);
                assert_eq!(metric.halstead.total_operands(), 10);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_boolean_keyword_outside_a_literal_still_counts() {
        // Companion to the test above (#1253): the suppression fires on
        // the *parent* kind, never on `True` / `False` alone. C#'s
        // overloadable-operator list emits a bare `true` / `false` token
        // with no `boolean_literal` wrapper — `operator_declaration` is
        // the grammar's only such position — so a blanket exclusion
        // would drop the operand that is the sole difference between
        // `operator true` and `operator false`, leaving two such
        // declarations with identical Halstead vocabularies whenever
        // their bodies match.
        //
        // Each declaration names one boolean and returns the other, so
        // the fixture exercises both the guarded and the unguarded
        // position for each keyword.
        //
        // Operands: `A` × 3 (class name, two parameter types), `a` × 2,
        // `true` × 2 (operator name + literal), `false` × 2 (likewise)
        // ⇒ n2 = 4, N2 = 9. A blanket exclusion gives N2 = 7; no guard
        // at all restores the double count at N2 = 11.
        check_metrics::<CsharpParser>(
            "class A {\n    public static bool operator true(A a) => false;\n    public static bool operator false(A a) => true;\n}\n",
            "foo.cs",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 9);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_predefined_types_keyed_by_lexeme() {
        // Regression: issue #286. The C# grammar emits one `PredefinedType`
        // kind_id for every keyword type (`int`, `string`, `bool`, …).
        // Without keying by source text the entire family collapses into
        // a single Halstead operator (n1 += 1) instead of one per distinct
        // keyword. This test pins the post-fix behaviour using four
        // distinct primitives — `int`, `string`, `bool`, `object` —
        // appearing as parameter types so no other operators interact
        // with the count.
        //
        // expected: operators are `class`, `void`, `M`, `{}`, `()`, `,`
        // (×3 between 4 params), plus the four distinct predefined types
        // → u_operators = 5 + 4 = 9. Without the fix the four primitives
        // collapse to one entry, giving u_operators = 6.
        check_metrics::<CsharpParser>(
            "class C { void M(int a, string b, bool c, object d) {} }",
            "foo.cs",
            |metric| {
                // The headline assertion: four distinct primitive
                // keywords contribute four distinct operators, not one.
                assert_eq!(metric.halstead.unique_operators(), 9);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_interpolated_string_no_double_count() {
        // Regression: issue #183. A C# `$"Hi {name}!"` used to be
        // classified as a Halstead operand (the wrapping
        // `InterpolatedStringExpression`) AND have its inner
        // `Interpolation`'s identifier classified as an operand too.
        // The fix routes `InterpolatedStringExpression` through a
        // conditional: when it has an `Interpolation` child, the inner
        // identifier already carries the operand contribution and the
        // wrapper is treated as `Unknown`; when it does not (static
        // `$"hello"`), the wrapper still counts as one operand.
        //
        // expected: operand contributions for
        //   `class C { void M(string name) { string s = $"Hi {name}!"; } }`
        // — `C` (class), `M` (method), `name` (param), `s` (local),
        // and the inner `name` (inside `{...}`). With the fix,
        // u_operands = 4 (C, M, name, s); N2 = 5 (`name` twice).
        // Without the fix, the wrapping `$"Hi {name}!"` would also
        // count → u_operands = 5, N2 = 6.
        check_metrics::<CsharpParser>(
            "class C { void M(string name) { string s = $\"Hi {name}!\"; } }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 5);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_static_interpolated_string_is_operand() {
        // Regression: issue #183. A `$"..."` with no `{...}` is
        // semantically identical to `"..."` and must still contribute
        // exactly one operand — the conditional `is_child(Interpolation)`
        // check distinguishes it from a true interpolation. expected:
        // operands are `C`, `M`, `s`, `$"hello"` → u_operands = 4, N2 = 4.
        // A naive "always Unknown" fix would yield u_operands = 3, N2 = 3,
        // diverging from the plain-string equivalent below.
        check_metrics::<CsharpParser>(
            "class C { void M() { string s = $\"hello\"; } }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );
    }

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_plain_string_still_operand() {
        // The fix for #183 only changes how `InterpolatedStringExpression`
        // is classified; plain `StringLiteral` (and `VerbatimStringLiteral`
        // / `RawStringLiteral`) must still contribute exactly one operand
        // each. expected: operands are `C`, `M`, `s`, `"hi"` →
        // u_operands = 4, N2 = 4.
        check_metrics::<CsharpParser>(
            "class C { void M() { string s = \"hi\"; } }",
            "foo.cs",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );
    }

    // C# half of #1380 — see `java_self_and_super_references_are_operands`
    // for the structural argument. `base` moves with `this`: both are
    // receivers of a member access.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_self_and_base_references_are_operands() {
        let source = "class T {\n    int F() { return this.x + base.y; }\n}";
        // Operators (n1=8, N1=10): class, {} x2, int, (), return, . x2, +, ;
        // Operands (n2=6, N2=6): T, F, this, x, base, y
        // Before the fix this read (10, 12, 4, 4).
        assert_halstead_counts::<CsharpParser>(
            source,
            "foo.cs",
            [8, 10, 6, 6],
            "csharp self/base references",
        );
        assert_keywords_are_operands_only::<CsharpParser>(source, "foo.cs", &["this", "base"]);
    }

    // An `indexer_declaration` spells the member's *name* with the same
    // `this` token kind the receiver uses (both are kind 91), so a
    // blanket move would have billed a declarator keyword as a value.
    // The declaration keeps the operator classification that the
    // `operator` keyword of an overload declaration already has (#1380).
    //
    // The fixture carries both uses, which is what makes the gate
    // observable: `this` has to reach *both* vocabularies from one file.
    // Asserting only the operand side would pass with the gate deleted,
    // and only the operator side would pass with the whole #1380 change
    // reverted (grammar-dispatch section 11).
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_indexer_declaration_keyword_is_not_a_self_reference() {
        let source = "class C {\n    int[] _a;\n    \
                      public int this[int i] { get { return this._a[i]; } }\n}";

        // Asserted per space, not through the root. The root merges
        // every space's vocabulary, and the fixture has one declarator
        // `this` and one receiver `this`, so at the root `this` is a
        // member of *both* vocabularies whether the gate is right or
        // exactly backwards — and every Halstead count is bit-identical
        // under the swap, one occurrence on each side either way. The
        // space tree is where the two uses stay apart: the declarator
        // sits in the class's own vocabulary and the receiver in the
        // accessor's.
        let mut roles = Vec::new();
        collect_keyword_roles(
            &ops_of::<CsharpParser>(source, "foo.cs"),
            "this",
            &mut roles,
        );

        // `Both` can only arise from two `this` nodes in one space that
        // the getter classifies differently — it is the gate's whole
        // effect, and it disappears the moment `this` gets one role.
        // `OperandOnly` is the accessor, the innermost space and the one
        // holding the receiver alone; it is what flips when the gate is
        // inverted rather than dropped. Correct gives
        // `[Both, Both, OperandOnly]`; inverting gives
        // `[Both, Both, OperatorOnly]`; dropping the gate gives three
        // `OperandOnly`; reverting #1380 gives three `OperatorOnly`.
        // Asserting the whole sequence rather than two `contains` calls:
        // the comment above already derives it, and a `contains` pair
        // leaves the length unasserted, so a space appearing or vanishing
        // goes unnoticed and `[Both, X, OperandOnly]` passes for any `X`.
        assert_eq!(
            roles,
            vec![Role::Both, Role::Both, Role::OperandOnly],
            "the declarator and the receiver must disagree in the two outer spaces \
             and the accessor must bill `this` as an operand alone",
        );
    }

    /// One `this` and one `base` per container the pinned
    /// `tree-sitter-c-sharp` can put them in: a delegating constructor
    /// initializer, a base-constructor initializer, a member access, an
    /// element access, and a call argument. No `indexer_declaration` —
    /// that position is the gated one and is an operator.
    #[cfg(feature = "csharp")]
    const CSHARP_SELF_POSITIONS: &str = "class Pos : B {
        int[] _a;
        public Pos() : this(1) { }
        public Pos(int x) : base(x) { }
        int A() { return this._a[0]; }
        int C() { return base.H(); }
        int E() { return base[0]; }
        int F() { return this[0]; }
        void G() { M(this); }
        void M(object o) { }
    }";

    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_self_and_base_leaves_are_unaliased_and_unconditional() {
        assert_self_reference_leaves::<CsharpCode>(
            CSHARP_SELF_POSITIONS,
            &[
                ("this", Csharp::This as u16, 4),
                ("base", Csharp::Base as u16, 3),
            ],
            "csharp",
        );
    }

    /// Every spelling of the six keywords `_parameter_type_with_modifiers`
    /// aliases to `modifier`, plus two controls that were billed before
    /// #1418: the bare `params` of a parameter array (kind 94, never
    /// aliased) and the bare `out` of a call argument (kind 56).
    ///
    /// `D` is declared *and* called so the argument `out` has a caller
    /// to sit in, which is what makes the two spellings of one keyword
    /// meet in one file.
    #[cfg(feature = "csharp")]
    const CSHARP_PARAMETER_MODIFIERS: &str = "static class E {
    static void A(this Foo f) { }
    static void B(scoped ref Foo f) { }
    static void C(ref readonly Foo f) { }
    static void D(out int x) { x = 1; }
    static void G(in Foo f) { }
    static void H(params int[] xs) { }
    static void I(ref int y) { D(out y); }
}";

    /// Each of the five operator keywords in *both* of its kind
    /// spellings — the childless `modifier` of a parameter, and the
    /// keyword's own token elsewhere: `ref` as a ref local, ref
    /// initializer and ref argument (kind 28); `readonly` as the leaf
    /// under a field's `modifier` wrapper (48); `in` as the `foreach`
    /// separator and an `in` argument (55); `out` as an out argument
    /// (56); `scoped` as a scoped ref local (93).
    ///
    /// Separate from [`CSHARP_PARAMETER_MODIFIERS`] because that fixture
    /// pairs the two spellings for `out` alone, which left four of the
    /// five bare kinds `CsharpCode::is_primitive` lists with no input
    /// (#1418).
    #[cfg(feature = "csharp")]
    const CSHARP_MODIFIER_BOTH_SPELLINGS: &str = "class S {
    static readonly int q = 0;
    static void M(scoped ref int a, ref readonly int b, in int c, out int d) { d = q; }
    static void N(int[] xs) {
        ref int r = ref xs[0];
        scoped ref int s = ref xs[1];
        foreach (var e in xs) { }
        M(ref r, in s, in s, out r);
    }
}";

    /// The six aliased parameter modifiers reach a Halstead half, and
    /// each reaches the same one its bare token reaches elsewhere
    /// (#1418).
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_parameter_modifiers_are_classified_1418() {
        // Operators (n1 = 15, N1 = 48): class 1; {} 8 (the class body
        // and seven method bodies); static 8 (the class and seven
        // methods); void 7; () 8 (seven parameter lists and the call);
        // int 3 (`out int x`, `int[]`, `ref int y`); [] 1; = 1; ; 2;
        // scoped 1; ref 3; readonly 1; out 2 (the parameter and the
        // argument); in 1; params 1.
        //
        // Operands (n2 = 15, N2 = 24): E 1; A/B/C/G/H/I 1 each; D 2
        // (declaration and call); this 1; Foo 4; f 4; x 2; 1 1; xs 1;
        // y 2.
        //
        // Before the fix this read (11, 41, 14, 23). The eight childless
        // `modifier` nodes were billed nowhere, which cost seven
        // operator occurrences and one operand occurrence, and emptied
        // `scoped`, `ref`, `readonly` and `in` out of the operator
        // vocabulary entirely — `out` survived only because the call
        // argument spells it with the unaliased kind.
        assert_halstead_counts::<CsharpParser>(
            CSHARP_PARAMETER_MODIFIERS,
            "foo.cs",
            [15, 48, 15, 24],
            "csharp parameter modifiers",
        );

        // The receiver is an operand, matching every other C# `this`
        // (#1380). Both halves matter: an arm listing it twice would
        // still put it among the operands.
        assert_keywords_are_operands_only::<CsharpParser>(
            CSHARP_PARAMETER_MODIFIERS,
            "foo.cs",
            &["this"],
        );

        let ops = ops_of::<CsharpParser>(CSHARP_PARAMETER_MODIFIERS, "foo.cs");
        for keyword in ["ref", "out", "in", "scoped", "readonly", "params"] {
            assert!(
                ops.operators.iter().any(|o| o == keyword),
                "`{keyword}` must be an operator; operators were {:?}",
                ops.operators
            );
            assert!(
                !ops.operands.iter().any(|o| o == keyword),
                "`{keyword}` must not be an operand; operands were {:?}",
                ops.operands
            );
        }

        // The vocabulary is not deduplicated — it is the concatenation
        // of the kind-keyed and the lexeme-keyed operator maps — so a
        // keyword appearing twice is the #453 shape: one keyword split
        // across the two maps and counted twice in `n1`. Keeping both
        // spellings in one map is what `CsharpCode::is_primitive`
        // listing the five bare kinds buys, and this is the only
        // assertion that can see it.
        //
        // It needs a fixture carrying *both* spellings of each keyword,
        // which `CSHARP_PARAMETER_MODIFIERS` does for `out` alone: its
        // `ref`, `in`, `scoped` and `readonly` are all in parameter
        // position, so for those the count can only ever be one and the
        // assertion is dead. That left four of the five bare kinds with
        // no input at all — dropping `Csharp::Ref`, `In`, `Readonly` or
        // `Scoped` from `is_primitive` failed no test in the workspace.
        let both_code = CSHARP_MODIFIER_BOTH_SPELLINGS.as_bytes();
        let spellings = [
            ("ref", Csharp::Ref as u16),
            ("out", Csharp::Out as u16),
            ("in", Csharp::In as u16),
            ("scoped", Csharp::Scoped as u16),
            ("readonly", Csharp::Readonly as u16),
        ];
        let (mut bare, mut aliased) = ([0_usize; 5], [0_usize; 5]);

        for_each_node_with_chain::<CsharpCode>(both_code, |node, _| {
            let text = &both_code[node.start_byte()..node.end_byte()];
            let Some(index) = spellings.iter().position(|(kw, _)| kw.as_bytes() == text) else {
                return;
            };
            if node.kind_id() == Csharp::Modifier as u16 && node.child_count() == 0 {
                aliased[index] += 1;
            } else if node.kind_id() == spellings[index].1 {
                bare[index] += 1;
            }
        });

        // Without this the count below is vacuous for any keyword the
        // fixture stopped spelling both ways — the same decay that hid
        // the four unguarded kinds in the first place.
        for (index, (keyword, _)) in spellings.iter().enumerate() {
            assert!(
                bare[index] > 0 && aliased[index] > 0,
                "fixture must spell `{keyword}` both ways; it has {} bare and {} aliased",
                bare[index],
                aliased[index]
            );
        }

        let both = ops_of::<CsharpParser>(CSHARP_MODIFIER_BOTH_SPELLINGS, "both.cs");
        for (keyword, _) in spellings {
            assert_eq!(
                both.operators.iter().filter(|o| *o == keyword).count(),
                1,
                "`{keyword}` must be one operator across both of its kind spellings; \
                 operators were {:?}",
                both.operators
            );
        }
    }

    /// Pins the grammar shape the #1418 arm gates on, in both
    /// directions.
    ///
    /// The arm reads `modifier` nodes with no children as aliased bare
    /// keywords and leaves the rest to their classified keyword leaf.
    /// That is a claim about two populations, and a grammar bump can
    /// break either: giving an alias a token child would double-count
    /// it, and flattening a declaration modifier to a childless node
    /// would bill `public` / `static` as an unknown keyword. Both are
    /// checked here, so neither can move quietly.
    ///
    /// Childlessness says "aliased", *not* "parameter modifier" —
    /// `_lambda_expression_init` and `anonymous_method_expression` alias
    /// a bare `static` / `async` onto the same kind, which the second
    /// walk below pins so the distinction cannot be forgotten. Their
    /// `Unknown` is today's behaviour rather than a contract: it is what
    /// they were before #1418, and billing them is a decision about
    /// lambdas. It is asserted only so making that decision has to come
    /// through this test.
    #[cfg(feature = "csharp")]
    #[test]
    fn csharp_aliased_modifier_is_childless() {
        let code = CSHARP_PARAMETER_MODIFIERS.as_bytes();
        let (mut aliased, mut declaration) = (0_usize, 0_usize);

        for_each_node_with_chain::<CsharpCode>(code, |node, chain| {
            if node.kind_id() != Csharp::Modifier as u16 {
                return;
            }
            let role = CsharpCode::get_op_type_with_code(node, code, Ancestors::known(chain));
            let text = &code[node.start_byte()..node.end_byte()];

            if node.child_count() == 0 {
                aliased += 1;
                // Spelled out rather than `this`-versus-everything-else,
                // because "everything else is an operator" is false of
                // the kind at large — a lambda's aliased `static` is
                // neither, and the second walk below owns it.
                let (correct, expected) = match text {
                    b"this" => (matches!(role, TokenRole::Operand), "an operand"),
                    b"scoped" | b"ref" | b"out" | b"in" | b"readonly" => {
                        (matches!(role, TokenRole::Operator), "an operator")
                    }
                    other => panic!(
                        "`{}` is not one of the six parameter spellings this fixture carries",
                        String::from_utf8_lossy(other)
                    ),
                };
                assert!(
                    correct,
                    "`{}` is an aliased parameter modifier and must be {expected}",
                    String::from_utf8_lossy(text)
                );
                // Grammar-dispatch section 5: nothing containing the
                // token is classified, so billing the token cannot
                // count the same source text twice. Every ancestor,
                // not just `parameter` — `parameter_list` and the
                // declaration above it contain it too.
                for (depth, ancestor) in chain.iter().enumerate() {
                    assert!(
                        matches!(
                            CsharpCode::get_op_type_with_code(
                                ancestor,
                                code,
                                Ancestors::known(&chain[..depth])
                            ),
                            TokenRole::Unknown
                        ),
                        "`{}` contains an aliased modifier and is itself classified, so the \
                         keyword now counts twice",
                        ancestor.kind()
                    );
                }
            } else {
                declaration += 1;
                assert_eq!(
                    node.child_count(),
                    1,
                    "a declaration `modifier` wraps exactly one keyword leaf"
                );
                assert!(
                    matches!(role, TokenRole::Unknown),
                    "the `{}` wrapper must stay unclassified; its leaf carries the operator",
                    String::from_utf8_lossy(text)
                );
                let leaf = node.child(0).expect("child_count is 1");
                let mut leaf_chain = chain.to_vec();
                leaf_chain.push(*node);
                assert!(
                    matches!(
                        CsharpCode::get_op_type_with_code(
                            &leaf,
                            code,
                            Ancestors::known(&leaf_chain)
                        ),
                        TokenRole::Operator
                    ),
                    "the leaf under a declaration `modifier` must carry the operator"
                );
            }
        });

        // Eight of each: `this`, `scoped`, `ref` x3, `readonly`, `out`,
        // `in` in parameter position, and the `static` of the class and
        // of its seven methods. Asserted so a fixture that stopped
        // carrying one population cannot pass having checked nothing.
        assert_eq!(aliased, 8, "fixture lost an aliased parameter modifier");
        assert_eq!(declaration, 8, "fixture lost a declaration modifier");

        // The second alias site. `static (int x) => …` and `async
        // delegate (int y) { … }` put a bare keyword under the same
        // childless `modifier`, so `csharp_is_aliased_modifier` holds
        // for a node that is not in a parameter at all — which is why
        // the getter dispatches on the text and not on the kind.
        let lambda = "static class L {
    static void M() {
        var a = static (int x) => x + 1;
        var b = async delegate (int y) { return y; };
    }
}"
        .as_bytes();
        let mut lambda_aliases = 0_usize;

        for_each_node_with_chain::<CsharpCode>(lambda, |node, chain| {
            if node.kind_id() != Csharp::Modifier as u16 || node.child_count() != 0 {
                return;
            }
            lambda_aliases += 1;
            let text = &lambda[node.start_byte()..node.end_byte()];
            assert!(
                matches!(text, b"static" | b"async"),
                "`{}` is not a lambda modifier the grammar aliases",
                String::from_utf8_lossy(text)
            );
            assert!(
                matches!(
                    CsharpCode::get_op_type_with_code(node, lambda, Ancestors::known(chain)),
                    TokenRole::Unknown
                ),
                "`{}` on a lambda is unbilled today, as it was before #1418; billing it is a \
                 deliberate change and belongs in this assertion, not around it",
                String::from_utf8_lossy(text)
            );
        });

        assert_eq!(
            lambda_aliases, 2,
            "fixture lost a lambda / anonymous-method modifier alias"
        );
    }

    #[cfg(feature = "go")]
    #[test]
    fn go_operators_and_operands() {
        check_metrics::<GoParser>(
            "package main
            func sum(a, b int) int {
                return a + b
            }",
            "foo.go",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 7,
                  "total_operators": 7,
                  "unique_operands": 5,
                  "total_operands": 8,
                  "length": 15,
                  "estimated_program_length": 31.26112492884004,
                  "purity_ratio": 2.0840749952560027,
                  "vocabulary": 12,
                  "volume": 53.77443751081734,
                  "difficulty": 5.6,
                  "level": 0.17857142857142858,
                  "effort": 301.1368500605771,
                  "time": 16.729825003365395,
                  "bugs": 0.014975730436275946
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_operators_and_operands() {
        check_metrics::<PerlParser>(
            "sub sum {
                my ($a, $b) = @_;
                return $a + $b;
            }",
            "foo.pl",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 10,
                  "total_operators": 14,
                  "unique_operands": 4,
                  "total_operands": 6,
                  "length": 20,
                  "estimated_program_length": 41.219280948873624,
                  "purity_ratio": 2.0609640474436812,
                  "vocabulary": 14,
                  "volume": 76.14709844115208,
                  "difficulty": 7.5,
                  "level": 0.13333333333333333,
                  "effort": 571.1032383086406,
                  "time": 31.727957683813365,
                  "bugs": 0.02294502281013948
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_interpolated_string_no_double_count() {
        // Regression: issue #199. A `string_double_quoted` (and
        // `string_qq_quoted` / `backtick_quoted` / `command_qx_quoted`)
        // wrapping an `interpolation` child used to be counted as a
        // Halstead operand while the inner scalar/array/hash variable
        // was also walked and counted — double-counting the inner
        // variable's contribution to `N2`. Mirrors #180 (Bash/Elixir),
        // #183 (C#), #184 (PHP), #191 (Kotlin).
        //
        // expected: for
        //   sub greet { my $name = shift; my $msg = "Hi $name"; return $msg; }
        // — operands are `greet`, `$name`, `shift`, `$msg`. With the
        // fix the wrapping `"Hi $name"` is skipped (has `Interpolation`
        // child), so u_operands = 4 and N2 = 6 (`$name` x2 from the
        // `my` binding and the interpolation; `$msg` x2 from the `my`
        // binding and `return`; `greet`, `shift` once each). Without
        // the fix the wrapping literal would also be counted, lifting
        // u_operands to 5 and N2 to 7.
        check_metrics::<PerlParser>(
            "sub greet { my $name = shift; my $msg = \"Hi $name\"; return $msg; }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 6);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_plain_string_still_operand() {
        // The fix for #199 only skips wrapping literals that carry an
        // `Interpolation` child; a plain `"hello"` (no `$…` inside)
        // must still contribute exactly one operand. expected: operands
        // `greet`, `$msg`, `"hello"` → u_operands = 3, N2 = 4 (`$msg`
        // appears in the `my` binding and the `return`).
        check_metrics::<PerlParser>(
            "sub greet { my $msg = \"hello\"; return $msg; }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_single_quoted_string_never_interpolates() {
        // Single-quoted (`'…'`) and `q{…}` literals are not subject to
        // interpolation in Perl, so even when their text contains a
        // `$name`-shaped sequence the wrapper is still counted as one
        // operand and the inner text is not parsed as a variable.
        // expected: operands `greet`, `$msg`, `'Hi $name'` →
        // u_operands = 3, N2 = 4 (`$msg` x2).
        check_metrics::<PerlParser>(
            "sub greet { my $msg = 'Hi $name'; return $msg; }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_plain_heredoc_counts_as_one_operand() {
        // Regression: issue #287. A plain (non-interpolating) Perl
        // heredoc body used to be classified `TokenRole::Unknown`,
        // so its visible `HeredocBodyStatement` node contributed
        // nothing to N2 even though it is a string literal. The fix
        // adds `HeredocBodyStatement` to the interpolation-aware
        // operand arm, so an inert heredoc counts as one operand.
        //
        // Source (heredoc body lives at the source_file level, not
        // inside any sub):
        //   my $msg = <<END;
        //   hello world
        //   END
        //
        // Operands traversed:
        //   * `$msg` (`scalar_variable`)                    × 1
        //   * heredoc body (`heredoc_body_statement`)       × 1
        // expected: u_operands = 2, N2 = 2.
        check_metrics::<PerlParser>("my $msg = <<END;\nhello world\nEND\n", "foo.pl", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_interpolated_heredoc_no_double_count() {
        // Regression: issue #287. An interpolating Perl heredoc
        // (`<<"TAG"` or bare `<<TAG`) carries an `Interpolation` child
        // when its body contains a `$var`. The wrapper must drop to
        // `Unknown` so the inner scalar variable carries the operand
        // count — same dispatch as the existing double-quoted /
        // backtick / qx wrappers (issue #199) and the PHP heredoc fix
        // (issue #184).
        //
        // Source:
        //   my $name = "x";
        //   my $msg = <<"END";
        //   hi $name
        //   END
        //
        // Operands by text key:
        //   * `$name` × 2 (my-binding + interpolation inside heredoc)
        //   * `"x"`  × 1 (inert double-quoted string)
        //   * `$msg` × 1
        // expected: u_operands = 3, N2 = 4. Without the
        // interpolation-aware drop the wrapping heredoc body would
        // also count, lifting u_operands to 4 and N2 to 5.
        check_metrics::<PerlParser>(
            "my $name = \"x\";\nmy $msg = <<\"END\";\nhi $name\nEND\n",
            "foo.pl",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_bare_pattern_delimiters_are_not_operators() {
        // Regression: issue #1312, the Perl sibling of Elixir #1256.
        // The bare match form is the only one of Perl's regex literals
        // whose delimiters are spelled with an operator token kind —
        // `bca dump` shows `/abc/` emitting two `SLASH` under
        // `PatternMatcher` — so `$s =~ /abc/;` reported a `/` operator
        // with no division in the source.
        //
        // expected: operators `$` (the `scalar_variable` sigil), `=~`
        // and `;` → n1 = N1 = 3. Operands `$s` and the `/abc/` pattern
        // → n2 = N2 = 2. Before the guard the two delimiters added `/`
        // → n1 = 4, N1 = 5; the pattern operand arrived with #1314,
        // which promoted all three pattern spellings together (see
        // `perl_every_pattern_value_spelling_scores_alike`).
        check_metrics::<PerlParser>("$s =~ /abc/;\n", "foo.pl", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 3);
            assert_eq!(metric.halstead.total_operators(), 3);
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_every_pattern_value_spelling_scores_alike() {
        // Companion to the test above (#1312, extended by #1314).
        // `m/abc/` is exactly `/abc/` in Perl and `qr/abc/` is the same
        // pattern as a value, so the three spellings of a pattern
        // *value* must score identically whatever delimiters they use.
        //
        // Until #1314 they scored alike at *zero*: no Perl pattern
        // wrapper was in the operand arm, so the literal never counted,
        // unlike Ruby's `Regex` and Elixir's `Sigil`. #1312 declined to
        // promote the bare form on its own precisely because that would
        // have scored `/abc/` at one operand and its synonyms at zero,
        // reintroducing the spelling sensitivity this test pins.
        // Promoting all three together closes the gap and keeps the
        // equality, which is what this test now asserts.
        //
        // `s///` and `tr///` are deliberately *not* rows here any more.
        // They are operations applied to a target rather than pattern
        // values, so #1314 made them operators; their own equality is
        // pinned by `perl_every_pattern_operation_spelling_scores_alike`
        // below. Splitting the one loop in two is the substantive
        // disagreement #1314 had with the reasoning recorded here: this
        // test governs *synonyms*, and `s///` is not a synonym of
        // `/abc/`.
        //
        // The fixture matches twice against one variable so that no two
        // of `[n1, N1, n2, N2]` are equal. A square tuple would leave
        // `assert_halstead_counts`' unique-vs-total axes unpinned —
        // transposing n1 with N1 inside the helper failed no test while
        // all three of its callers expected a square tuple.
        //
        // expected per variant: operators `$` × 2 (one per
        // `scalar_variable`), `=~` × 2, `and`, `;` → n1 = 4, N1 = 6.
        // The pattern contributes no *operator* — that is #1312's half
        // — and one operand, so with `$s` twice and the pattern twice
        // → n2 = 2, N2 = 4.
        for pattern in ["/abc/", "m/abc/", "m{abc}", "qr/abc/"] {
            assert_halstead_counts::<PerlParser>(
                &format!("$s =~ {pattern} and $s =~ {pattern};\n"),
                "foo.pl",
                [4, 6, 2, 4],
                &format!("pattern {pattern}"),
            );
        }
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_every_pattern_operation_spelling_scores_alike() {
        // The other half of the split (#1314). Substitution and
        // transliteration are operations applied to a target, so they
        // are operators — and like the value spellings, their delimiter
        // choice must not move the count. `y///` is a synonym of
        // `tr///` and shares `TransliterationTrOrY`, so the two fold to
        // one operator entry, which is why all four rows agree on n1.
        //
        // expected per variant: operators `$` × 2, `=~` × 2, `and`,
        // `;`, and the operation itself × 2 → n1 = 5, N1 = 8. The
        // pattern and replacement text is invisible to this grammar —
        // `substitution_pattern_s` emits only its keyword and
        // delimiters, no content node — so the sole operand is `$s`,
        // twice → n2 = 1, N2 = 2.
        for pattern in ["s/a/b/", "s{a}{b}", "tr/a/b/", "y/a/b/"] {
            assert_halstead_counts::<PerlParser>(
                &format!("$s =~ {pattern} and $s =~ {pattern};\n"),
                "foo.pl",
                [5, 8, 1, 2],
                &format!("pattern {pattern}"),
            );
        }
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_interpolated_pattern_operands_agree_but_operators_do_not() {
        // Two things at once (#1314), because they are the same
        // measurement: why the three pattern-value spellings route
        // through `string_operand_type` rather than a plain operand
        // arm, and what that routing does *not* fix.
        //
        // `m/$x/` and `qr/$x/` emit a real `Interpolation` wrapping a
        // `scalar_variable`, while the bare form keeps its `$x` inside
        // an unclassified `regex_pattern_content`. So:
        //
        // * Operands agree at n2 = N2 = 2 (`$s` plus one contribution
        //   from the pattern) only because of the interpolation guard.
        //   A plain operand arm would count the wrapper *and* the inner
        //   `$x` for the suffixed forms — n2 = 3 — reintroducing
        //   through the back door the divergence
        //   `perl_every_pattern_value_spelling_scores_alike` exists to
        //   prevent. Which node carries the one operand still differs
        //   by spelling: the wrapper for the bare form, the inner `$x`
        //   for the other two.
        // * Operators do *not* agree: the exposed `scalar_variable`
        //   brings a `$` sigil, an operator here, that the bare form
        //   has no node for. Over two matches N1 is 6 for `/$x/` and
        //   8 for the other two.
        //
        // The operator asymmetry is a grammar gap this classifier
        // cannot repair — there is nothing to classify in the bare
        // form — so it is pinned rather than papered over, the same
        // treatment `perl_division_emits_no_slash_token` gives the
        // missing division token. A bump that starts exposing the bare
        // form's interpolation turns this red, at which point the
        // expectations above need re-deriving.
        // Each fixture matches twice, so `N1 > n1` and `N2 > n2` and no
        // row is a square tuple that a transposition inside
        // `assert_halstead_counts` could pass (#1312).
        assert_halstead_counts::<PerlParser>(
            "$s =~ /$x/ and $s =~ /$x/;\n",
            "foo.pl",
            [4, 6, 2, 4],
            "bare /$x/",
        );
        for pattern in ["m/$x/", "qr/$x/"] {
            assert_halstead_counts::<PerlParser>(
                &format!("$s =~ {pattern} and $s =~ {pattern};\n"),
                "foo.pl",
                [4, 8, 2, 4],
                &format!("suffixed {pattern}"),
            );
        }
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_division_emits_no_slash_token() {
        // Drift marker, not an endorsement. Ruby's counterpart
        // (`ruby_division_survives_the_regex_guard`) proves #1312's
        // guard cannot swallow a real division; Perl has no such
        // fixture to write, because at the pinned grammar `$a / $b`
        // emits *no* `SLASH` token at all — `binary_expression`'s
        // children skip straight from one `scalar_variable` to the
        // other. Perl division therefore counts zero operators today,
        // a pre-existing grammar gap this fix neither causes nor
        // repairs.
        //
        // Pinning it keeps the gap in CI: a bump that starts emitting
        // the token turns this red, at which point the division would
        // begin counting (its parent is `BinaryExpression`, not
        // `PatternMatcher`, so the guard leaves it alone) and the
        // expectations above need re-deriving.
        //
        // The same gap is why no Perl test can distinguish the
        // parent-scoped guard from an ancestor-scoped one: with no
        // `SLASH` reachable below a `PatternMatcher`, that mutant is
        // unobservable here — measured, not assumed. Perl's guard is
        // parent-scoped for correctness by construction and for
        // symmetry with Ruby's, where the distinction *is* observable
        // and is pinned by
        // `ruby_regex_guard_is_parent_scoped_not_ancestor_scoped`.
        let path = PathBuf::from("foo.pl");
        let source = "my $z = $a / $b;\n";
        let parser = PerlParser::new(source.as_bytes().to_vec(), &path, None);
        assert!(
            !ast_has_kind_id(&parser, Perl::SLASH as u16),
            "tree-sitter-perl still emits no SLASH for `{source}`"
        );
        // Anchor the negative assertion to *this* fixture. Without it
        // the test stays green when `source` is edited to something
        // containing no division at all — measured: swapping in
        // `my $z = 1;` failed nothing.
        //
        // expected: operators `my`, `=`, `$` × 3 (one per
        // `scalar_variable`), `;` → n1 = 4, N1 = 6, with no `/` among
        // them. Operands `$z`, `$a`, `$b` → n2 = N2 = 3.
        check_metrics::<PerlParser>(source, "foo.pl", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 4);
            assert_eq!(metric.halstead.total_operators(), 6);
            assert_eq!(metric.halstead.unique_operands(), 3);
            assert_eq!(metric.halstead.total_operands(), 3);
        });
        // Positive control: the same kind *is* reachable in this
        // grammar, so the assertion above is about division and not
        // about `Perl::SLASH` being enum-only dead weight.
        let matcher = PerlParser::new(b"$s =~ /abc/;\n".to_vec(), &path, None);
        assert!(
            ast_has_kind_id(&matcher, Perl::SLASH as u16),
            "Perl::SLASH must be the bare pattern delimiter kind"
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_readline_closer_alias_never_reaches_kind_id() {
        // Drift marker for `Perl::GT2` (#1395). The grammar closes
        // `<FH>` / `<$fh>` with `token.immediate('>')`, which the
        // generated parser gives its own symbol — hence the `GT2`
        // variant sitting next to `FileHandle` in the enum — but whose
        // `public_symbol_map` entry collapses it onto `GT` before
        // `kind_id()`, exactly like `LPAREN2` in #768 and Ruby's
        // `SLASH2` in #1312. Nothing in `getter/perl.rs` names it, and
        // nothing should: `compute_halstead` keys a non-primitive
        // operator on `kind_id()`, so two live kinds both rendering
        // `">"` would split one `>` across two `n1` entries. If a bump
        // ever starts emitting it, the repair is to route `>` through
        // the lexeme-keyed map, not to list both — and this test is
        // what says so.
        //
        // The same collapse makes the `GT2` arm in `getter/cpp.rs` and
        // `getter/mozcpp.rs` a defensive arm rather than a live one:
        // tree-sitter-cpp maps its `>>`-closing `GT2` the same way, so
        // `vector<vector<int>>` reports two `GT`s.
        let path = PathBuf::from("foo.pl");
        for source in ["my $l = <FH>;\n", "my $l = <$fh>;\n", "my $b = $x > $y;\n"] {
            let parser = PerlParser::new(source.as_bytes().to_vec(), &path, None);
            assert!(
                !ast_has_kind_id(&parser, Perl::GT2 as u16),
                "Perl::GT2 must stay collapsed to Perl::GT for `{source}`"
            );
            // Positive control: the id the operator arm fires on is
            // present, so the assertion above cannot pass merely
            // because the fixture grew no `>` at all.
            assert!(
                ast_has_kind_id(&parser, Perl::GT as u16),
                "Perl::GT must be the `>` kind for `{source}`"
            );
        }
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_readline_brackets_are_operators() {
        // #1395: a readline's `<` / `>` delimit syntax, not a literal,
        // so under the policy on `Getter::get_op_type` they are
        // ordinary operators — even though ABC's `conditions` excludes
        // them (#1297). `<STDIN>` is the one spelling that cannot show
        // this: the grammar lexes it as a single `standard_input`
        // token, so there are no brackets to classify.
        //
        // expected: operators `sub`, `{}`, `my`, `$` × 2 (one per
        // `scalar_variable`), `=`, `<`, `>`, `;` × 2, `return` →
        // n1 = 9, N1 = 11. Operands `r`, `$l` × 2, `FH` →
        // n2 = 3, N2 = 4.
        check_metrics::<PerlParser>("sub r { my $l = <FH>; return $l; }\n", "foo.pl", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 9);
            assert_eq!(metric.halstead.total_operators(), 11);
            assert_eq!(metric.halstead.unique_operands(), 3);
            assert_eq!(metric.halstead.total_operands(), 4);
        });
    }

    /// Every (name wrapper, contained operand) pairing tree-sitter-perl's
    /// node-types.json admits, and the single source of truth for both
    /// halves of #1355's guard: its parent set is the distinct first
    /// components, the kinds it subsumes the distinct second ones.
    /// `perl_name_wrappers_bill_the_name_once_1355` witnesses every row
    /// and fails on an eleventh pairing.
    #[cfg(feature = "perl")]
    const PERL_NAME_WRAPPER_PAIRINGS: [(Perl, Perl); 10] = [
        (Perl::PackageName, Perl::Identifier),
        (Perl::PackageName, Perl::ScalarVariable),
        (Perl::PackageName, Perl::ArrayVariable),
        (Perl::PackageName, Perl::HashVariable),
        (Perl::PackageName, Perl::SpecialScalarVariable),
        (Perl::PackageName, Perl::Typeglob),
        (Perl::PackageName, Perl::PackageVariable),
        (Perl::PackageVariable, Perl::PackageName),
        (Perl::PackageVariable, Perl::ScalarVariable),
        (Perl::Typeglob, Perl::Identifier),
    ];

    /// The anonymous tokens those wrappers also hold. `::` and `*` are
    /// operators (matched above the guard, so they keep that reading);
    /// `{` folds into the `{}` glyph and `}` has never been classified
    /// at all. Listing them is what lets
    /// `perl_name_wrappers_bill_the_name_once_1355` police *every*
    /// child rather than only the named ones — the operand arm carries
    /// token-shaped kinds too (`True`, `FILE`, `SUB`, …), and a bump
    /// that let one of those inside a wrapper would otherwise be
    /// silenced with nothing failing.
    #[cfg(feature = "perl")]
    const PERL_NAME_WRAPPER_TOKENS: [Perl; 4] =
        [Perl::COLONCOLON, Perl::STAR, Perl::LBRACE, Perl::RBRACE];

    /// The occurrences #1355's guard suppresses in `source`, paired
    /// with the (wrapper kind, child kind) pairings they witness.
    ///
    /// Walks with `for_each_node_with_chain`, which maintains the
    /// ancestor chain exactly as `spaces::compute` does, so "parent"
    /// here means what `Ancestors::parent` means inside the guard
    /// rather than what a differently-built chain would say.
    #[cfg(feature = "perl")]
    fn perl_subsumed_operands(source: &str) -> (Vec<String>, HashSet<(u16, u16)>) {
        let wrappers: HashSet<u16> = PERL_NAME_WRAPPER_PAIRINGS
            .map(|(wrapper, _)| wrapper as u16)
            .into();
        let subsumed: HashSet<u16> = PERL_NAME_WRAPPER_PAIRINGS
            .map(|(_, child)| child as u16)
            .into();
        let tokens: HashSet<u16> = PERL_NAME_WRAPPER_TOKENS.map(|kind| kind as u16).into();
        let code = source.as_bytes();
        let mut hidden = Vec::new();
        let mut pairings = HashSet::new();
        for_each_node_with_chain::<PerlCode>(code, |node, chain| {
            let Some(parent) = chain.last() else { return };
            if !wrappers.contains(&parent.kind_id()) {
                return;
            }
            assert!(
                subsumed.contains(&node.kind_id()) || tokens.contains(&node.kind_id()),
                "`{source}`: a `{}` inside a `{}` is a child this guard was not \
                 derived against; re-read node-types.json before trusting it",
                node.kind(),
                parent.kind(),
            );
            if subsumed.contains(&node.kind_id()) {
                pairings.insert((parent.kind_id(), node.kind_id()));
                hidden.push(
                    node.utf8_text(code)
                        .expect("fixture is valid UTF-8")
                        .to_owned(),
                );
            }
        });
        (hidden, pairings)
    }

    /// One row of `perl_name_wrappers_bill_the_name_once_1355`'s
    /// table: a fixture, what it must measure now, what it measured
    /// before #1355, and the operand text behind the counts.
    struct PerlNameWrapperCase {
        source: &'static str,
        /// `[n1, N1, n2, N2]` with the guard in place.
        counts: [u64; 4],
        /// `[n2, N2]` without it. Re-derived by the loop rather than
        /// trusted, so a stale row fails instead of misinforming.
        before: [u64; 2],
        operands: &'static [&'static str],
    }

    /// Regression for #1355. `package_name`, `package_variable` and
    /// `typeglob` are operands spanning a whole name, so every
    /// operand-classified node *inside* one was billed a second time:
    /// `use strict;` scored `N2` 2 for one name, `our $Foo::count = 3;`
    /// n2 5 / N2 6 for two, and the vocabulary grew a bare `::` entry
    /// because a `package_variable`'s qualifier slot is itself a
    /// childless `package_name`.
    ///
    /// Each row's `before` column is what it measured without the
    /// guard, and the loop re-derives both halves from the current
    /// parse rather than trusting the column — the guard is the only
    /// difference between the two classifications, so the occurrences
    /// it removes are exactly the subsumed-kind children of a wrapper:
    ///
    /// - `N2` before minus `N2` after must equal how many of those
    ///   there are. That identity *is* the defect: one spurious operand
    ///   per contained name part.
    /// - `n2` before is the post-fix vocabulary unioned with their
    ///   texts. It exceeds `n2` after wherever a part's spelling is not
    ///   already an operand on its own (`Data`, `::`, `count`).
    ///
    /// The walk doubles as the grammar-dispatch §1 / §2 drift marker.
    /// It asserts that every *named* child of a wrapper is one of the
    /// eight subsumed kinds — which is what makes keying the arm on the
    /// parent alone safe — and that all ten pairings node-types.json
    /// admits are exercised here, so a bump that renumbers or re-parents
    /// one fails loudly instead of leaving the counts below measuring a
    /// construct the arm no longer reaches.
    ///
    /// Two mutants this does *not* catch, measured rather than assumed.
    /// Widening the guard from parent- to ancestor-scoped fails nothing,
    /// for the reason `perl_division_emits_no_slash_token` already
    /// records about the other guard in this getter: every operand-kinded
    /// descendant of a wrapper is also a direct child of one, and the
    /// intervening sigil tokens are matched by the operator arm above
    /// before the guard is reached. Parent-scoping stands on
    /// grammar-dispatch §5 and on symmetry with that guard, not on a
    /// test. What *is* pinned is the arm's position: moving it above the
    /// operator arm swallows `::`, `*` and the typeglob's opening brace,
    /// and the operator columns below fail.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_name_wrappers_bill_the_name_once_1355() {
        let cases: [PerlNameWrapperCase; 12] = [
            // identifier under package_name, the single-segment form.
            PerlNameWrapperCase {
                source: "use strict;\n",
                counts: [2, 2, 1, 1],
                before: [1, 2],
                operands: &["strict"],
            },
            // …and the multi-segment one, twice over.
            PerlNameWrapperCase {
                source: "require Data::Dumper;\n",
                counts: [3, 3, 1, 1],
                before: [3, 3],
                operands: &["Data::Dumper"],
            },
            PerlNameWrapperCase {
                source: "package Foo::Bar;\n",
                counts: [3, 3, 1, 1],
                before: [3, 3],
                operands: &["Foo::Bar"],
            },
            // The `bar` of a qualified call is a *sibling* of the
            // `package_name`, not a child, so it still counts while the
            // `Foo` inside the wrapper does not. That is the row saying
            // the guard reads position and not kind: keying it on the
            // child kinds instead fails 14 tests here, this one among
            // them.
            PerlNameWrapperCase {
                source: "Foo::bar();\n",
                counts: [3, 3, 2, 2],
                before: [2, 3],
                operands: &["Foo", "bar"],
            },
            // identifier under typeglob, bare and brace-delimited.
            PerlNameWrapperCase {
                source: "my $g = *STDOUT;\n",
                counts: [5, 5, 2, 2],
                before: [3, 3],
                operands: &["$g", "*STDOUT"],
            },
            PerlNameWrapperCase {
                source: "my $t = *{Foo};\n",
                counts: [6, 6, 2, 2],
                before: [3, 3],
                operands: &["$t", "*{Foo}"],
            },
            // package_name and scalar_variable under package_variable,
            // and scalar_variable under package_name — the reported
            // fixture, where `$Foo` was billed twice and `::` once.
            PerlNameWrapperCase {
                source: "our $Foo::count = 3;\n",
                counts: [4, 4, 2, 2],
                before: [5, 6],
                operands: &["$Foo::count", "3"],
            },
            // array_variable / hash_variable / special_scalar_variable
            // under package_name: the same shape with the other sigils.
            PerlNameWrapperCase {
                source: "my @l = @Foo::list;\n",
                counts: [3, 3, 2, 2],
                before: [5, 6],
                operands: &["@l", "@Foo::list"],
            },
            PerlNameWrapperCase {
                source: "my %h = %Foo::hash;\n",
                counts: [3, 3, 2, 2],
                before: [5, 6],
                operands: &["%h", "%Foo::hash"],
            },
            PerlNameWrapperCase {
                source: "my $z = $_::x;\n",
                counts: [4, 5, 2, 2],
                before: [5, 6],
                operands: &["$z", "$_::x"],
            },
            // typeglob under package_name.
            PerlNameWrapperCase {
                source: "*Foo::glob = 1;\n",
                counts: [3, 3, 2, 2],
                before: [6, 7],
                operands: &["*Foo::glob", "1"],
            },
            // package_variable under package_name: the nesting that
            // makes qualifier depth unbounded. One variable reference
            // used to spell seven vocabulary entries.
            PerlNameWrapperCase {
                source: "my $x = $Foo::Bar::baz;\n",
                counts: [4, 5, 2, 2],
                before: [7, 10],
                operands: &["$x", "$Foo::Bar::baz"],
            },
        ];

        let mut witnessed: HashSet<(u16, u16)> = HashSet::new();
        for PerlNameWrapperCase {
            source,
            counts,
            before: [n2_before, total_before],
            operands,
        } in cases
        {
            let (hidden, pairings) = perl_subsumed_operands(source);
            assert!(
                !hidden.is_empty(),
                "row {source:?} contains no name-wrapper child, so it witnesses nothing",
            );
            witnessed.extend(pairings);

            // Phrased as an addition rather than a subtraction so a
            // future edit that inverts the two underflows nothing and
            // fails with the message below.
            assert_eq!(
                total_before,
                counts[3] + hidden.len() as u64,
                "row {source:?} must shed exactly one operand per contained \
                 name part; recorded N2_before {total_before}, parts {hidden:?}",
            );
            let mut vocabulary: HashSet<&str> = operands.iter().copied().collect();
            vocabulary.extend(hidden.iter().map(String::as_str));
            assert_eq!(
                vocabulary.len() as u64,
                n2_before,
                "row {source:?}: n2 before the fix is the post-fix vocabulary \
                 plus the contained name parts; got {vocabulary:?}",
            );

            assert_halstead_counts::<PerlParser>(source, "foo.pl", counts, source);
            assert_ops_operands::<PerlParser>(source, "foo.pl", operands.len(), operands.to_vec());
        }

        let mut got: Vec<(u16, u16)> = witnessed.into_iter().collect();
        got.sort_unstable();
        let mut expected_pairings: Vec<(u16, u16)> = PERL_NAME_WRAPPER_PAIRINGS
            .map(|(wrapper, child)| (wrapper as u16, child as u16))
            .into();
        expected_pairings.sort_unstable();
        assert_eq!(
            got, expected_pairings,
            "the table must exercise every (wrapper, child) pairing \
             node-types.json admits, and no other",
        );
    }

    /// The over-suppression half of #1355 (grammar-dispatch §6 and §11).
    /// The guard is keyed on the parent, so the same kinds it silences
    /// inside a name wrapper have to keep counting everywhere else —
    /// otherwise "one operand per name" would have been bought by
    /// zeroing ordinary variables and calls.
    ///
    /// `module_name` rides along because the issue asserted it shares
    /// the `identifier` leaf and would be collateral damage. It does
    /// not: `use 'Foo.pm'` parses to a leaf holding only its two quote
    /// tokens, so it wraps nothing and is untouched either way.
    #[cfg(feature = "perl")]
    #[test]
    fn perl_qw_list_bills_one_operand_per_element() {
        // `qw(a b c)` was invisible to Halstead — neither the elements,
        // the wrapper nor the `qw` keyword had an arm — so it billed
        // nothing where its synonym `("a", "b", "c")` billed three
        // operands. Each `list_item` is now one operand and the
        // `word_list_qw` wrapper is gated on holding one, the #1353
        // Ruby `%w[]` rule: one operand per element, or one for the
        // empty literal.
        assert_ops_operands::<PerlParser>(
            "my @a = qw(a b c);\n",
            "foo.pl",
            4,
            vec!["@a", "a", "b", "c"],
        );
        assert_ops_operands::<PerlParser>("my @a = qw();\n", "foo.pl", 2, vec!["@a", "qw()"]);
        assert_ops_operands::<PerlParser>(
            "use POSIX qw(floor ceil);\n",
            "foo.pl",
            3,
            vec!["POSIX", "floor", "ceil"],
        );
        // expected: [n1, N1, n2, N2] = [3, 3, 4, 4] for every delimiter —
        // operators `my`, `=`, `;`; the `qw` keyword and its delimiters
        // are unclassified, as Ruby's `%w[` is, so the choice of
        // delimiter cannot move the score (#1312).
        for spelling in [
            "qw(a b c)",
            "qw/a b c/",
            "qw{a b c}",
            "qw[a b c]",
            "qw<a b c>",
        ] {
            assert_halstead_counts::<PerlParser>(
                &format!("my @a = {spelling};\n"),
                "foo.pl",
                [3, 3, 4, 4],
                spelling,
            );
        }
        // The synonym: the same four operands, plus the `()` and `,`
        // operators the list spelling carries.
        assert_halstead_counts::<PerlParser>(
            "my @a = (\"a\", \"b\", \"c\");\n",
            "foo.pl",
            [5, 6, 4, 4],
            "list literal",
        );
    }

    #[cfg(feature = "perl")]
    #[test]
    fn perl_qualified_name_leaves_still_count_elsewhere_1355() {
        // expected: operators `my` × 4, `$` × 3 (one per `$`-sigilled
        // variable), `=` × 4, `;` × 5, `()` × 3 and the fat comma
        // → n1 = 6, N1 = 20. Operands are the four declared variables,
        // the three integers, the hash key, `$_` and the call target
        // → n2 = N2 = 10. Five of the eight kinds the guard silences
        // under a name wrapper appear among them — `scalar_variable`,
        // `array_variable`, `hash_variable`, `special_scalar_variable`
        // and `identifier` — and all five still count here.
        let bare = "my $x = 1;\nmy @a = (2);\nmy %h = (k => 3);\nmy $u = $_;\nfoo();\n";
        assert_halstead_counts::<PerlParser>(bare, "foo.pl", [6, 20, 10, 10], bare);
        assert_ops_operands::<PerlParser>(
            bare,
            "foo.pl",
            10,
            vec!["$x", "1", "@a", "2", "%h", "k", "3", "$u", "$_", "foo"],
        );
        let (hidden, _) = perl_subsumed_operands(bare);
        assert!(
            hidden.is_empty(),
            "no name wrapper appears here, so the guard must be inert; got {hidden:?}",
        );

        // expected: operators `use`, `;` → n1 = N1 = 2; the quoted
        // module name is the sole operand → n2 = N2 = 1.
        let quoted = "use 'Some.pm';\n";
        assert_halstead_counts::<PerlParser>(quoted, "foo.pl", [2, 2, 1, 1], quoted);
        assert_ops_operands::<PerlParser>(quoted, "foo.pl", 1, vec!["'Some.pm'"]);
        assert!(
            ast_has_kind_id(
                &PerlParser::new(quoted.as_bytes().to_vec(), &PathBuf::from("foo.pl"), None),
                Perl::ModuleName as u16,
            ),
            "the quoted `use` form no longer parses to `module_name`, so this \
             row no longer says anything about it",
        );
    }

    #[cfg(feature = "lua")]
    #[test]
    fn lua_operators_and_operands() {
        check_metrics::<LuaParser>(
            "local function add(a, b)
  local result = a + b
  if result > 0 then
    return result
  end
  return 0
end",
            "foo.lua",
            |metric| {
                // n1=11: local,function,(,,,=,+,if,>,then,return,end
                // (after #695 the `)` closer no longer counts — only the
                // folded `(` opener does; was n1=12).
                // n2=5: add,a,b,result,0
                insta::assert_json_snapshot!(metric.halstead, @r#"
                {
                  "unique_operators": 11,
                  "total_operators": 14,
                  "unique_operands": 5,
                  "total_operands": 10,
                  "length": 24,
                  "estimated_program_length": 49.66338827944708,
                  "purity_ratio": 2.0693078449769615,
                  "vocabulary": 16,
                  "volume": 96.0,
                  "difficulty": 11.0,
                  "level": 0.09090909090909091,
                  "effort": 1056.0,
                  "time": 58.666666666666664,
                  "bugs": 0.03456644293839657
                }
                "#);
            },
        );
    }

    /// Regression for #695. Lua/Bash/Tcl/iRules/PHP/Ruby/Elixir used to
    /// classify the *closing* delimiter (`)`/`]`/`}`) as a separate
    /// operator, while the C-family majority folds each balanced pair to a
    /// single glyph via `get_operator_id_as_str` and counts only the
    /// opener. A balanced `(1)` therefore double-counted as `()` + `)`,
    /// inflating n1 and N1. With the fix only the folded `(` opener counts:
    /// `local x = (1)` yields operators `local`, `=`, `()` — n1 = N1 = 3,
    /// with no standalone `)`.
    #[cfg(feature = "lua")]
    #[test]
    fn lua_balanced_paren_counts_opener_only() {
        let source = "local x = (1)\n";
        let path = PathBuf::from("foo.lua");
        let parser = LuaParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        let paren = ops.operators.iter().filter(|o| o.as_str() == "()").count();
        assert_eq!(
            paren, 1,
            "balanced `(1)` must be one `()` operator; operators were {:?}",
            ops.operators
        );
        assert!(
            !ops.operators.iter().any(|o| o.as_str() == ")"),
            "the closing `)` must not be a separate operator; operators were {:?}",
            ops.operators
        );
    }

    /// Guard for #768. Several `get_op_type` impls (Cpp/C/Objc/Mozcpp/
    /// Tcl/iRules/Php/Elixir/Ruby) classify a grammar's *second-alias*
    /// opener — `LPAREN2`, and for Elixir/Ruby `LBRACK2`/`LBRACK3` — as a
    /// Halstead operator alongside the base `LPAREN`/`LBRACK`. #768 worried
    /// that an alias opener would reach `compute_halstead` with a kind_id
    /// distinct from the base, inflating n1 (a second `()` entry) and
    /// rendering a bare `"("` instead of the folded `"()"`.
    ///
    /// That cannot happen: tree-sitter's runtime collapses each alias to
    /// its base via the grammar's `public_symbol_map` *before*
    /// `Node::kind_id()` (`ts_node_symbol`) ever returns. So the alias
    /// kind_id is unobservable to the metric layer and the alias match arms
    /// are defensive — they only fire if a future grammar bump drops that
    /// collapse. This test pins the invariant: parsing the exact
    /// constructs each grammar produces the alias for internally
    /// (pp-conditional `defined(...)` for Cpp; call arg-list / subscript /
    /// constant-array-pattern for Ruby) must yield **no** node carrying the
    /// alias kind_id, and the balanced opener must count once and render as
    /// the pair glyph. If a grammar bump makes an alias id observable, this
    /// goes red and signals that the alias arms must additionally fold to
    /// the base in `get_operator_id_as_str` (the fix #768 proposed).
    #[cfg(all(feature = "c", feature = "cpp", feature = "elixir", feature = "ruby"))]
    #[test]
    fn second_alias_opener_collapses_to_base_kind_id() {
        #[cfg(any(feature = "c", feature = "cpp", feature = "elixir", feature = "ruby"))]
        fn assert_no_alias<T: crate::ParserTrait>(
            source: &str,
            file: &str,
            alias_id: u16,
            alias_name: &str,
        ) {
            let path = PathBuf::from(file);
            let parser = T::new(source.as_bytes().to_vec(), &path, None);
            let mut stack = vec![parser.root()];
            while let Some(node) = stack.pop() {
                assert_ne!(
                    node.kind_id(),
                    alias_id,
                    "{alias_name} (kind_id {alias_id}) must never reach kind_id() \
                     for `{source}`; the runtime public_symbol_map should have \
                     collapsed it to the base opener. If this fires after a \
                     grammar bump, fold {alias_name} to its pair glyph in \
                     get_operator_id_as_str (issue #768)."
                );
                for child in node.children() {
                    stack.push(child);
                }
            }
        }

        // Balanced openers must count once and render folded (no bare
        // `(`/`[`, no n1 inflation) — the property #768 feared was broken.
        #[cfg(any(feature = "c", feature = "cpp", feature = "elixir", feature = "ruby"))]
        fn assert_folded_openers<T: crate::MetricSuite>(source: &str, file: &str) {
            let path = PathBuf::from(file);
            let parser = T::new(source.as_bytes().to_vec(), &path, None);
            let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
            assert!(
                !ops.operators.iter().any(|o| o.as_str() == "("),
                "no bare `(` operator (must fold to `()`); operators were {:?}",
                ops.operators
            );
            assert!(
                !ops.operators.iter().any(|o| o.as_str() == "["),
                "no bare `[` operator (must fold to `[]`); operators were {:?}",
                ops.operators
            );
            // Each pair glyph appears at most once — the alias does not add
            // a second `()`/`[]` entry to n1.
            assert!(
                ops.operators.iter().filter(|o| o.as_str() == "()").count() <= 1,
                "`()` must be a single n1 entry; operators were {:?}",
                ops.operators
            );
            assert!(
                ops.operators.iter().filter(|o| o.as_str() == "[]").count() <= 1,
                "`[]` must be a single n1 entry; operators were {:?}",
                ops.operators
            );
        }

        // Cpp/C/Mozcpp: LPAREN2 = 20. The grammar emits it internally only
        // inside preprocessor-conditional expressions (`#if defined(FOO)`).
        assert_no_alias::<crate::CppParser>(
            "#if defined(FOO)\n#endif\n",
            "a.cpp",
            20,
            "Cpp::LPAREN2",
        );
        assert_no_alias::<crate::CParser>("#if defined(FOO)\n#endif\n", "a.c", 20, "C::LPAREN2");

        // Ruby: LPAREN2 = 47 (call arg-list), LBRACK3 = 155 (element-
        // reference subscript), LBRACK2 = 46 (constant array pattern).
        assert_no_alias::<crate::RubyParser>("f(1)\n", "a.rb", 47, "Ruby::LPAREN2");
        assert_no_alias::<crate::RubyParser>("a[0]\n", "a.rb", 155, "Ruby::LBRACK3");
        assert_no_alias::<crate::RubyParser>(
            "case p\nin Point[1, 2] then 1\nend\n",
            "a.rb",
            46,
            "Ruby::LBRACK2",
        );

        // Elixir: LPAREN2 = 95 (immediate call paren), LBRACK2 = 96
        // (access / subscript).
        assert_no_alias::<crate::ElixirParser>("f(1)\n", "a.ex", 95, "Elixir::LPAREN2");
        assert_no_alias::<crate::ElixirParser>("x[0]\n", "a.ex", 96, "Elixir::LBRACK2");

        assert_folded_openers::<crate::CppParser>("int main(){ int a[3]; return a[0]; }", "b.cpp");
        assert_folded_openers::<crate::RubyParser>("f(1)\nb = [1]\nb[0]\n", "b.rb");
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_halstead_basic() {
        check_metrics::<KotlinParser>(
            "fun add(a: Int, b: Int): Int {
                val result = a + b
                return result
            }",
            "foo.kt",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 9,
                  "total_operators": 11,
                  "unique_operands": 5,
                  "total_operands": 10,
                  "length": 21,
                  "estimated_program_length": 40.13896548741762,
                  "purity_ratio": 1.9113793089246487,
                  "vocabulary": 14,
                  "volume": 79.9544533632097,
                  "difficulty": 9.0,
                  "level": 0.1111111111111111,
                  "effort": 719.5900802688873,
                  "time": 39.97722668160485,
                  "bugs": 0.026767153565498338
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_string_template_no_double_count() {
        // Re-anchored for issue #454. The pre-#454 comment claimed
        // kotlin-ng emits an `identifier` node for the short `$name`
        // form whose bytes include the leading `$`. That is factually
        // false: AST dump shows the short form produces bare
        // `string_content` tokens (`$`, then `name`) with **no**
        // structured node. The old assertion (u_operands = 4, N2 = 5)
        // passed for the wrong reason (lesson 6): the wrapping literal
        // was counted (+1) and the inner `name` was dropped (-1), and
        // the two errors cancelled. The `$name!` it used also defeats
        // recovery because the grammar glues the trailing `!` onto the
        // name token.
        //
        // Correct mechanism (clean end-of-segment short form):
        // `fun greet(name: String): String {\n    return "Hi $name"\n}\n`
        //   operators: fun, (, ), :, {}, return → as classified.
        //   operands by token text:
        //     `greet` × 1, `name` × 2 (param + recovered short-interp),
        //     `String` × 2 (param type + return type).
        //   The wrapping `"Hi $name"` literal is suppressed and the
        //   inner `name` recovered → u_operands = 3 (`greet`, `name`,
        //   `String`), N2 = 5. Pre-#454: wrapper counted, inner dropped
        //   → u_operands = 4, N2 = 6.
        check_metrics::<KotlinParser>(
            "fun greet(name: String): String {\n    return \"Hi $name\"\n}\n",
            "foo.kt",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 5);
            },
        );
        // Lesson 4: the ops store agrees on n2 and the exact operand set
        // (inner `name` present, wrapper absent).
        assert_ops_operands::<KotlinParser>(
            "fun greet(name: String): String {\n    return \"Hi $name\"\n}\n",
            "foo.kt",
            3,
            vec!["greet", "name", "String"],
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_short_interpolation_counts_inner_not_wrapper() {
        // Issue #454: the short `$name` template — distinct from the
        // long `${expr}` form, which the kotlin-ng grammar gives a
        // structured `interpolation` node (see
        // `kotlin_string_template_long_form_no_double_count`). The short
        // form has no such node; the variable arrives as a bare
        // `string_content` token preceded by a `$` `string_content`.
        // The fix recovers the clean-identifier variable as an operand
        // and suppresses the opaque wrapper.
        //
        // `fun f() { val x = 1; println("v=$x") }\n`
        //   operands by token text: `f`, `x` × 2 (decl + recovered),
        //   `println`, `1`. The wrapping `"v=$x"` is suppressed →
        //   u_operands = 4 (`f`, `x`, `println`, `1`), N2 = 5.
        // Pre-#454 the wrapper `"v=$x"` counted and the inner `x` was
        // dropped → u_operands = 4 but the wrapper, not `x`, was the
        // fourth operand, and N2 = 5 with the wrong member — the ops
        // assertion below pins the exact set so the cancellation cannot
        // hide it.
        let src = "fun f() { val x = 1; println(\"v=$x\") }\n";
        check_metrics::<KotlinParser>(src, "foo.kt", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 4);
            assert_eq!(metric.halstead.total_operands(), 5);
        });
        assert_ops_operands::<KotlinParser>(src, "foo.kt", 4, vec!["f", "x", "println", "1"]);
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_short_interpolation_space_separated() {
        // Issue #454 follow-up: tree-sitter-kotlin-ng splits the literal
        // only at each `$`, so a `$name` segment's name token absorbs any
        // trailing inter-segment text into its byte range. For `"$a $b"`
        // the token after the first `$` is `"a "` (with the trailing
        // space). Pre-fix `kotlin_is_identifier("a ")` returned false and
        // the leading variable `a` was silently dropped, yielding
        // operands `{b, f, s}` (verified: `a` missing) — breaking parity
        // with the long form `"${a} ${b}"`, which recovers `{a, b, f, s}`.
        //
        // The fix takes the maximal leading-identifier prefix of the name
        // token, recovering `a` and keying it as the bare `"a"` (not
        // `"a "`). Short and long forms must now agree exactly.
        //
        // `fun f() { val s = "$a $b" }\n`
        //   operands by token text: `f`, `s`, `a` (recovered), `b`
        //   (recovered). Wrapper suppressed → u_operands = 4, N2 = 4.
        let short = "fun f() { val s = \"$a $b\" }\n";
        let long = "fun f() { val s = \"${a} ${b}\" }\n";
        check_metrics::<KotlinParser>(short, "foo.kt", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 4);
            assert_eq!(metric.halstead.total_operands(), 4);
        });
        // Both `a` and `b` present, wrapper absent, n2 == dedupe(operands).
        assert_ops_operands::<KotlinParser>(short, "foo.kt", 4, vec!["f", "s", "a", "b"]);
        // Exact parity with the long `${a} ${b}` form.
        assert_ops_operands::<KotlinParser>(long, "foo.kt", 4, vec!["f", "s", "a", "b"]);

        // Comma after the name (`"$a, $b"`): the first name token is
        // `"a, "`; its leading identifier prefix is `a`.
        let comma = "fun f() { val s = \"$a, $b\" }\n";
        assert_ops_operands::<KotlinParser>(comma, "foo.kt", 4, vec!["f", "s", "a", "b"]);

        // Name preceded by literal text and at end-of-segment (`"x=$a"`):
        // the `a` token has no trailing text, so recovery is unchanged.
        let prefixed = "fun f() { val s = \"x=$a\" }\n";
        assert_ops_operands::<KotlinParser>(prefixed, "foo.kt", 3, vec!["f", "s", "a"]);

        // Mid-prose `"$x is "`: the name token is `"x is "`. The leading
        // identifier prefix is `x`, matching the long form `"${x} is "`,
        // which also recovers `x` and treats `" is "` as literal text.
        let prose_short = "fun f() { val s = \"$x is \" }\n";
        let prose_long = "fun f() { val s = \"${x} is \" }\n";
        assert_ops_operands::<KotlinParser>(prose_short, "foo.kt", 3, vec!["f", "s", "x"]);
        assert_ops_operands::<KotlinParser>(prose_long, "foo.kt", 3, vec!["f", "s", "x"]);
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_dollar_non_identifier_stays_literal() {
        // Issue #454 boundary: a `$` not followed by a clean identifier
        // is literal text, not an interpolation. `"price: $5"` (digit
        // after `$`) must keep the wrapping literal as a single operand
        // and recover nothing.
        //
        // `fun f() { val a = "price: $5" }\n`
        //   operands: `f`, `a`, `"price: $5"` → u_operands = 3, N2 = 3.
        let src = "fun f() { val a = \"price: $5\" }\n";
        check_metrics::<KotlinParser>(src, "foo.kt", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 3);
            assert_eq!(metric.halstead.total_operands(), 3);
        });
        assert_ops_operands::<KotlinParser>(src, "foo.kt", 3, vec!["f", "a", "\"price: $5\""]);
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_string_template_long_form_no_double_count() {
        // The `${expr}` long form of a Kotlin string template also
        // produces an `Interpolation` child. The fix must apply to it
        // identically.
        //
        // Source: `fun f(x: Int): String { return "v=${x}" }\n`
        // Operands by source-byte key:
        //   `f` × 1, `x` × 2 (param + inside `${x}`),
        //   `Int` × 1, `String` × 1.
        // With the fix u_operands = 4 (`f`, `x`, `Int`, `String`),
        // N2 = 5. Without the fix the wrapping `"v=${x}"` would also
        // count → u_operands = 5, N2 = 6.
        check_metrics::<KotlinParser>(
            "fun f(x: Int): String { return \"v=${x}\" }\n",
            "foo.kt",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 5);
            },
        );
    }

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_plain_string_still_operand() {
        // The fix for #191 only skips wrapping templates that contain
        // an `Interpolation` child; a plain `"hello"` (no `$` interp)
        // must still contribute exactly one operand.
        //
        // Source: `fun f(): String { return "hello" }\n`
        // Operands: `f` × 1, `String` × 1, `"hello"` × 1 →
        // u_operands = 3, N2 = 3.
        check_metrics::<KotlinParser>(
            "fun f(): String { return \"hello\" }\n",
            "foo.kt",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 3);
            },
        );
    }

    // Kotlin half of #1380 — see
    // `java_self_and_super_references_are_operands` for the structural
    // argument.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_self_and_super_references_are_operands() {
        let source = "class T {\n    fun f() = this.x + super.y\n}";
        // Operators (n1=7, N1=8): class, {}, fun, (), =, . x2, +
        // Operands (n2=6, N2=6): T, f, this, x, super, y
        // Before the fix this read (9, 10, 4, 4).
        assert_halstead_counts::<KotlinParser>(
            source,
            "foo.kt",
            [7, 8, 6, 6],
            "kotlin self/super references",
        );
        assert_keywords_are_operands_only::<KotlinParser>(source, "foo.kt", &["this", "super"]);
    }

    // The label-qualified spellings are their own leaf kinds — `this@`
    // (106) and `super@` (107) — carrying no `this` / `super` leaf, so
    // listing only the two bare kinds would score every `this@Outer`
    // reference zero (grammar-dispatch section 1). The labels `Outer`
    // and `Inner` stay separate operands: the `this_expression` wrapper
    // whose span would have swallowed them is deliberately unclassified
    // (section 5).
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_labelled_self_and_super_references_are_operands() {
        let source = "class Outer {\n    inner class Inner : A() {\n        \
                      fun f() = this@Outer.x + super@Inner.y\n    }\n}";
        assert_keywords_are_operands_only::<KotlinParser>(source, "foo.kt", &["this@", "super@"]);
        assert_ops_operands::<KotlinParser>(
            source,
            "foo.kt",
            8,
            vec!["A", "Inner", "Outer", "f", "super@", "this@", "x", "y"],
        );
        // The metrics store is a second, independent walk — it keys
        // operands by `get_operand_id` where `ops_inner` keys by text —
        // so `assert_ops_operands` on its own pins the ops store against
        // a literal rather than against the metric (lesson 4).
        //
        // `N2` is what makes the "the labels stay separate operands"
        // claim above testable. Both labels duplicate an enclosing class
        // name, so dropping their contribution entirely leaves `n2` at 8
        // with the same eight strings; only `N2` falls, 10 to 8.
        check_metrics::<KotlinParser>(source, "foo.kt", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 8);
            assert_eq!(metric.halstead.total_operands(), 10);
        });
    }

    // The keeper question of grammar-dispatch section 6: a
    // `constructor_delegation_call` emits a bare `this` / `super` leaf
    // with no `this_expression` / `super_expression` wrapper around it,
    // so classifying the wrapper instead would score constructor
    // delegation zero. This is the only spelling that can tell the two
    // choices apart — every other `this` carries both nodes — so it is
    // the independent path grammar-dispatch section 11 asks for.
    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_constructor_delegation_self_reference_is_an_operand() {
        let source = "class C(val n: Int) {\n    constructor() : this(0)\n}";
        assert_keywords_are_operands_only::<KotlinParser>(source, "foo.kt", &["this"]);
        assert_ops_operands::<KotlinParser>(
            source,
            "foo.kt",
            5,
            vec!["0", "C", "Int", "n", "this"],
        );
        check_metrics::<KotlinParser>(source, "foo.kt", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 5);
            assert_eq!(metric.halstead.total_operands(), 5);
        });
    }

    /// One `this` / `super` per container the pinned
    /// `tree-sitter-kotlin-ng` can put them in: a bare expression, a
    /// call argument, a navigation receiver, a type-argument-qualified
    /// `super<P>`, both label-qualified forms, and the
    /// `constructor_delegation_call` that carries no wrapper.
    #[cfg(feature = "kotlin")]
    const KOTLIN_SELF_POSITIONS: &str = "class P {
        fun h() = 1
    }
    class Outer : P() {
        val x = 1
        fun c() = super.h()
        fun d() = this
        fun e(o: Any): Any = e(this)
        inner class Inner : P() {
            fun a() = this@Outer.x
            fun b() = this.hashCode()
            fun f() = super@Inner.h()
            fun g() = super<P>.h()
        }
    }
    class Del(val n: Int) {
        constructor() : this(0)
    }
";

    #[cfg(feature = "kotlin")]
    #[test]
    fn kotlin_self_and_super_leaves_are_unaliased_and_unconditional() {
        assert_self_reference_leaves::<KotlinCode>(
            KOTLIN_SELF_POSITIONS,
            &[
                ("this", Kotlin::This as u16, 4),
                ("super", Kotlin::Super as u16, 2),
                ("this@", Kotlin::ThisAT as u16, 1),
                ("super@", Kotlin::SuperAT as u16, 1),
            ],
            "kotlin",
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_fstring_no_double_count() {
        // Regression: issue #191. A Python f-string (`f"Hi {name}!"`)
        // wraps an `Interpolation` child whose inner identifier
        // `name` is walked and counted as its own operand. Without
        // the `is_child(Interpolation)` guard the wrapping `String`
        // would also count, double-counting `name`'s contribution to
        // `N2`. Same pattern as #180 (Bash/Elixir) and #184 (PHP).
        //
        // Source: `def greet(name):\n    return f"Hi {name}!"\n`
        // Operands by source-byte key:
        //   `greet` × 1, `name` × 2 (param + inside `{name}`).
        // With the fix the wrapping `f"Hi {name}!"` is skipped →
        // u_operands = 2 (`greet`, `name`), N2 = 3. Without the fix
        // the wrapping literal would also count → u_operands = 3,
        // N2 = 4.
        check_metrics::<PythonParser>(
            "def greet(name):\n    return f\"Hi {name}!\"\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 3);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_plain_string_still_operand() {
        // The fix for #191 only skips wrapping `String` nodes that
        // contain an `Interpolation` child; a plain `"hi"` must still
        // contribute exactly one operand.
        //
        // Source: `def f():\n    return "hi"\n`
        // Operands: `f` × 1, `"hi"` × 1 → u_operands = 2, N2 = 2.
        // (The previous documentation-string filter is preserved:
        // a bare `"hi"` as a top-level `expression_statement` would
        // be skipped, but here it appears as `return "hi"`.)
        check_metrics::<PythonParser>("def f():\n    return \"hi\"\n", "foo.py", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_concatenated_docstring_suppressed() {
        // Regression for #695. An implicit-concatenation docstring
        // (`"""doc""" "more"`) parses as `expression_statement >
        // concatenated_string > [string, string]`. The single-literal
        // docstring guard (`parent == expression_statement &&
        // child_count == 1`) never fired here, so each fragment counted
        // as a separate operand and the docstring's N2 contribution
        // depended on how many literals it was split into. With the fix,
        // every fragment of such a docstring is suppressed.
        //
        // Source: `def f():\n    """doc""" "more"\n    return 1\n`
        // Operands: `f`, `1` only — both docstring fragments suppressed →
        // u_operands = 2, N2 = 2.
        check_metrics::<PythonParser>(
            "def f():\n    \"\"\"doc\"\"\" \"more\"\n    return 1\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 2);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_concatenated_non_docstring_still_counts() {
        // The #695 fix must only suppress concatenated literals in the
        // *docstring* position (sole child of an `expression_statement`).
        // A concatenated string used as a value (`x = "a" "b"`) is not a
        // docstring — its `concatenated_string` parent's grandparent is
        // an assignment, not a single-child statement — so both fragments
        // must still be operands.
        //
        // Source: `def f():\n    x = "a" "b"\n    return x\n`
        // Operands: `f`, `x` (twice: assign + return), `"a"`, `"b"` →
        // u_operands = 4, N2 = 5.
        check_metrics::<PythonParser>(
            "def f():\n    x = \"a\" \"b\"\n    return x\n",
            "foo.py",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 5);
            },
        );
    }

    #[cfg(feature = "python")]
    #[test]
    fn python_empty_file_halstead() {
        check_metrics::<PythonParser>("", "empty.py", |metric| {
            let h = &metric.halstead;
            assert_eq!(h.unique_operators(), 0);
            assert_eq!(h.total_operands(), 0);
            assert_eq!(h.estimated_program_length(), 0.0);
            assert_eq!(h.purity_ratio(), 0.0);
            assert_eq!(h.volume(), 0.0);
            assert_eq!(h.difficulty(), 0.0);
            assert_eq!(h.level(), 0.0);
            assert_eq!(h.effort(), 0.0);
            assert_eq!(h.time(), 0.0);
            assert_eq!(h.bugs(), 0.0);
        });
    }

    /// Regression #413, sub-fix (1): `await` was double-counted because the
    /// operator arm listed both the await-expression node (Await=237) and the
    /// nested `await` keyword token (Await2=95). Only the node should count,
    /// mirroring how `yield` counts only the Yield node.
    #[cfg(feature = "python")]
    #[test]
    fn python_await_counted_once_per_use() {
        check_metrics::<PythonParser>(
            "async def f():\n    await a()\n    await b()\n    await c()\n",
            "foo.py",
            |metric| {
                // expected operators: async, def, await  (3 unique)
                //   await used three times -> N1 counts: async(1) def(1) await(3) = 5
                //   Before #413, Await + Await2 both matched, so `await` was a
                //   distinct operator twice: n1=4, N1=8.
                assert_eq!(metric.halstead.unique_operators(), 3);
                assert_eq!(metric.halstead.total_operators(), 5);
            },
        );
    }

    /// Regression #413, sub-fix (3): `lambda` was dropped entirely. Only the
    /// `lambda` keyword token (Lambda3=73) is classified, not the wrapping
    /// Lambda/Lambda2 expression nodes, to avoid an await-style double count.
    #[cfg(feature = "python")]
    #[test]
    fn python_lambda_counted_once() {
        check_metrics::<PythonParser>("g = lambda x: x + 1\n", "foo.py", |metric| {
            // expected operators: =, lambda, +  (3 unique, each used once)
            // Before #413, lambda was absent: only =, + were counted.
            assert_eq!(metric.halstead.unique_operators(), 3);
            assert_eq!(metric.halstead.total_operators(), 3);
        });
    }

    /// Regression #413, sub-fix (2): `match` / `case` keyword tokens
    /// (Match=26, Case=27) were dropped. Each should now count as an operator,
    /// matching the cyclomatic metric which already counts every `case`.
    #[cfg(feature = "python")]
    #[test]
    fn python_match_case_counted() {
        check_metrics::<PythonParser>(
            "match x:\n    case 1:\n        pass\n    case _:\n        pass\n",
            "foo.py",
            |metric| {
                // expected operators: match, case, pass  (3 unique)
                //   match(1) + case(2) + pass(2) = 5 total occurrences.
                // Before #413, neither match nor case was counted (only pass).
                assert_eq!(metric.halstead.unique_operators(), 3);
                assert_eq!(metric.halstead.total_operators(), 5);
            },
        );
    }

    /// Regression #413, sub-fix (2): `nonlocal` (Nonlocal=41) was dropped while
    /// `global` was already classified. Both should count, for parity.
    #[cfg(feature = "python")]
    #[test]
    fn python_nonlocal_and_global_counted() {
        check_metrics::<PythonParser>(
            "def f():\n    global a\n    nonlocal b\n",
            "foo.py",
            |metric| {
                // expected operators: def, global, nonlocal  (3 unique)
                // Before #413, nonlocal was absent: only def, global counted.
                assert_eq!(metric.halstead.unique_operators(), 3);
                assert_eq!(metric.halstead.total_operators(), 3);
            },
        );
    }

    /// Regression #413, sub-fix (4): `not in` (Notin=193) and `is not`
    /// (Isnot=194) are single compound operators. The parent-guard suppresses
    /// the inner Not/In/Is leaves only under those compounds, so standalone
    /// `not x`, `a in b`, `a is b`, and `for x in y` still count their leaves.
    #[cfg(feature = "python")]
    #[test]
    fn python_not_in_is_not_counted_as_single_operator() {
        check_metrics::<PythonParser>(
            "a not in b\na is not b\nnot c\nd in e\nf is g\nfor h in i:\n    pass\n",
            "foo.py",
            |metric| {
                // expected operators (7 unique):
                //   "not in" (compound, once), "is not" (compound, once),
                //   "not" (standalone `not c`, once),
                //   "in" (standalone `d in e` + `for h in i` = twice),
                //   "is" (standalone `f is g`, once),
                //   "for" (once), "pass" (once)
                // Total occurrences: 1+1+1+2+1+1+1 = 8.
                // Before #413, `a not in b` counted not+in (two) and
                // `a is not b` counted is+not (two); the compounds were
                // never classified.
                assert_eq!(metric.halstead.unique_operators(), 7);
                assert_eq!(metric.halstead.total_operators(), 8);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_operators_and_operands() {
        check_metrics::<BashParser>(
            "#!/bin/bash
f() {
    local x=1
    if [ $x -eq 1 ]; then
        echo 'one'
    fi
}",
            "foo.sh",
            |metric| {
                // Operators (9 unique, 9 occurrences): the opening
                // delimiters `()`/`{}`/`[]` (each folded to one glyph and
                // counted once per balanced pair, #695 — the closers no
                // longer add a second operator), `local`, `=`, `if`,
                // `then`, `fi`, `;`.
                // Operands (6 unique, 7 occurrences): `f`, `x` (the
                // assignment LHS `variable_name`, kind 160), `1` (twice:
                // `=1` and `-eq 1`), `$x` (the `simple_expansion` — its
                // inner `variable_name` leaf is now suppressed so `$x`
                // counts once, #695), `echo`, `'one'`.
                // N2 was 8 before #1351: `echo` counted twice, once as the
                // `command_name` wrapper and once as the `word` it wraps.
                assert_eq!(metric.halstead.unique_operators(), 9);
                assert_eq!(metric.halstead.total_operators(), 9);
                assert_eq!(metric.halstead.unique_operands(), 6);
                assert_eq!(metric.halstead.total_operands(), 7);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_interpolated_string_no_double_count() {
        // Regression: issue #180. A double-quoted Bash string containing
        // `$name`, `${name[…]}`, or `$(cmd)` used to be classified as a
        // Halstead operand AND have its inner `simple_expansion` /
        // `expansion` / `command_substitution` children classified as
        // operands too. We now skip the wrapping literal when it has an
        // expansion child so only the inner expansion contributes.
        //
        // expected: operands across `a="plain"\nb="$x"\n` —
        //   line 1: variable_name `a`, plain string `"plain"` (no
        //     expansion, still operand) → 2.
        //   line 2: variable_name `b`, wrapping `"$x"` skipped (has
        //     expansion), `simple_expansion` `$x` (its inner
        //     variable_name `x` leaf is suppressed under #695) → 2.
        // Total unique operands: 4 (`a`, `b`, `"plain"`, `$x`), each
        // appearing once → N2 = 4. Before #695 the inner `x` leaf of
        // `$x` was also counted (u_operands = 5, N2 = 5); before the
        // earlier #180 fix the wrapping `"$x"` literal was counted too.
        // The `=` is the only operator; appears twice (N1 = 2, n1 = 1).
        check_metrics::<BashParser>("a=\"plain\"\nb=\"$x\"\n", "foo.sh", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 1);
            assert_eq!(metric.halstead.total_operators(), 2);
            assert_eq!(metric.halstead.unique_operands(), 4);
            assert_eq!(metric.halstead.total_operands(), 4);
            insta::assert_json_snapshot!(metric.halstead);
        });
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_interpolated_string_no_double_count() {
        // Regression: issue #180. Without the fix, an interpolated
        // Elixir `String` was classified as a single operand while its
        // inner `interpolation` identifier was also walked and
        // classified as its own operand — double-counting the
        // interpolated identifier's contribution to `N2`.
        //
        // expected: operand contributions for
        //   `def greet(name) do\n  msg = "Hi #{name}"\nend\n` —
        // `def`, `greet`, `name` (param), `msg`, and the inner `name`
        // (inside `#{...}`). With the fix, the wrapping
        // `"Hi #{name}"` literal is skipped (has `Interpolation`
        // child), so `name` is the only repeated operand:
        // u_operands = 4 (def, greet, name, msg), N2 = 5. Without the
        // fix, the wrapping literal would also count → u_operands = 5,
        // N2 = 6. Operators: `do`, `end`, `(`, `=` → u = N = 4.
        // Only the *opening* delimiters count after #695, so the `)`
        // and the `}` interpolation closer add no operator; #1314 then
        // dropped the `#{` opener too, on the rule that an
        // interpolation opener is spelling rather than an operation
        // (was 5 here, and 7 before #695).
        check_metrics::<ElixirParser>(
            "def greet(name) do\n  msg = \"Hi #{name}\"\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 4);
                assert_eq!(metric.halstead.total_operators(), 4);
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 5);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_plain_string_still_operand() {
        // The fix for #180 only skips wrapping literals that contain
        // interpolation; a plain `"hello"` must still contribute exactly
        // one operand. expected: `def`, `f`, `"hello"` → 3 unique
        // operands (n2 = 3), each appearing once (N2 = 3).
        check_metrics::<ElixirParser>("def f do\n  \"hello\"\nend\n", "foo.ex", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 3);
            assert_eq!(metric.halstead.total_operands(), 3);
        });
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_boolean_and_nil_literals_count_once() {
        // Regression: issue #1253. `boolean: choice("true", "false")`
        // and `nil: "nil"` each wrap a keyword leaf, and both the
        // wrapper and the leaf sat in the operand arm — so every
        // literal occurrence added +1 to N2. Operands are keyed by
        // source text, so the duplicate collapsed into the same
        // vocabulary entry and n2 stayed correct, which is why nothing
        // caught it.
        //
        // Source is the issue's reproducer plus a repeat of `true` and
        // `nil`, so N2 exceeds n2 and the assertions can tell "counted
        // once per occurrence" from "deduplicated into the vocabulary".
        // All three keywords appear, so restoring any one of `True`,
        // `False`, or `Nil2` to the operand arm trips this test.
        //
        // Operands by text key: `x`, `y`, `z`, `w`, `v`, `true` × 2,
        // `nil` × 2, `false` ⇒ n2 = 8, N2 = 10. Before the fix each of
        // the five literals counted twice ⇒ N2 = 15.
        //
        // This also guards the drift in the other direction. Elixir
        // classifies the wrapper and drops the leaf outright rather
        // than parent-guarding it, so a grammar bump that stopped
        // emitting `boolean` / `nil` would leave the leaves unclassified
        // and the literals would vanish from N2 entirely (⇒ 5 / 5)
        // rather than merely being miscounted.
        check_metrics::<ElixirParser>(
            "x = true\ny = nil\nz = false\nw = true\nv = nil\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 8);
                assert_eq!(metric.halstead.total_operands(), 10);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_reserved_word_after_a_dot_stays_an_operand() {
        // Companion to the test above (#1253). Elixir drops `True` /
        // `False` / `Nil2` from the operand arm outright, which is only
        // safe because the one grammar position that accepts a reserved
        // word outside the `boolean` / `nil` wrapper — the right-hand
        // side of a remote dot — aliases it to `identifier`. This pins
        // that alias: if a grammar bump emitted the bare keyword there
        // instead, `Foo.nil` and `Foo.true` would silently stop
        // contributing an operand.
        //
        // Source: a = Foo.nil / b = Foo.true / c = nil
        //
        // Operands by text key: `a`, `Foo` × 2, `nil` × 2 (the aliased
        // identifier and the real literal, which share a text key),
        // `b`, `true`, `c` ⇒ n2 = 6, N2 = 8. Losing the alias drops the
        // two dotted references ⇒ N2 = 6.
        check_metrics::<ElixirParser>("a = Foo.nil\nb = Foo.true\nc = nil\n", "foo.ex", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 6);
            assert_eq!(metric.halstead.total_operands(), 8);
        });
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_interpolated_sigil_no_double_count() {
        // Sigils mirror strings under #180. For `~r/foo#{name}/`, the
        // wrapping `Sigil` is skipped, but `SigilName` (`r`) and the
        // inner `name` identifier each contribute one operand.
        // expected: `def`, `f`, `name` (param), `re`, `r` (sigil name),
        // `name` (inside `#{...}`) → u_operands = 5, N2 = 6 (`name`
        // twice).
        check_metrics::<ElixirParser>(
            "def f(name) do\n  re = ~r/foo#{name}/\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 5);
                assert_eq!(metric.halstead.total_operands(), 6);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_interpolated_charlist_no_double_count() {
        // Charlists mirror strings and sigils under #180. The
        // `E::String | E::Charlist | E::Sigil` arm in `get_op_type`
        // skips any wrapping literal that has an `Interpolation`
        // child; this test exercises the `Charlist` branch
        // specifically.
        //
        // expected: for `def f(name) do\n  cl = 'Hi #{name}'\nend\n` —
        // `def`, `f`, `name` (param), `cl`, and the inner `name`
        // (inside `#{...}`). With the fix, the wrapping
        // `'Hi #{name}'` is skipped → u_operands = 4 (def, f, name,
        // cl), N2 = 5 (`name` twice).
        check_metrics::<ElixirParser>(
            "def f(name) do\n  cl = 'Hi #{name}'\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 5);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_sigil_delimiters_are_not_operators() {
        // Regression: issue #1256. Sigil delimiter tokens share their
        // kind ids with real operators (`SLASH`, `LPAREN`, `LBRACE`,
        // …) and were classified unconditionally, so `~r/abc/`
        // fabricated two division operators and the author's delimiter
        // choice moved n1/N1. The parent guard suppresses them under
        // `Sigil`; `~` stays the single per-sigil operator.
        //
        // expected: operators `=` × 3 and `~` × 3 → n1 = 2, N1 = 6.
        // Without the guard the delimiters added `/` × 2, `(`, `{` →
        // n1 = 5, N1 = 10. Operands: `a`, `~r/abc/i`, `r`, `i` (sigil
        // modifiers), `b`, `~w(one two)`, `w`, `c`, `~s{hi}`, `s` →
        // n2 = N2 = 10.
        check_metrics::<ElixirParser>(
            "a = ~r/abc/i\nb = ~w(one two)\nc = ~s{hi}\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 2);
                assert_eq!(metric.halstead.total_operators(), 6);
                assert_eq!(metric.halstead.unique_operands(), 10);
                assert_eq!(metric.halstead.total_operands(), 10);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_sigil_delimiter_choice_is_invariant() {
        // Companion to the test above (#1256): two sigils differing
        // only in delimiter are the same literal, so every delimiter
        // choice must produce identical Halstead counts. `(` `[` `{`
        // `<` `/` `|` are the operator-kind delimiters the guard
        // covers; `"` and `'` never had an operator arm and pin the
        // already-correct path.
        //
        // expected per variant: operators `=`, `~` → n1 = 2, N1 = 2;
        // operands `x`, the sigil literal text, `w` (sigil name) →
        // n2 = 3, N2 = 3.
        for (open, close) in [
            ("(", ")"),
            ("[", "]"),
            ("{", "}"),
            ("<", ">"),
            ("/", "/"),
            ("|", "|"),
            ("\"", "\""),
            ("'", "'"),
        ] {
            assert_halstead_counts::<ElixirParser>(
                &format!("x = ~w{open}one two{close}\n"),
                "foo.ex",
                [2, 2, 3, 3],
                &format!("delimiter pair {open} {close}"),
            );
        }
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_standalone_operators_survive_the_sigil_guard() {
        // Control for #1256: the guard is parent-scoped, so the same
        // token kinds outside a sigil still count. Covers every guarded
        // kind standalone: `/` (division), `<` / `>` (comparison), `[`
        // and `|` (list cons), `(` (call), `{` (map literal, with its
        // `%`).
        //
        // expected: operators `=` × 6, `/`, `<`, `>`, `[`, `|`, `(`,
        // `%`, `{` → n1 = 9, N1 = 14. Operands: `x`, `a`, `b`, `y`,
        // `c`, `d`, `z`, `e`, `f`, `q`, `h`, `t`, `p`, `g`, `1`, `m`,
        // the `k:` keyword, `2` → n2 = N2 = 18.
        check_metrics::<ElixirParser>(
            "x = a / b\ny = c < d\nz = e > f\nq = [h | t]\np = g(1)\nm = %{k: 2}\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 9);
                assert_eq!(metric.halstead.total_operators(), 14);
                assert_eq!(metric.halstead.unique_operands(), 18);
                assert_eq!(metric.halstead.total_operands(), 18);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_interpolated_sigil_keeps_inner_nodes_counting() {
        // Interpolation inside a sigil after #1256: the `{` delimiter
        // is suppressed (its parent is the `Sigil`), while the
        // `interpolation` child is a separate node whose inner
        // identifier must still count — the guard must not reach past
        // the delimiter tokens.
        //
        // expected: operators `=`, `~` → n1 = N1 = 2. Operands:
        // `v`, `s` (sigil name), `b` (interpolated identifier); the
        // wrapping sigil is skipped (`Interpolation` child, #180) and
        // `quoted_content` is unclassified → n2 = N2 = 3. The `#{`
        // marker was a third operator until #1314 dropped it.
        check_metrics::<ElixirParser>("v = ~s{a#{b} c}\n", "foo.ex", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 2);
            assert_eq!(metric.halstead.total_operators(), 2);
            assert_eq!(metric.halstead.unique_operands(), 3);
            assert_eq!(metric.halstead.total_operands(), 3);
        });

        // A guarded kind *inside* the interpolation: the `/` in
        // `#{a / b}` has `binary_operator` as its parent but the
        // `Sigil` as a further ancestor, so this input is the one
        // discriminator between the correct parent-scoped guard and a
        // wrong ancestor-scoped one that would swallow it.
        //
        // expected: operators `=`, `~`, `/` → n1 = N1 = 3 (the `#{`
        // opener stopped counting with #1314); operands `v`, `s`, `a`,
        // `b` → n2 = N2 = 4. The division is what this row is for, and
        // it still counts — the ancestor-scoped mutant drops it.
        check_metrics::<ElixirParser>("v = ~s{x #{a / b} y}\n", "foo.ex", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 3);
            assert_eq!(metric.halstead.total_operators(), 3);
            assert_eq!(metric.halstead.unique_operands(), 4);
            assert_eq!(metric.halstead.total_operands(), 4);
        });
    }

    #[cfg(feature = "bash")]
    #[test]
    fn bash_all_expansion_kinds_skip_wrapper() {
        // Exercises every node kind tested by
        // `bash_string_has_expansion`: `simple_expansion` (`$v`),
        // `expansion` (`${v[0]}`), `command_substitution` (`$(date)`),
        // and `arithmetic_expansion` (`$((1+2))`). A typo replacing
        // one kind with an aliased neighbour in `language_bash.rs`
        // (e.g., `ExpansionBody` instead of `Expansion`) would leave
        // the corresponding wrapping string counted as an operand and
        // shift the totals.
        //
        // expected: operands across the four lines —
        //   line 1 `a="$v"`: var_name `a`, simple_expansion `$v` (its
        //     inner var_name `v` leaf is suppressed under #695; wrapper
        //     skipped) → 2
        //   line 2 `b="${v[0]}"`: var_name `b`, var_name `v` (inside
        //     subscript — parent is `expansion`, not `simple_expansion`,
        //     so it still counts), number `0` (wrapper skipped,
        //     `expansion` itself is not in the operand list) → 3
        //   line 3 `c="$(date)"`: var_name `c`, the `word` `date` under
        //     the `command_name` (wrapper skipped, `command_substitution`
        //     not in operand list, and since #1351 the `command_name`
        //     wrapper is not either) → 2
        //   line 4 `d="$((1+2))"`: var_name `d`, numbers `1` and `2`
        //     (wrapper skipped, `arithmetic_expansion` not in operand
        //     list) → 3
        // Unique operands: a, b, c, d, $v, v, 0, date, 1, 2 → 10. Total
        // occurrences: 10 (`v` appears once — only line 2's subscript
        // leaf; line 1's `$v` inner leaf is suppressed — and `date` once,
        // as the `word`; before #1351 the `command_name` wrapping it
        // added a second `date` and N2 was 11). Operators after
        // #695: only the openers `[` (folded `[]`) and `+`, plus `=` four
        // times — the `}`/`)`/`))`/`]` closers no longer count.
        check_metrics::<BashParser>(
            "a=\"$v\"\nb=\"${v[0]}\"\nc=\"$(date)\"\nd=\"$((1+2))\"\n",
            "foo.sh",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 3);
                assert_eq!(metric.halstead.total_operators(), 6);
                assert_eq!(metric.halstead.unique_operands(), 10);
                assert_eq!(metric.halstead.total_operands(), 10);
            },
        );
    }

    /// Regression for #695. A bare `$x` (outside any string) parses as a
    /// `simple_expansion` wrapping a `variable_name` leaf — and `$?` / `$1`
    /// as a `simple_expansion` wrapping a `special_variable_name` leaf. Both
    /// the wrapper and the inner leaf used to be classified as operands, so
    /// each bare variable reference double-counted (the same hazard Tcl
    /// guards with its `Id2` exclusion and iRules with a parent check). The
    /// `variable_name` / `special_variable_name` arm now yields `Unknown`
    /// when its parent is a `simple_expansion`, so `$x` contributes exactly
    /// one operand while the assignment LHS `variable_name` (`x` in `x=…`,
    /// parent is `variable_assignment`) still counts.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_bare_variable_no_double_count() {
        let source = "x=1\necho $x\necho $?\n";
        let path = PathBuf::from("foo.sh");
        let parser = BashParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        let bare_x = ops.operands.iter().filter(|o| o.as_str() == "$x").count();
        let special = ops.operands.iter().filter(|o| o.as_str() == "$?").count();
        // Each bare reference is exactly one operand; the inner leaf is not
        // double-counted. If the guard regressed, the inner `variable_name`
        // `x` would add a second `x` occurrence (text-colliding with the
        // assignment LHS) and the inner `special_variable_name` `?` would
        // appear as a standalone `?` operand.
        assert_eq!(
            bare_x, 1,
            "bare $x must be one operand; operands were {:?}",
            ops.operands
        );
        assert_eq!(
            special, 1,
            "bare $? must be one operand; operands were {:?}",
            ops.operands
        );
        assert!(
            !ops.operands.iter().any(|o| o.as_str() == "?"),
            "the inner special_variable_name `?` leaf must be suppressed; operands were {:?}",
            ops.operands
        );
        // The assignment LHS `variable_name` `x` (parent `variable_assignment`,
        // not `simple_expansion`) must still be an operand.
        assert!(
            ops.operands.iter().any(|o| o.as_str() == "x"),
            "assignment LHS `x` must still be an operand; operands were {:?}",
            ops.operands
        );
    }

    /// Drives one row of a Bash wrapper/leaf double-count table: a grammar
    /// wrapper whose entire contribution to `N2` was its single,
    /// already-counted child (`command_name`, #1351; `translated_string`,
    /// #1358).
    ///
    /// `expected` is the post-fix `[n1, N1, n2, N2]`. `(n2_before,
    /// N2_before)` is what the same source scored while `wrapper` was still
    /// classified as an operand. Both columns are checked against the
    /// *current* parse under the model "one spurious operand per wrapper
    /// node" — they are not measured against the old code, which no longer
    /// exists to run:
    ///
    /// - `N2_before - N2` must equal the number of `wrapper` nodes. That
    ///   identity *is* the defect: one spurious operand per wrapper.
    /// - `n2_before` must equal the post-fix operand vocabulary unioned
    ///   with the wrapper spellings. It exceeds `n2` wherever the wrapper's
    ///   whole text is not already an operand in its own right — either
    ///   because it differs from its single child's (`"$cmd"`, `${cmd}`,
    ///   `$"ls"`) or because it spans several (`foo$x`, `$(which ls)`,
    ///   `{1..3}`).
    ///
    /// So a mistyped or stale column fails rather than misinforming the next
    /// reader — one did, during review of #1351 — but neither check can
    /// catch a *production* regression, because both hold whatever
    /// `get_op_type` answers. `assert_halstead_counts` below is the only
    /// assertion here that fails when the wrapper arm comes back; measured
    /// by neutralising it under the pre-fix arm, which leaves both tables
    /// green.
    #[cfg(feature = "bash")]
    #[track_caller]
    fn assert_bash_wrapper_sheds_one_operand(
        source: &str,
        expected: [u64; 4],
        (n2_before, total_before): (u64, u64),
        wrapper: Bash,
    ) {
        let name: &'static str = wrapper.clone().into();
        let kind = wrapper as u16;
        let code = source.as_bytes();
        let parser = BashParser::new(code.to_vec(), &PathBuf::from("foo.sh"), None);
        let spellings: Vec<&str> = parser
            .root()
            .preorder()
            .filter(|node| node.kind_id() == kind)
            .filter_map(|node| node.utf8_text(code))
            .collect();
        assert!(
            !spellings.is_empty(),
            "row {source:?} parses without a {name}, so it witnesses nothing",
        );
        // Phrased as an addition rather than `total_before - expected[3]`: a
        // future edit that inverts the two would underflow `u64` and panic
        // with a raw overflow message instead of the one below.
        assert_eq!(
            total_before,
            expected[3] + spellings.len() as u64,
            "row {source:?} must shed exactly one operand per {name}; \
             recorded N2_before {total_before}",
        );

        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        let mut vocabulary: HashSet<&str> = ops.operands.iter().map(String::as_str).collect();
        vocabulary.extend(spellings);
        assert_eq!(
            vocabulary.len() as u64,
            n2_before,
            "row {source:?}: n2 before the fix is the post-fix vocabulary \
             plus the {name} spellings; got {vocabulary:?}",
        );

        assert_halstead_counts::<BashParser>(source, "foo.sh", expected, source);
    }

    /// Regression for #1351, the command-name sibling of #695's bare
    /// `$x`. `command_name` is a pure wrapper: the grammar gives it
    /// exactly one required child (a `_primary_expression` or a
    /// `concatenation`) and it adds no text of its own, so classifying it
    /// as an operand *and* letting the walk reach the child counted every
    /// command name twice in `N2`.
    ///
    /// The table is the grammar-dispatch §6 evidence that deleting the arm
    /// zeroes nothing: it names every kind `command_name` can wrap, and in
    /// every row the command name still contributes at least one operand
    /// once the trailing `arg` is discounted.
    ///
    /// `n2_before` / `N2_before` are what each row scores with the
    /// `command_name` arm restored *against today's tree*, not a historical
    /// measurement — the `$"ls" arg` row has since lost a
    /// `translated_string` wrapper to #1358 as well.
    /// `assert_bash_wrapper_sheds_one_operand` re-derives both from the
    /// current parse rather than trusting them.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_command_name_wrapper_no_double_count() {
        // (source, [n1, N1, n2, N2], (n2_before, N2_before))
        let cases: [(&str, [u64; 4], (u64, u64)); 14] = [
            // word
            ("ls bar\n", [0, 0, 2, 2], (2, 3)),
            // number
            ("1 arg\n", [0, 0, 2, 2], (2, 3)),
            // string, inert
            ("\"ls\" arg\n", [0, 0, 2, 2], (2, 3)),
            // string wrapping an expansion: the wrapper string is already
            // skipped (#180), so before #1351 the `command_name` was the
            // only thing counting the quoted spelling — which also planted
            // a spurious `"$cmd"` entry in n2 beside `$cmd`.
            ("\"$cmd\" arg\n", [0, 0, 2, 2], (3, 3)),
            // raw_string
            ("'ls' arg\n", [0, 0, 2, 2], (2, 3)),
            // ansi_c_string
            ("$'ls' arg\n", [0, 0, 2, 2], (2, 3)),
            // translated_string. Two wrappers stacked here — `command_name`
            // over `translated_string` — so the pre-#1351 column below is
            // measured against a tree #1358 has already thinned to
            // `"ls"` + `arg`.
            ("$\"ls\" arg\n", [0, 0, 2, 2], (3, 3)),
            // simple_expansion
            ("$cmd arg\n", [0, 0, 2, 2], (2, 3)),
            // brace expansion: counts through its inner `variable_name`,
            // whose `SimpleExpansion` parent guard does not apply here.
            ("${cmd} arg\n", [0, 0, 2, 2], (3, 3)),
            // command_substitution: counts through the nested command.
            // Two command names here — the outer one and `which`.
            ("$(which ls) arg\n", [0, 0, 3, 3], (4, 5)),
            // process_substitution, likewise two command names.
            ("<(ls) arg\n", [0, 0, 2, 2], (3, 4)),
            // arithmetic_expansion
            ("$((1+1)) arg\n", [1, 1, 2, 3], (3, 4)),
            // brace_expression
            ("{1..3} arg\n", [1, 1, 3, 3], (4, 4)),
            // concatenation
            ("foo$x arg\n", [0, 0, 3, 3], (4, 4)),
        ];
        for (source, expected, before) in cases {
            assert!(
                expected[3] > 1,
                "row {source:?} must leave the command name at least one \
                 operand beside `arg`; a zero here means the deleted arm \
                 was load-bearing for this spelling",
            );
            assert_bash_wrapper_sheds_one_operand(source, expected, before, Bash::CommandName);
        }
    }

    /// Regression for #1358, the sibling of #1351 in the same `match`.
    /// `translated_string: $ => seq('$', $.string)` carries exactly one
    /// required `string` child and no text of its own beyond the `$`, so
    /// classifying the wrapper *and* letting the walk reach the child
    /// counted every `$"…"` twice in `N2`.
    ///
    /// The rows assert the total, `N2`. `n2` alone cannot witness this
    /// double count: the wrapper and its child spell *different* text
    /// (`$"x"` against `"x"`), so the pre-fix tree split one operand into
    /// two vocabulary entries rather than repeating one — which is why the
    /// `n2_before` column is carried too, and checked against the wrapper
    /// spellings the row actually parses to.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_translated_string_wrapper_no_double_count() {
        // (source, [n1, N1, n2, N2], (n2_before, N2_before))
        let cases: [(&str, [u64; 4], (u64, u64)); 7] = [
            // Assignment RHS.
            ("a=$\"x\"\n", [1, 1, 2, 2], (3, 3)),
            // Empty translated string. The grammar makes the inner `string`
            // required, so the wrapper is never childless — the condition
            // grammar-dispatch §6 warns that deletion would regress.
            ("a=$\"\"\n", [1, 1, 2, 2], (3, 3)),
            // The one spelling the deleted arm *was* load-bearing for: the
            // inner `string` wraps an operandless brace `expansion`, so the
            // whole `$"…"` now scores zero. That is #1351's residue one
            // level down rather than a new gap — a plain `a="${#}"` already
            // scored `[1, 1, 1, 1]` — and
            // `bash_translated_string_scores_alike_in_both_positions` pins
            // that both positions agree on it.
            ("a=$\"${#}\"\n", [1, 1, 1, 1], (2, 2)),
            // `${!}` is the same residue plus a `!`, which the operator arm
            // counts; it must not turn into an operand along the way.
            ("a=$\"${!}\"\n", [2, 2, 1, 1], (2, 2)),
            // `case` subject.
            ("case $\"y\" in *) ;; esac\n", [4, 4, 1, 1], (2, 2)),
            // Command-name position, where #1351's wrapper stacks on top of
            // this one; the `_before` columns here price the
            // `translated_string` alone.
            ("$\"ls\" arg\n", [0, 0, 2, 2], (3, 3)),
            // Interpolating form. `bash_string_has_expansion` inspects the
            // node's own children, and a `translated_string` has only `$`
            // and `string`, so it never saw the `simple_expansion` one level
            // down: the wrapper reintroduced exactly the double count #180
            // removed, for the `$"…"` spelling alone. Only `$y` and `b` may
            // survive.
            ("b=$\"$y\"\n", [1, 1, 2, 2], (3, 3)),
        ];
        for (source, expected, before) in cases {
            assert_bash_wrapper_sheds_one_operand(source, expected, before, Bash::TranslatedString);
        }
    }

    /// The load-bearing half of #1358's grammar-dispatch §6 argument, which
    /// nothing else asserts. In ordinary argument position the grammar emits
    /// no `translated_string` at all — just a `$` token and a `string` — so
    /// the `string` is the node present for *every* spelling, and dropping
    /// the wrapper makes the wrapper-bearing positions agree with argument
    /// position rather than newly disagree. If a grammar bump starts
    /// emitting the wrapper here, the deletion has to be re-derived.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_translated_string_scores_alike_in_both_positions() {
        // `${#}` carries the residue: it contributes no operand of its own,
        // so the second row pins that the deletion left *both* positions at
        // zero rather than only the wrapper-bearing one.
        //
        // Only the command-name half moves under the pre-fix arm; the
        // argument-position half is the reference the parity is measured
        // against, and `cmd $"…"` is asserted nowhere else. Measured — with
        // the argument assertions dropped this test still fails pre-fix,
        // with the command-name ones dropped it passes — so do not
        // "simplify" it down to the failing half.
        for (spelling, expected) in [("$\"hi\"", [0, 0, 2, 2]), ("$\"${#}\"", [0, 0, 1, 1])] {
            let as_command_name = format!("{spelling} arg\n");
            let as_argument = format!("cmd {spelling}\n");
            let parse = |source: &str| {
                BashParser::new(source.as_bytes().to_vec(), &PathBuf::from("foo.sh"), None)
            };
            assert!(
                !ast_has_kind_id(&parse(&as_argument), Bash::TranslatedString as u16),
                "argument position must still parse {spelling} as a bare `$` \
                 plus a `string`; a grammar bump that emits the wrapper here \
                 invalidates the parity this test rests on",
            );
            assert!(
                ast_has_kind_id(&parse(&as_command_name), Bash::TranslatedString as u16),
                "command-name position must still emit the wrapper, or the \
                 pair witnesses nothing",
            );
            assert_halstead_counts::<BashParser>(
                &as_command_name,
                "foo.sh",
                expected,
                &as_command_name,
            );
            assert_halstead_counts::<BashParser>(&as_argument, "foo.sh", expected, &as_argument);
        }
    }

    /// Pins the one residue of #1351: a brace `expansion` with no
    /// `variable_name` leaf. `${#}` (positional-parameter count) and `${!}`
    /// (last background PID) hold only anonymous tokens, and
    /// `Bash::Expansion` is not an operand, so the whole expansion
    /// contributes nothing.
    ///
    /// That was already true in *argument* position before the fix, which
    /// is the reason grammar-dispatch §6's gate-don't-delete rule did not
    /// apply to the `command_name` arm: deleting it made command-name
    /// position agree with argument position rather than newly disagree.
    /// The parity is the load-bearing half of that argument and nothing
    /// else asserts it, so if a future arm starts classifying these the
    /// two positions have to move together.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_operandless_expansion_scores_alike_in_both_positions() {
        // `${!}` carries a `!`, which the operator arm counts; `${#}`'s `#`
        // is not an operator. Both positions must agree per spelling.
        for (spelling, expected) in [("${#}", [0, 0, 1, 1]), ("${!}", [1, 1, 1, 1])] {
            let as_command_name = format!("{spelling} arg\n");
            let as_argument = format!("cmd {spelling}\n");
            assert_halstead_counts::<BashParser>(
                &as_command_name,
                "foo.sh",
                expected,
                &as_command_name,
            );
            assert_halstead_counts::<BashParser>(&as_argument, "foo.sh", expected, &as_argument);
        }
    }

    /// Drift marker for #1351 (lesson 34 / grammar-dispatch §2). `_concat`
    /// (`Bash::Concat`) is a hidden zero-width external token the scanner
    /// emits between `concatenation` parts; the parser never surfaces it as
    /// a node, and it spells no operand, so `BashCode::get_op_type` lists
    /// neither it nor the visible `concatenation` wrapper. If a grammar
    /// bump starts emitting it, this fails and the classification must be
    /// re-derived rather than assumed still absent.
    ///
    /// Measured, not assumed: putting `Bash::Concat` back in the operand
    /// arm fails no test in the suite, because the token is unreachable.
    /// Unreachability is the only coverage such an arm can have, which is
    /// why this test asserts it directly instead of asserting a count.
    #[cfg(feature = "bash")]
    #[test]
    fn bash_hidden_concat_token_is_unreachable() {
        let source = "a=foo$x\nb=pre\"$y\"post\ncmd bar$z\n";
        let path = PathBuf::from("foo.sh");
        let parser = BashParser::new(source.as_bytes().to_vec(), &path, None);
        // Non-vacuity: the visible `concatenation` this source is written
        // to produce must actually be in the parse, so the negative below
        // is about `_concat` and not about a source that concatenates
        // nothing.
        assert!(
            ast_has_kind_id(&parser, Bash::Concatenation as u16),
            "expected a visible `concatenation` node in the parse",
        );
        assert!(
            !ast_has_kind_id(&parser, Bash::Concat as u16),
            "the hidden `_concat` token surfaced; re-derive its \
             classification in BashCode::get_op_type against the new grammar",
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_operators_and_operands() {
        check_metrics::<TclParser>(
            "proc f {a b} {
    set x [expr {$a + $b}]
    if {$x > 0 && $x != 0} {
        return $x
    }
    return 0
}",
            "foo.tcl",
            |metric| {
                // Anchored per the snapshot policy in AGENTS.md, which
                // this call predates. Operators `proc`, `set`, `[]`,
                // `{}`, `expr`, `+`, `if`, `>`, `&&`, `!=` → n1 = 10,
                // N1 = 14 (`{}` × 4 for the proc parameter list, the
                // proc body, the two `expr`/`if` conditions and the
                // `if` body — the `expr` braces are an `Expr`, the
                // bodies a `BracedWord`). Operands `f`, `a`, `b`, `x`,
                // `$a`, `$b`, `$x`, `0` and `return` → n2 = 9,
                // N2 = 14. Before #1354 the proc body and the `if`
                // body were operands too → 11 / 16.
                assert_eq!(metric.halstead.unique_operators(), 10);
                assert_eq!(metric.halstead.total_operators(), 14);
                assert_eq!(metric.halstead.unique_operands(), 9);
                assert_eq!(metric.halstead.total_operands(), 14);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_bitwise_ternary_string_ops() {
        // Exercises operator families not covered by tcl_operators_and_operands:
        // bitwise (&, |, ^, ~, <<, >>), ternary (?), and string-comparison (eq, ne, in, ni).
        check_metrics::<TclParser>(
            "proc f {a b} {
    set bits [expr {$a & $b | $a ^ ~$b}]
    set sh [expr {$a << 1 | $b >> 1}]
    set t [expr {$a > 0 ? $a : $b}]
    if {$a eq {x} || $a ne {y}} {
        return $a
    }
    return $b
}",
            "foo.tcl",
            |metric| {
                // Anchored per the snapshot policy in AGENTS.md, which
                // this call predates. N1 fell 33 → 31 with #1314: the
                // `if` condition's `{x}` and `{y}` are braced *words*,
                // so their openers stopped fabricating a `{}` operator.
                // n1 is unchanged at 18 because the `{}` entry survives
                // on the proc body and the `expr` braces — which is
                // exactly why the fabrication was invisible in n1 and
                // is the reason to assert N1 as well (#1294).
                //
                // The operand columns fell 17 / 30 → 13 / 26 with
                // #1354, and the operator columns did not move: the two
                // script bodies (the proc's and the `if`'s) stopped
                // being operands, and the `x` / `y` inside the braced
                // words `{x}` and `{y}` are now part of the one operand
                // each word contributes.
                assert_eq!(metric.halstead.unique_operators(), 18);
                assert_eq!(metric.halstead.total_operators(), 31);
                assert_eq!(metric.halstead.unique_operands(), 13);
                assert_eq!(metric.halstead.total_operands(), 26);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_array_reference_bills_the_reference_and_the_index() {
        // `$arr($i)` is the reference plus the index Tcl substitutes
        // inside the parens, and `arr(k)` as a `set` target is the name
        // plus the literal index; the `array_index` wrapper is neither.
        // The quoted spelling is deliberate — the vendored grammar
        // mis-parses a bare `$arr(k)` in command-word position. Pinned
        // per dialect and as a parity in `tests/parity/`, because the
        // iRules twin listed the wrapper as a third operand.
        assert_ops_operands::<TclParser>(
            "set arr(k) 1\nset z \"$arr($i)\"\n",
            "foo.tcl",
            6,
            vec!["arr", "k", "1", "z", "$arr($i)", "$i"],
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_bare_variable_operand() {
        // Bare `$varname` produces a VariableSubstitution node (already an operand).
        // Its anonymous Id2 child must NOT be counted separately; each reference is 1 operand.
        check_metrics::<TclParser>(
            "proc f {x} {
    return $x
}",
            "foo.tcl",
            |metric| {
                // Anchored per the snapshot policy in AGENTS.md, which
                // this call predates. Operators `proc` and `{}` × 2
                // (the parameter list and the body) → n1 = 2, N1 = 3.
                // Operands `f`, the parameter `x`, `return` and `$x` —
                // one occurrence each, so a re-counted `x` leaf inside
                // `$x` would show up in N2 even though it collides with
                // the parameter in n2. Before #1354 the proc body was a
                // fifth operand.
                assert_eq!(metric.halstead.unique_operators(), 2);
                assert_eq!(metric.halstead.total_operators(), 3);
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 4);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_inert_quoted_word_counts_as_operand() {
        // Regression for #277. A `"..."` literal with no `$var` / `[cmd]`
        // interpolation must contribute exactly one operand (the wrapping
        // `QuotedWord`). The string content `hello world` is exposed as a
        // single `_quoted_word_content` token (not itself classified by
        // `get_op_type`), so the only operands here are `f`, `s`, and the
        // quoted string. `set` is the anonymous `Set2` keyword and is
        // classified as an operator, not an operand.
        check_metrics::<TclParser>(
            "proc f {} {
    set s \"hello world\"
}",
            "foo.tcl",
            |metric| {
                // Operands: `f`, the `set` target `s`, `"hello world"` —
                // 3 unique, 3 total. Before #1294 this read 3/3 for a
                // different reason, with `s` missing and the proc-body
                // `braced_word` making the count coincidentally
                // plausible; #1354 removed that body operand, so the
                // three named here are now the whole list. The wrapping
                // `QuotedWord` must still contribute exactly one operand
                // when it carries no interpolation children; dropping to 2
                // would mean the inert case was over-guarded.
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 3);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_interpolated_quoted_word_no_double_count() {
        // Regression for #277. Before the fix, `"$x is $y"` produced an
        // extra operand for the wrapping `QuotedWord` on top of the two
        // inner `VariableSubstitution` operands (`$x`, `$y`), giving 7.
        // After the fix, the wrapper is `TokenRole::Unknown` whenever
        // it carries an interpolation child, so operand attribution
        // belongs solely to the inner substitutions.
        check_metrics::<TclParser>(
            "proc f {x y} {
    set s \"$x is $y\"
}",
            "foo.tcl",
            |metric| {
                // Operands: `f`, `x`, `y` (proc args), the `set` target
                // `s`, `$x`, `$y` — 6 unique, 6 total. The wrapping
                // `QuotedWord` contributes nothing, and since #1354
                // neither does the proc-body `braced_word`. Before #277
                // the wrapper double-counted.
                assert_eq!(metric.halstead.unique_operands(), 6);
                assert_eq!(metric.halstead.total_operands(), 6);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_command_substitution_quoted_word_no_double_count() {
        // Regression for #277. A `"...[cmd]..."` literal exposes the
        // bracketed command as a `command_substitution` child whose inner
        // identifiers/literals contribute their own operands. The wrapping
        // `QuotedWord` must not also be classified as an operand, or the
        // command's identifier would be counted alongside a phantom
        // wrapper operand.
        check_metrics::<TclParser>(
            "proc f {} {
    set s \"result: [foo]\"
}",
            "foo.tcl",
            |metric| {
                // Operands: `f`, the `set` target `s`, `foo` — 3 unique,
                // 3 total. The wrapping `QuotedWord` and the inert text
                // `result: ` do not contribute extra operands, and since
                // #1354 neither does the proc-body `braced_word`. Before
                // #277 the wrapper double-counted.
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 3);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    /// Regression for #1294. The `set` target parses as the anonymous
    /// `id` token (`Tcl::Id2`) — the same kind as the leaf inside a
    /// `variable_substitution` — and the getter used to exclude that kind
    /// wholesale, so every variable a Tcl script assigned was absent from
    /// n2/N2. The guard is now parent-scoped: a target `id` counts, a
    /// var-sub leaf does not. Exact occurrence counts distinguish this
    /// fix from a regression in either direction: a re-blanketed
    /// exclusion drops `s`/`t` (total 2), while losing the guard
    /// double-counts the `$s` leaf as a second `s` (total 5).
    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_set_target_is_operand() {
        let source = "set s 1\nset t $s\n";
        let path = PathBuf::from("foo.tcl");
        let parser = TclParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        // expected operands: targets `s` and `t`, literal `1`, reference
        // `$s` (wrapper only) — 4 total, each exactly once.
        for operand in ["s", "t", "1", "$s"] {
            assert_eq!(
                ops.operands
                    .iter()
                    .filter(|o| o.as_str() == operand)
                    .count(),
                1,
                "`{operand}` must be exactly one operand; operands were {:?}",
                ops.operands
            );
        }
        assert_eq!(
            ops.operands.len(),
            4,
            "operands must be exactly s, t, 1, $s; got {:?}",
            ops.operands
        );

        check_metrics::<TclParser>(source, "foo.tcl", |metric| {
            // expected: n2 = 4 (s, t, 1, $s), N2 = 4; operators are the
            // two `set` keywords — n1 = 1, N1 = 2.
            assert_eq!(metric.halstead.unique_operands(), 4);
            assert_eq!(metric.halstead.total_operands(), 4);
            assert_eq!(metric.halstead.unique_operators(), 1);
            assert_eq!(metric.halstead.total_operators(), 2);
        });
    }

    /// Drift marker for #1294 (lesson 34 / grammar-dispatch §2): the
    /// *named* `id` rule (`Tcl::Id`, kind_id 84) never surfaces at the
    /// pinned tree-sitter-tcl — the parser emits the anonymous `Id2` in
    /// both positions the getter guards (the `set` target and the
    /// var-sub leaf). The `Tcl::Id` arm in `get_op_type` is therefore
    /// defensive; if a grammar bump starts emitting 84 this fails and
    /// the arm's classification must be re-derived instead of trusted.
    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_named_id_variant_is_unreachable() {
        let source = "proc f {x} {\n    set s $x\n    foreach v {1 2} { puts \"$v\" }\n}\n";
        let path = PathBuf::from("foo.tcl");
        let parser = TclParser::new(source.as_bytes().to_vec(), &path, None);
        // Non-vacuity: the anonymous token must be present in this parse
        // (both the `set` target and the `$x` / `$v` leaves emit it).
        assert!(
            ast_has_kind_id(&parser, Tcl::Id2 as u16),
            "expected the anonymous Tcl::Id2 token to appear in the parse",
        );
        assert!(
            !ast_has_kind_id(&parser, Tcl::Id as u16),
            "the named Tcl::Id rule surfaced; re-derive the defensive \
             `Tcl::Id` arm in TclCode::get_op_type against the new grammar",
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_braced_word_delimiter_is_not_an_operator() {
        // Regression: issue #1314, the Tcl sibling of Elixir #1256 and
        // Ruby/Perl #1312. A braced *word* — a literal value, not a
        // script — carries its `{` as an `LBRACE` child, the kind id a
        // real block uses, so `set a {braced word}` reported a `{}`
        // operator with no block in the source.
        //
        // expected: operator `set` × 3 → n1 = 1, N1 = 3. Operands
        // `a`, `b`, `c`, `$a` and `{braced word}` × 2 → n2 = 5,
        // N2 = 6. Before the guard the two openers added `{}` →
        // n1 = 2, N1 = 5; before #1354 the inner `braced` / `word`
        // counted alongside the word containing them → n2 = 7,
        // N2 = 10.
        check_metrics::<TclParser>(
            "set a {braced word}\nset b {braced word}\nset c $a\n",
            "foo.tcl",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 1);
                assert_eq!(metric.halstead.total_operators(), 3);
                assert_eq!(metric.halstead.unique_operands(), 5);
                assert_eq!(metric.halstead.total_operands(), 6);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_script_bodies_keep_their_braces() {
        // Control for #1314, and the reason a kind-scoped guard is safe
        // in Tcl where it would not be elsewhere: the grammar gives the
        // literal and the block *different* kinds. A `proc` body, an
        // `if` body and an `if` condition are `BracedWord` (88) and
        // `Expr` (97); only the value form is `BracedWordSimple` (89).
        // This fixture nests a braced word inside a real script body,
        // so a guard that keyed on the brace alone would drop the
        // block's `{}` and fail here.
        //
        // expected: operators `proc`, `set` × 2, `if`, `>`, and `{}`
        // × 4 (the proc parameter list, the proc body, the `if`
        // condition, the `if` body) → n1 = 5, N1 = 9. Operands, all
        // distinct → n2 = N2 = 8: `p`, `x`, `a`, `$x`, `1`, `b` and
        // the two braced *words* `{v w}` and `{y}`, each one operand
        // rather than one per inner word.
        //
        // Before #1354 this read 13 / 13. The five extra entries were
        // the inner words `v`, `w`, `y` and the two *script* bodies,
        // which were `BracedWord` operands in their own right — so a
        // block counted twice over, once as the operand and once as
        // the `{}` operator this test is about. Both halves are gone;
        // the operator columns are what this test guards and they did
        // not move.
        check_metrics::<TclParser>(
            "proc p {x} {\n  set a {v w}\n  if {$x > 1} { set b {y} }\n}\n",
            "foo.tcl",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 5);
                assert_eq!(metric.halstead.total_operators(), 9);
                assert_eq!(metric.halstead.unique_operands(), 8);
                assert_eq!(metric.halstead.total_operands(), 8);
            },
        );
    }

    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_braced_word_guard_is_parent_scoped_not_ancestor_scoped() {
        // The input that separates the parent-scoped guard from the
        // ancestor-scanning mutant. I first recorded this distinction
        // as *unobservable* in Tcl, reasoning that a braced word holds
        // only simple words and nested braced words. `bca dump` says
        // otherwise: the grammar parses a `[…]` command substitution
        // inside a braced word, and the `if` inside it brings an `Expr`
        // condition and a `BracedWord` body, each with its own `{`,
        // both of them non-immediate descendants of the
        // `BracedWordSimple`. An ancestor scan swallows both.
        //
        // (Real Tcl does not substitute inside braces — this is the
        // grammar modelling structure it will not evaluate. What the
        // classifier sees is what the metric reports, so it is the
        // right fixture regardless.)
        //
        // expected: operators `set`, `[]`, `if`, and `{}` × 2 (the
        // `if` condition's `Expr` and its `BracedWord` body; the outer
        // value word's own `{` is suppressed) → n1 = 4, N1 = 5.
        // Operands `z`, the whole braced word, and `$q` / `puts` / `w`
        // from inside the command substitution → n2 = N2 = 5. Under
        // the ancestor-scoped mutant both surviving braces vanish:
        // n1 = 3, N1 = 3.
        //
        // #1354 widened the guard from the `{` alone to every direct
        // child of the braced word, which is why `x` and `v` are no
        // longer operands and the nested script body no longer is
        // either. It did not change the *scope*: the three operands
        // from inside the command substitution are grandchildren, and
        // an ancestor-scoped guard would drop them too.
        check_metrics::<TclParser>("set z {x [if {$q} {puts w}] v}\n", "foo.tcl", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 4);
            assert_eq!(metric.halstead.total_operators(), 5);
            assert_eq!(metric.halstead.unique_operands(), 5);
            assert_eq!(metric.halstead.total_operands(), 5);
        });
    }

    #[cfg(feature = "irules")]
    #[test]
    fn irules_braced_word_guard_is_parent_scoped_not_ancestor_scoped() {
        // The iRules twin of the test above — the two getters are
        // clones, so the mutant must fail in both.
        //
        // expected: operators `when`, `set`, `[]`, `if`, `{}` × 3 (the
        // handler body, the `if` condition and the `if` body) → n1 = 5,
        // N1 = 7. Operands `HTTP_REQUEST`, `z`, the whole braced word,
        // and `$q` / `log` / `w` from inside the command substitution →
        // n2 = N2 = 6 (10 before #1354, which also took the direct
        // children `x` / `v` and the two script bodies out of the
        // operand set without moving the operator columns this test
        // guards).
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST {\n  set z {x [if {$q} {log w}] v}\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 5);
                assert_eq!(metric.halstead.total_operators(), 7);
                assert_eq!(metric.halstead.unique_operands(), 6);
                assert_eq!(metric.halstead.total_operands(), 6);
            },
        );
    }

    /// How one dialect of the Tcl family spells the braced-word
    /// construct. The two grammars are deliberate clones with different
    /// id blocks, so #1354's guard is derived once and instantiated
    /// twice — and a fix that landed in only one dialect fails the
    /// second instantiation rather than going unnoticed.
    struct BracedWordKinds {
        /// `braced_word_simple`, the literal *value* form the guard
        /// keys on.
        wrapper: u16,
        /// `braced_word`, the *script* form #1354 gated on holding a
        /// command: an operand only when it holds none.
        script_body: u16,
        /// `comment`, the one named child of a script that is not a
        /// command and that the gate must not mistake for one.
        comment: u16,
        /// Every named kind node-types.json admits directly inside
        /// `wrapper`. A child outside this set means the grammar moved
        /// and the parent-keyed arm has to be re-derived
        /// (grammar-dispatch §1).
        children: [u16; 6],
        /// The `{` / `}` the wrapper also holds. Suppressing the opener
        /// was the whole of #1314's narrower guard; the closer has
        /// never been classified, since `get_operator_id_as_str` folds
        /// the pair to one `{}` glyph.
        delimiters: [u16; 2],
        /// Of `children`, the three the operand arm classified
        /// unconditionally before the guard.
        operand_children: [u16; 3],
        /// `quoted_word`, which was an operand only when *inert* —
        /// `string_operand_type`'s own rule, replicated here so the
        /// shed count below is what `N2` actually shed.
        quoted_word: u16,
        /// The interpolation kinds that decide that.
        interpolation: [u16; 2],
    }

    #[cfg(feature = "tcl")]
    const TCL_BRACED_WORD_KINDS: BracedWordKinds = BracedWordKinds {
        wrapper: Tcl::BracedWordSimple as u16,
        script_body: Tcl::BracedWord as u16,
        comment: Tcl::Comment as u16,
        children: [
            Tcl::SimpleWord as u16,
            Tcl::EscapedCharacter as u16,
            Tcl::QuotedWord as u16,
            Tcl::VariableSubstitution as u16,
            Tcl::CommandSubstitution as u16,
            Tcl::BracedWordSimple as u16,
        ],
        delimiters: [Tcl::LBRACE as u16, Tcl::RBRACE as u16],
        operand_children: [
            Tcl::SimpleWord as u16,
            Tcl::VariableSubstitution as u16,
            Tcl::BracedWordSimple as u16,
        ],
        quoted_word: Tcl::QuotedWord as u16,
        interpolation: [
            Tcl::VariableSubstitution as u16,
            Tcl::CommandSubstitution as u16,
        ],
    };

    #[cfg(feature = "irules")]
    const IRULES_BRACED_WORD_KINDS: BracedWordKinds = BracedWordKinds {
        wrapper: Irules::BracedWordSimple as u16,
        script_body: Irules::BracedWord as u16,
        comment: Irules::Comment as u16,
        children: [
            Irules::SimpleWord as u16,
            Irules::EscapedCharacter as u16,
            Irules::QuotedWord as u16,
            Irules::VariableSubstitution as u16,
            Irules::CommandSubstitution as u16,
            Irules::BracedWordSimple as u16,
        ],
        delimiters: [Irules::LBRACE as u16, Irules::RBRACE as u16],
        operand_children: [
            Irules::SimpleWord as u16,
            Irules::VariableSubstitution as u16,
            Irules::BracedWordSimple as u16,
        ],
        quoted_word: Irules::QuotedWord as u16,
        interpolation: [
            Irules::VariableSubstitution as u16,
            Irules::CommandSubstitution as u16,
        ],
    };

    /// The operand occurrences #1354 removed from `source`, as their
    /// source texts, plus the set of `braced_word_simple` child kinds
    /// the fixture witnessed.
    ///
    /// Walks with `for_each_node_with_chain`, which maintains the
    /// ancestor chain exactly as `spaces::compute` does, so "parent"
    /// here means what `Ancestors::parent` means inside the guard.
    /// Doubles as the grammar-dispatch §1 / §2 drift marker: a child of
    /// the wrapper outside `children` ∪ `delimiters` fails on the spot,
    /// which is what makes keying the arm on the parent alone — rather
    /// than on an enumerated child list — safe to rely on.
    #[cfg(any(feature = "irules", feature = "tcl"))]
    fn braced_word_shed<L: crate::LanguageInfo>(
        source: &str,
        kinds: &BracedWordKinds,
    ) -> (Vec<String>, HashSet<u16>) {
        let code = source.as_bytes();
        let mut shed = Vec::new();
        let mut witnessed = HashSet::new();
        for_each_node_with_chain::<L>(code, |node, chain| {
            let text = || {
                node.utf8_text(code)
                    .expect("fixture is valid UTF-8")
                    .to_owned()
            };
            // The script form was an operand of its own wherever it
            // appeared until #1354, which now gates it on holding a
            // command — a named child that is not a comment. This is not
            // a child of the wrapper, so it is counted before the parent
            // test below.
            if node.kind_id() == kinds.script_body
                && node
                    .children()
                    .any(|child| child.is_named() && child.kind_id() != kinds.comment)
            {
                shed.push(text());
            }
            if chain.last().is_none_or(|p| p.kind_id() != kinds.wrapper) {
                return;
            }
            assert!(
                kinds.children.contains(&node.kind_id())
                    || kinds.delimiters.contains(&node.kind_id()),
                "`{source}`: a `{}` inside a braced word is a child this guard \
                 was not derived against; re-read node-types.json before \
                 trusting it",
                node.kind(),
            );
            if kinds.children.contains(&node.kind_id()) {
                witnessed.insert(node.kind_id());
            }
            let was_operand = kinds.operand_children.contains(&node.kind_id())
                || (node.kind_id() == kinds.quoted_word && !node.wraps_any(&kinds.interpolation));
            if was_operand {
                shed.push(text());
            }
        });
        (shed, witnessed)
    }

    /// One row of the #1354 tables: a fixture, what it measures now,
    /// what it measured before, and the operand texts behind the counts.
    struct BracedWordCase {
        source: &'static str,
        /// `[n1, N1, n2, N2]` with the guard in place.
        counts: [u64; 4],
        /// `[n2, N2]` without it. Re-derived by the loop rather than
        /// trusted, so a stale row fails instead of misinforming.
        before: [u64; 2],
        operands: &'static [&'static str],
    }

    /// Every row is measured in *both* dialects, so a fix applied to
    /// one getter and not its clone fails here. `braced_word_shed`'s
    /// drift assertion likewise runs against both grammars.
    #[cfg(any(feature = "irules", feature = "tcl"))]
    fn check_braced_word_cases<T: crate::MetricSuite, L: crate::LanguageInfo>(
        cases: &[BracedWordCase],
        file: &str,
        kinds: &BracedWordKinds,
    ) -> HashSet<u16> {
        let mut witnessed = HashSet::new();
        for case in cases {
            let (shed, seen) = braced_word_shed::<L>(case.source, kinds);
            witnessed.extend(seen);

            // Phrased as an addition rather than a subtraction so a
            // future edit that inverts the two underflows nothing.
            assert_eq!(
                case.before[1],
                case.counts[3] + shed.len() as u64,
                "{file} `{}`: N2 must shed exactly one occurrence per \
                 previously-billed part; recorded {}, parts {shed:?}",
                case.source,
                case.before[1],
            );
            let mut vocabulary: HashSet<&str> = case.operands.iter().copied().collect();
            vocabulary.extend(shed.iter().map(String::as_str));
            assert_eq!(
                vocabulary.len() as u64,
                case.before[0],
                "{file} `{}`: n2 before the fix is the post-fix vocabulary \
                 plus those parts; got {vocabulary:?}",
                case.source,
            );

            assert_halstead_counts::<T>(case.source, file, case.counts, case.source);
            assert_ops_operands::<T>(
                case.source,
                file,
                case.operands.len(),
                case.operands.to_vec(),
            );
        }
        witnessed
    }

    /// The rows shared by both dialects: one per named child kind
    /// `braced_word_simple` admits, the childless spelling, the
    /// repeated-value row that separates `n2` from `N2` (#1294), and
    /// the braced/quoted parity pair #1317 asks for.
    #[cfg(any(feature = "irules", feature = "tcl"))]
    const BRACED_WORD_CASES: [BracedWordCase; 11] = [
        // simple_word, the reported fixture. Two words inside one
        // value scored two operands beside the value itself.
        BracedWordCase {
            source: "set x {literal here}\n",
            counts: [1, 1, 2, 2],
            before: [4, 4],
            operands: &["x", "{literal here}"],
        },
        // The childless spelling, and the reason the wrapper is kept
        // rather than dropped in favour of its contents
        // (grammar-dispatch §6): with nothing inside, the wrapper is
        // the empty string's only carrier. Nothing is shed here, so
        // this row asserts the two columns agree.
        BracedWordCase {
            source: "set y {}\n",
            counts: [1, 1, 2, 2],
            before: [2, 2],
            operands: &["y", "{}"],
        },
        // braced_word_simple inside braced_word_simple: the nesting
        // that makes the over-count unbounded in depth. One value
        // spelled six vocabulary entries.
        BracedWordCase {
            source: "set a {x {y z}}\n",
            counts: [1, 1, 2, 2],
            before: [6, 6],
            operands: &["a", "{x {y z}}"],
        },
        // quoted_word, inert — an operand in its own right elsewhere,
        // and shed here.
        BracedWordCase {
            source: "set a {x \"q w\" v}\n",
            counts: [1, 1, 2, 2],
            before: [5, 5],
            operands: &["a", "{x \"q w\" v}"],
        },
        // quoted_word carrying an interpolation, which was *not* an
        // operand before the guard either (`string_operand_type` had
        // already suppressed it) — so only `x` and `v` are shed. Its
        // `$q` is a grandchild of the braced word and still counts,
        // which is the parent-scoping this arm inherits from #1314.
        BracedWordCase {
            source: "set a {x \"$q\" v}\n",
            counts: [1, 1, 3, 3],
            before: [5, 5],
            operands: &["a", "$q", "{x \"$q\" v}"],
        },
        // escaped_character, never classified — so it sheds nothing
        // and the row measures the two `simple_word`s around it.
        BracedWordCase {
            source: "set a {x \\n y}\n",
            counts: [1, 1, 2, 2],
            before: [4, 4],
            operands: &["a", "{x \\n y}"],
        },
        // variable_substitution. Tcl substitutes nothing between
        // braces, so `{$x}` is the two-character string `$x` — the row
        // that makes "the wrapper is the value" more than a tie-break.
        BracedWordCase {
            source: "set a {$x}\n",
            counts: [1, 1, 2, 2],
            before: [3, 3],
            operands: &["a", "{$x}"],
        },
        // command_substitution, likewise never an operand itself. Its
        // interior is, and stays so: `$q`, `puts` and `w` are
        // grandchildren. The nested `{puts w}` is a *script* body and
        // sheds under the other half of #1354.
        BracedWordCase {
            source: "set z {x [if {$q} {puts w}] v}\n",
            counts: [4, 5, 5, 5],
            before: [8, 8],
            operands: &["z", "$q", "puts", "w", "{x [if {$q} {puts w}] v}"],
        },
        // The same value twice: n2 3 against N2 4, so a row that
        // asserted only the vocabulary could not tell the two axes
        // apart (#1294).
        BracedWordCase {
            source: "set a {b c}\nset d {b c}\n",
            counts: [1, 2, 3, 4],
            before: [5, 8],
            operands: &["a", "d", "{b c}"],
        },
        // The parity pair #1317 named: two spellings of one literal
        // value must score alike. They did not before — braced 4 / 4
        // against quoted 2 / 2 — which is the spelling sensitivity
        // #695, #1312 and #1314 each removed elsewhere.
        BracedWordCase {
            source: "set a {one two}\n",
            counts: [1, 1, 2, 2],
            before: [4, 4],
            operands: &["a", "{one two}"],
        },
        BracedWordCase {
            source: "set a \"one two\"\n",
            counts: [1, 1, 2, 2],
            before: [2, 2],
            operands: &["a", "\"one two\""],
        },
    ];

    /// The script half of #1354, shared by both dialects: a
    /// `braced_word` holding commands is a block whose contents the
    /// walk already counts, so it is no longer also an operand
    /// spanning the whole block.
    ///
    /// The three childless rows are the gate, and the reason this is a
    /// gate and not a deletion (grammar-dispatch §6). `braced_word` is
    /// not only the script kind: it is the value slot of every command
    /// the grammar does not special-case, where `lappend l {}` is an
    /// empty list whose brace pair is its only carrier. Deleting the
    /// kind scored that zero while its `lappend l ""` synonym — the
    /// last row, the control — scored one. An empty `proc` body is
    /// spelled identically and so also keeps an operand; #1318 tells
    /// the two roles apart by the enclosing command, but it bills them
    /// alike, so this gate is still what keeps the operand.
    ///
    /// The rows' *operator* columns moved with #1318 wherever the
    /// enclosing command takes a value, which is why the `lappend`
    /// rows here read `0` where the `proc` and `if` rows read the
    /// block's `{}`. The operand columns are untouched by it — #1318
    /// revises the brace and nothing else — so every `before` here
    /// still describes #1354 alone.
    #[cfg(any(feature = "irules", feature = "tcl"))]
    const SCRIPT_BODY_CASES: [BracedWordCase; 9] = [
        BracedWordCase {
            source: "proc p {} { set b 1 }\n",
            counts: [3, 4, 3, 3],
            before: [4, 4],
            operands: &["p", "b", "1"],
        },
        BracedWordCase {
            source: "proc p {} {}\n",
            counts: [2, 3, 2, 2],
            before: [2, 2],
            operands: &["p", "{}"],
        },
        // A comment is a named child of the script but not a command,
        // and no arm bills it, so a comment-only body scores like the
        // empty one above rather than like nothing: the block's whole
        // text is its one operand. Gating on "any named child" billed
        // it zero — adding a comment to an empty block lowered N2.
        BracedWordCase {
            source: "proc p {} {\n    # only a comment\n}\n",
            counts: [2, 3, 2, 2],
            before: [2, 2],
            operands: &["p", "{\n    # only a comment\n}"],
        },
        BracedWordCase {
            source: "if {$q} {\n    # noop\n}\n",
            counts: [2, 3, 2, 2],
            before: [2, 2],
            operands: &["$q", "{\n    # noop\n}"],
        },
        // The control: a comment *beside* a command changes nothing, so a
        // gate keyed on "contains a comment" would fail this row.
        BracedWordCase {
            source: "proc p {} {\n    # c\n    set b 1\n}\n",
            counts: [3, 4, 3, 3],
            before: [4, 4],
            operands: &["p", "b", "1"],
        },
        // The value-role twin: inside a literal string Tcl performs no
        // substitution, so `# x` is not a comment at all, and the word
        // is its one operand exactly as `lappend l {}` below is. Its
        // operator columns are zero since #1318 — `lappend` takes a
        // value, so the brace pair is a quote and not a block.
        BracedWordCase {
            source: "lappend l {\n    # x\n}\n",
            counts: [0, 0, 3, 3],
            before: [3, 3],
            operands: &["lappend", "l", "{\n    # x\n}"],
        },
        // A `braced_word` in *value* position — the #1318 role, where
        // the same kind carries a literal list. Its interior words
        // counted before #1354 and still do; what #1354 removed is the
        // whole-block operand that was double-billing them, and what
        // #1318 removed is the `{}` operator (`lappend` takes a value,
        // so the brace pair quotes rather than opens).
        BracedWordCase {
            source: "lappend l {a b}\n",
            counts: [0, 0, 4, 4],
            before: [5, 5],
            operands: &["lappend", "l", "a", "b"],
        },
        // …and the childless spelling of that value, which sheds
        // nothing: the brace pair is the empty list's only carrier.
        BracedWordCase {
            source: "lappend l {}\nreturn {}\n",
            counts: [0, 0, 4, 5],
            before: [4, 5],
            operands: &["lappend", "l", "return", "{}"],
        },
        // The control the row above is measured against: the quoted
        // spelling of the same empty value, which never depended on
        // the arm and must keep scoring one operand. Since #1318 the
        // two rows agree on all four columns rather than only on the
        // operand pair — an empty list is an empty list however it is
        // spelled.
        BracedWordCase {
            source: "lappend l \"\"\nreturn \"\"\n",
            counts: [0, 0, 4, 5],
            before: [4, 5],
            operands: &["lappend", "l", "return", "\"\""],
        },
    ];

    /// The table must exercise every named child kind the grammar
    /// admits inside a braced word, and no other — the other half of
    /// the drift marker in `braced_word_shed`, which can only police
    /// kinds a fixture actually produces.
    #[cfg(any(feature = "irules", feature = "tcl"))]
    fn assert_braced_word_children_witnessed(
        witnessed: &HashSet<u16>,
        kinds: &BracedWordKinds,
        dialect: &str,
    ) {
        let mut got: Vec<u16> = witnessed.iter().copied().collect();
        got.sort_unstable();
        let mut expected = kinds.children;
        expected.sort_unstable();
        assert_eq!(
            got.as_slice(),
            expected.as_slice(),
            "{dialect}: the fixtures must witness every child kind \
             node-types.json admits inside a braced word",
        );
    }

    /// Regression for #1354 and #1317. `braced_word_simple` is a
    /// literal value and `braced_word` a script, and both were
    /// operands *beside* the content the walk counts anyway: a braced
    /// word was billed once per inner word plus once for itself, and a
    /// block once for every command in it plus once for its whole
    /// text. `set x {literal here}` scored n2 4 / N2 4 for one value.
    /// The name is the invariant either way — the value's content is
    /// the literal, the script's is its commands, and each is billed
    /// once.
    ///
    /// Each row's `before` column is re-derived by the loop from the
    /// current parse rather than trusted. That derivation is a replica
    /// of the pre-#1354 arms and could in principle drift from what
    /// they did, so every column was also measured directly against a
    /// build of the old getters — `lappend l {a b}` at n2 5 / N2 5,
    /// `lappend l {}` at 4 / 5, `proc p {} {}` at 2 / 2 — rather than
    /// derived only from the model here.
    ///
    /// The same walk doubles as the drift marker for the parent-keyed
    /// arm: it fails if the grammar ever puts a seventh kind directly
    /// inside a braced word, and the union assertion below fails if a
    /// bump stops emitting one of the six.
    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_braced_word_bills_its_content_once_1354() {
        let mut witnessed = check_braced_word_cases::<TclParser, TclCode>(
            &BRACED_WORD_CASES,
            "foo.tcl",
            &TCL_BRACED_WORD_KINDS,
        );
        witnessed.extend(check_braced_word_cases::<TclParser, TclCode>(
            &SCRIPT_BODY_CASES,
            "foo.tcl",
            &TCL_BRACED_WORD_KINDS,
        ));
        assert_braced_word_children_witnessed(&witnessed, &TCL_BRACED_WORD_KINDS, "tcl");
    }

    /// The iRules twin. The tables are shared, so a fix that reached
    /// only `big-code-analysis-ast/src/getter/tcl.rs` fails every row
    /// here — the two getters are deliberate clones and #1354 names
    /// both.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_braced_word_bills_its_content_once_1354() {
        let mut witnessed = check_braced_word_cases::<IrulesParser, IrulesCode>(
            &BRACED_WORD_CASES,
            "foo.irule",
            &IRULES_BRACED_WORD_KINDS,
        );
        witnessed.extend(check_braced_word_cases::<IrulesParser, IrulesCode>(
            &SCRIPT_BODY_CASES,
            "foo.irule",
            &IRULES_BRACED_WORD_KINDS,
        ));
        // The `when` handler body is the iRules-only spelling of a
        // script body, and the largest instance of the defect: its
        // operand text was the entire event handler.
        let handlers: [BracedWordCase; 3] = [
            BracedWordCase {
                source: "when HTTP_REQUEST { set x 1 }\n",
                counts: [3, 3, 3, 3],
                before: [4, 4],
                operands: &["HTTP_REQUEST", "x", "1"],
            },
            BracedWordCase {
                source: "when HTTP_REQUEST {}\n",
                counts: [2, 2, 2, 2],
                before: [2, 2],
                operands: &["HTTP_REQUEST", "{}"],
            },
            // The comment-only twin of the empty handler above; see the
            // shared table for why it scores like it.
            BracedWordCase {
                source: "when HTTP_REQUEST {\n    # only a comment\n}\n",
                counts: [2, 2, 2, 2],
                before: [2, 2],
                operands: &["HTTP_REQUEST", "{\n    # only a comment\n}"],
            },
        ];
        witnessed.extend(check_braced_word_cases::<IrulesParser, IrulesCode>(
            &handlers,
            "foo.irule",
            &IRULES_BRACED_WORD_KINDS,
        ));
        assert_braced_word_children_witnessed(&witnessed, &IRULES_BRACED_WORD_KINDS, "irules");
    }

    /// One row of the #1318 tables: a fixture and the four Halstead
    /// columns plus the operand vocabulary behind them.
    ///
    /// No `before` column, unlike [`BracedWordCase`]: #1318 is not a
    /// guard whose absence a walk can model, it is a *classification*.
    /// The pre-fix counts are recorded per row in prose instead, and
    /// each was measured against a build without the
    /// `get_op_type_with_code` overrides.
    struct BracedWordValueCase {
        source: &'static str,
        /// `[n1, N1, n2, N2]`.
        counts: [u64; 4],
        operands: &'static [&'static str],
    }

    /// Runs one #1318 table against one dialect. Both dialects run
    /// every shared row, so a fix that reached one getter and not its
    /// clone fails here.
    #[cfg(any(feature = "irules", feature = "tcl"))]
    fn check_braced_word_value_cases<T: crate::MetricSuite>(
        cases: &[BracedWordValueCase],
        file: &str,
    ) {
        for case in cases {
            assert_halstead_counts::<T>(case.source, file, case.counts, case.source);
            assert_ops_operands::<T>(
                case.source,
                file,
                case.operands.len(),
                case.operands.to_vec(),
            );
        }
    }

    /// The #1318 rows both dialects share. Every independent path
    /// through the role test gets a row of its own
    /// (`.claude/rules/testing.md`, "give one input to each independent
    /// path"): the value default, the script-command list, a modelled
    /// construct reached through a `word_list`, the two modelled slots
    /// that hold values, an unresolvable command name, and both
    /// nesting directions.
    ///
    /// **Every row asserts the operand columns too, and they are the
    /// half that must not move.** #1318 revises one operator and
    /// nothing else, so a mutant that suppressed a value word's
    /// *contents* — the tidier-looking rule, which collapses an
    /// `oo::class create C {…}` body into a single operand — fails
    /// here rather than passing as an improvement. #1382 keeps to the
    /// same discipline: it withdraws further `{}` operators and moves
    /// no operand column in this table.
    ///
    /// The trailing rows are #1382's. The first four are two *pairs*:
    /// a braced value slot beside the bare spelling of the same
    /// argument, which must score alike. Before #1382 they did not —
    /// the braced spelling billed one extra `{}`. The four after them
    /// carry no bare partner: each braces a value with a space in it
    /// (`proc {my proc}`, `{a b}`, `{code msg}`), which is the whole
    /// reason the braces are there. Their pre-#1382 counts are
    /// recorded per row instead.
    #[cfg(any(feature = "irules", feature = "tcl"))]
    const BRACED_WORD_VALUE_CASES: [BracedWordValueCase; 24] = [
        // The rule reaches the opener and *only* the opener. A `;`
        // separating two commands is a direct child of the
        // `braced_word` — `_terminator` is a hidden rule, so it is
        // inlined rather than wrapped — and both dialects classify
        // `SEMI` as an operator, so a revision keyed on the parent
        // kind alone swallowed it too: this row read n1 0 / N1 0 and
        // `halstead.effort` 0.0, against a line that is two commands.
        // The pairing with the `eval` row below is the point — same
        // brace, same separator, one command name apart.
        BracedWordValueCase {
            source: "lappend l {puts a ; puts b}\n",
            counts: [1, 1, 5, 6],
            operands: &["lappend", "l", "puts", "a", "b"],
        },
        BracedWordValueCase {
            source: "eval {puts a ; puts b}\n",
            counts: [2, 2, 4, 5],
            operands: &["eval", "puts", "a", "b"],
        },
        // The reported fixture. `lappend` takes a list, so `{a b}`
        // quotes rather than opens: no operator. Before #1318 this
        // read n1 1 / N1 1 — a `{}` block the line does not contain.
        BracedWordValueCase {
            source: "lappend l {a b}\n",
            counts: [0, 0, 4, 4],
            operands: &["lappend", "l", "a", "b"],
        },
        // The issue's second line, and the one showing the defect
        // needs no second argument to appear.
        BracedWordValueCase {
            source: "puts {c d}\n",
            counts: [0, 0, 3, 3],
            operands: &["puts", "c", "d"],
        },
        // The headline: one value, two commands, and until #1318 two
        // different operator counts — `set` reported none, `lappend` a
        // `{}`. `set` is an operator and `lappend` an operand because
        // the grammar models one command and not the other; that
        // asymmetry is the grammar's, not this rule's.
        BracedWordValueCase {
            source: "set x {a b}\nlappend y {a b}\n",
            counts: [1, 1, 6, 6],
            operands: &["lappend", "x", "y", "{a b}", "a", "b"],
        },
        // The script side of the same shape, and the reason `LBRACE`
        // is gated rather than deleted (grammar-dispatch §6): `eval`
        // evaluates its argument, so the block is real and keeps its
        // `{}`.
        BracedWordValueCase {
            source: "eval {puts hi}\n",
            counts: [1, 1, 3, 3],
            operands: &["eval", "puts", "hi"],
        },
        // The same command named through the global namespace, which
        // is the spelling a `namespace eval` body uses to guarantee the
        // core command over a local proc shadowing it. `::eval` *is*
        // `eval`, so the two rows must agree on the operator column;
        // before the leading `::` was stripped this one fell to the
        // value default and lost its block.
        BracedWordValueCase {
            source: "::eval {puts hi}\n",
            counts: [1, 1, 3, 3],
            operands: &["::eval", "puts", "hi"],
        },
        // The control for that strip: only the *leading* qualifier is
        // a namespace path to the core command. `ns::eval` is a
        // different proc living in `ns`, so it takes the value default
        // like any other unrecognised name — a strip of every `::`
        // segment would have promoted it to a script.
        BracedWordValueCase {
            source: "ns::eval {a b}\n",
            counts: [0, 0, 3, 3],
            operands: &["ns::eval", "a", "b"],
        },
        // The default for an unrecognised command — a user proc here,
        // but equally any package command. Nothing distinguishes it
        // from `lappend` structurally, so the row exists to pin which
        // way the coin lands. Note the words inside are still
        // operands: the rule withdraws the block, never the code.
        BracedWordValueCase {
            source: "myproc {g h}\n",
            counts: [0, 0, 3, 3],
            operands: &["myproc", "g", "h"],
        },
        // `namespace` is the one construct either grammar models that
        // still reaches its body through a `word_list`, so it is the
        // row that fails if the rule stops at the parent instead of
        // reading the grandparent. Its body must stay a script.
        BracedWordValueCase {
            source: "namespace eval ns {\n    set a 1\n}\n",
            counts: [3, 3, 4, 4],
            operands: &["eval", "ns", "a", "1"],
        },
        // A literal nested in a literal: neither brace opens a block,
        // and both words survive.
        BracedWordValueCase {
            source: "puts {a {b c}}\n",
            counts: [0, 0, 4, 4],
            operands: &["puts", "a", "b", "c"],
        },
        // A `set` inside a literal. The `set` keyword and the `[]`
        // substitution are real operators of a command the walk
        // descends into, and they stay — the rule reaches exactly the
        // one brace whose parent it can classify, never a subtree.
        // `{x [foo] v}` is a `braced_word_simple`, so #1354 bills it
        // whole and its `[foo]` interior separately, unchanged.
        BracedWordValueCase {
            source: "lappend l {set a {x [foo] v}}\n",
            counts: [2, 2, 5, 5],
            operands: &["lappend", "l", "a", "{x [foo] v}", "foo"],
        },
        // A braced word in the command *name* position. Legal Tcl —
        // `{puts} hi` invokes `puts` — and the one generic position
        // that is not an argument, so it is answered before the
        // command lookup. It must also never reach the `switch`-arm
        // rescue, which is what the braced-pattern row in the Tcl
        // table checks.
        BracedWordValueCase {
            source: "{puts} hi\n",
            counts: [0, 0, 2, 2],
            operands: &["puts", "hi"],
        },
        // A defaulted `proc` parameter — the other modelled slot that
        // holds a value, decided by the parent kind rather than by a
        // command name. `{x y}` is data the interpreter assigns, never
        // a script it runs, and it billed a fourth `{}` before #1318.
        // The three that remain are the parameter list, the parameter
        // spec and the body: those two list delimiters group a
        // declaration rather than quote a value, the line #1354 drew
        // for `Arguments`.
        BracedWordValueCase {
            source: "proc p {a {b {x y}}} { puts $a }\n",
            counts: [2, 4, 7, 7],
            operands: &["p", "a", "b", "x", "y", "puts", "$a"],
        },
        // A literal nested in a script, the direction that must keep
        // working: the `proc` body is a block (`{}` twice with the
        // parameter list) and the list it appends is not.
        BracedWordValueCase {
            source: "proc p {} { lappend l {a b} }\n",
            counts: [2, 3, 5, 5],
            operands: &["p", "lappend", "l", "a", "b"],
        },
        // A computed command name resolves to nothing, so the value
        // default decides. `$c` is the reference's own operand.
        BracedWordValueCase {
            source: "set c puts\n$c {a b}\n",
            counts: [1, 1, 5, 5],
            operands: &["c", "puts", "$c", "a", "b"],
        },
        // #1382's headline, and the pair that names the defect: `after`
        // is a script-taking command, but only from its *second*
        // argument — the first is a millisecond count. Both spellings
        // of that count are one operand and no operator; before #1382
        // the braced one billed a `{}` for a block the line does not
        // contain, reading N1 2 against the bare form's 1. The `{}`
        // both rows do report is the `{puts hi}` script, which is real.
        BracedWordValueCase {
            source: "after {100} {puts hi}\n",
            counts: [1, 1, 4, 4],
            operands: &["after", "100", "puts", "hi"],
        },
        BracedWordValueCase {
            source: "after 100 {puts hi}\n",
            counts: [1, 1, 4, 4],
            operands: &["after", "100", "puts", "hi"],
        },
        // The same pair for `time script ?count?`, whose value slot is
        // the *last* rather than the first — so a rule that hard-coded
        // "argument 0 is the value" passes the `after` pair and fails
        // this one. The script argument keeps its `{}` in both rows,
        // which is what makes the operator column a 1 and not a 0.
        //
        // The *bare* row is the half that catches it, which is not the
        // half it looks like. Measured by giving `time` `after`'s slot
        // rule: `time {puts hi} 3` reads n1 0 / N1 0, its one block
        // demoted to a value — while the braced row below is unmoved
        // at [1, 1, 4, 4], because `{puts hi}` loses the `{}` that
        // `{3}` gains and the operand texts are the same either way.
        // Do not trim the bare spelling as redundant with the braced
        // one; here it is the discriminating row of the two.
        BracedWordValueCase {
            source: "time {puts hi} {3}\n",
            counts: [1, 1, 4, 4],
            operands: &["time", "puts", "hi", "3"],
        },
        BracedWordValueCase {
            source: "time {puts hi} 3\n",
            counts: [1, 1, 4, 4],
            operands: &["time", "puts", "hi", "3"],
        },
        // A braced `proc` *name*, the one value slot the grammar names
        // as a field rather than by position. `{my proc}` is an
        // identifier containing a space, not a body, and billed a
        // fourth `{}` before #1382. The three operators left are the
        // `proc` keyword and the two braces of the parameter list and
        // the body — and note the interior words survive, `proc` being
        // an operand here and an operator one column over.
        BracedWordValueCase {
            source: "proc {my proc} {} {}\n",
            counts: [2, 3, 3, 3],
            operands: &["my", "proc", "{}"],
        },
        // The two `namespace` subcommands that take values throughout,
        // both of them Tcl 8.6 standard-library spellings. Their braced
        // argument is a pattern list and a dictionary; neither is
        // evaluated, and each billed a `{}` before #1382 — n1 2 / N1 2
        // against the 1 / 1 here. The `namespace` keyword is the
        // operator that remains, which is what keeps these two rows
        // from reading `effort` 0.0.
        BracedWordValueCase {
            source: "namespace export {a b}\n",
            counts: [1, 1, 3, 3],
            operands: &["export", "a", "b"],
        },
        BracedWordValueCase {
            source: "namespace ensemble create -map {a b}\n",
            counts: [1, 1, 5, 5],
            operands: &["ensemble", "create", "-map", "a", "b"],
        },
        // A `trap` clause written outside a `try`, which is how both
        // grammars reach the generic-command path for it. This is the
        // `ScriptSlots::LastOf` row — the pattern and the variable list
        // are values and the handler is the script — and the only one
        // whose slot is counted from the *end* of the list, so a rule
        // that read `Only(2)` from the front would need the arity to
        // pass it. Before #1382 all three braces billed: N1 3.
        BracedWordValueCase {
            source: "trap {POSIX} {code msg} {puts hi}\n",
            counts: [1, 1, 6, 6],
            operands: &["trap", "POSIX", "code", "msg", "puts", "hi"],
        },
    ];

    /// Regression for #1318. `braced_word` carries both a block and a
    /// plain literal, and the grammars spell the two identically, so
    /// #1314's kind-scoped guard reached only the value slots they
    /// special-case: `set x {a b}` reported no operator while
    /// `lappend x {a b}` reported a `{}` for a block the line does not
    /// contain. The role is recognised out-of-band, by the enclosing
    /// command's leading word (grammar-dispatch §9).
    ///
    /// The Tcl-only rows are the constructs this grammar models with
    /// no node of its own (#467, #1264) — `switch` and `for` — plus the
    /// braced `switch` *pattern* that must not be mistaken for an arm
    /// body, in both the one-arm-per-line and the one-line layouts.
    /// Their iRules counterparts are dedicated nodes and are covered by
    /// the sibling test.
    #[cfg(feature = "tcl")]
    #[test]
    fn tcl_braced_word_role_follows_the_enclosing_command_1318() {
        check_braced_word_value_cases::<TclParser>(&BRACED_WORD_VALUE_CASES, "foo.tcl");
        let tcl_only: [BracedWordValueCase; 8] = [
            // `switch` arm bodies. The grammar flattens `pat body pat
            // body` into a `command` named after the first pattern, so
            // the bodies read as arguments of a command called `a` —
            // the shape the value default would call a literal. The
            // arm list's own `switch` name is what rescues them, and
            // `puts` occurring in both bodies is what separates n2
            // from N2.
            BracedWordValueCase {
                source: "switch $v { a { puts A } b { puts B } }\n",
                counts: [1, 3, 7, 8],
                operands: &["switch", "$v", "a", "b", "puts", "A", "B"],
            },
            // …and the limit of that rescue. A braced *pattern* is the
            // arm command's `name`, not an argument, so it is a
            // literal — `switch -regexp $v { {^a.*b$} {…} }` is
            // idiomatic and its regex must not be wrapped in a block.
            // Rescuing the whole arm command would read N1 4 here.
            // The leading `-exact` / `--` options are `simple_word`
            // operands of the *`switch`* command and shift nothing:
            // the arm list is found as the sole `braced_word` argument,
            // not by index (grammar-dispatch §9).
            BracedWordValueCase {
                source: "switch -exact -- $v {\n    {a b}   { puts X }\n    default { puts Y }\n}\n",
                counts: [1, 3, 10, 11],
                operands: &[
                    "switch", "-exact", "--", "$v", "a", "b", "puts", "X", "default", "Y",
                ],
            },
            // The same arms on one line. Only the *first* pattern is
            // the arm command's name; `{^b}` is its third argument, and
            // the name test alone rescued it as a body — N1 4 here,
            // against N1 3 for the identical arms written one per line.
            // The arm list is `pattern body pattern body …` by Tcl's
            // own definition, so the arguments alternate and the
            // even-indexed ones are the bodies.
            BracedWordValueCase {
                source: "switch -regexp $v { {^a} { puts A } {^b} { puts B } }\n",
                counts: [1, 3, 8, 9],
                operands: &["switch", "-regexp", "$v", "^a", "puts", "A", "^b", "B"],
            },
            // The words that can interpose between a pattern and its
            // body take one slot each and leave the parity intact: a
            // `-` fall-through body and a `default` pattern are both
            // `simple_word`s. The two braced bodies are at indexes 2
            // and 4 of the run and both keep their `{}`.
            BracedWordValueCase {
                source: "switch $v { a - b { puts AB } default { puts D } }\n",
                counts: [1, 3, 9, 10],
                operands: &["switch", "$v", "a", "-", "b", "puts", "AB", "default", "D"],
            },
            // `for` has four braced arguments and all four are
            // evaluated, so all four keep their braces. `i` appears as
            // the `set` target and again inside `incr`, and `$i` in
            // the condition and the body, which is what separates
            // n2 = 8 from N2 = 10. `<` is an *operand* here rather
            // than a comparison operator: with no `for` rule there is
            // no `expr` slot, so the condition parses as a command and
            // its comparison never surfaces as a token — the same
            // grammar limitation #1264 recorded for ABC.
            BracedWordValueCase {
                source: "for {set i 0} {$i < 3} {incr i} { puts $i }\n",
                counts: [2, 5, 8, 10],
                operands: &["for", "i", "0", "$i", "<", "3", "incr", "puts"],
            },
            // #1382's guard rows: an arm *pattern* spelled like a
            // command whose value slots the rule now withdraws. An arm
            // list parses as commands, so the pattern becomes a real
            // command name and the arm *body* lands in one of that
            // command's value slots — where only `Getter::is_switch_arm`
            // keeps it a block. Both rows are `switch` bodies that must
            // keep their `{}`, and both were measured with the guard
            // short-circuited to `false`.
            //
            // This one is the positional half: `after`'s slot 0 is the
            // millisecond count, so without the guard `{ puts B }` reads
            // as that value and the row drops to N1 1.
            BracedWordValueCase {
                source: "switch $v { after { puts B } }\n",
                counts: [1, 2, 5, 5],
                operands: &["switch", "$v", "after", "puts", "B"],
            },
            // …and this is the field-keyed half. `proc` needs three
            // words, so the arm patterns must be written one per line
            // for the grammar to build a `procedure` at all — on one
            // line it recovers into an `ERROR` and no rule fires. Here
            // it swallows two arms, taking `{ puts A }` as its `name`
            // field and `{ puts B }` as its body; without the guard the
            // name's brace goes and the row reads N1 5. The `namespace`
            // arm is the third spelling of the same hazard and is not
            // discriminating: its subcommand slot holds the braced body
            // itself rather than a `simple_word`, so no layout resolves
            // and the construct-wide script answer stands either way.
            // `proc` and `namespace` are operators here and `after` an
            // operand, which is the three patterns' whole difference.
            BracedWordValueCase {
                source: "switch $v {\n    proc { puts A }\n    after { puts B }\n    namespace { puts C }\n}\n",
                counts: [3, 6, 7, 9],
                operands: &["switch", "$v", "after", "puts", "A", "B", "C"],
            },
            // The arity guard on `ScriptSlots::LastOf`, Tcl-only
            // because the iRules grammar models `trap_handler` and so
            // never reaches the generic-command path (#1382 review).
            // Tcl models neither `on` nor `trap`, so the whole tail
            // after the `try` body parses as *one* `trap` command with
            // five arguments — `{p} {v} {puts b} finally {puts c}`.
            // Reading "the script is the last argument" off that names
            // the `finally` body and calls `{puts b}` a value, which
            // dropped the `{}` of a block the line does contain and
            // read N1 3. All five braces are blocks here, which is the
            // answer a list the signature cannot explain has to get.
            // The `trap` row in the shared table is the same clause at
            // its documented arity, where two of the three braces
            // really are values — so a guard stuck on "always script"
            // fails there and one stuck on "always last" fails here.
            BracedWordValueCase {
                source: "try {puts a} trap {p} {v} {puts b} finally {puts c}\n",
                counts: [2, 6, 8, 10],
                operands: &["a", "b", "c", "finally", "p", "puts", "trap", "v"],
            },
        ];
        check_braced_word_value_cases::<TclParser>(&tcl_only, "foo.tcl");
    }

    /// The iRules twin of the test above. The shared table runs
    /// unchanged — the two getters are deliberate clones and #1318
    /// names both — and the dialect rows cover the handler bodies,
    /// which have no Tcl spelling.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_braced_word_role_follows_the_enclosing_command_1318() {
        check_braced_word_value_cases::<IrulesParser>(&BRACED_WORD_VALUE_CASES, "foo.irule");
        let irules_only: [BracedWordValueCase; 4] = [
            // A `when` handler body is a modelled slot, so the literal
            // inside it is classified independently of the block that
            // holds it.
            BracedWordValueCase {
                source: "when HTTP_REQUEST {\n    lappend b {x y}\n}\n",
                counts: [2, 2, 5, 5],
                operands: &["HTTP_REQUEST", "lappend", "b", "x", "y"],
            },
            // This grammar models `switch` with `switch_arm` children,
            // so the arm body fills a modelled slot and never reaches
            // the command-name list the Tcl rows need.
            BracedWordValueCase {
                source: "when HTTP_REQUEST {\n    switch $v { a { pool p1 } }\n}\n",
                counts: [3, 5, 5, 5],
                operands: &["HTTP_REQUEST", "$v", "a", "pool", "p1"],
            },
            // `on` and `trap` are why the command list carries two
            // words no *Tcl* command spells. The grammar emits
            // `on_handler` / `trap_handler` only under `try` — pinned
            // by `irules_try_handler_kinds_appear_only_under_try` — so
            // a statement-level handler is a generic command, and
            // without the list entry its body would lose the `{}` that
            // the second occurrence here counts.
            BracedWordValueCase {
                source: "when RULE_INIT { set x 1 }\non error { log local0. oops }\n",
                counts: [3, 4, 8, 8],
                operands: &[
                    "RULE_INIT",
                    "x",
                    "1",
                    "on",
                    "error",
                    "log",
                    "local0.",
                    "oops",
                ],
            },
            // #1382 inside a modelled handler slot: the `when` body is
            // a block and keeps its `{}`, and the `after` delay nested
            // in it is a value and does not. Before #1382 this read
            // N1 4. The shared table's `after` pair already runs for
            // this dialect; what this row adds is that the rule reaches
            // a command nested inside a handler, where the `{}` billed
            // for the handler could otherwise mask a withdrawal.
            BracedWordValueCase {
                source: "when HTTP_REQUEST {\n    after {100} {puts hi}\n}\n",
                counts: [2, 3, 5, 5],
                operands: &["HTTP_REQUEST", "after", "100", "puts", "hi"],
            },
        ];
        check_braced_word_value_cases::<IrulesParser>(&irules_only, "foo.irule");
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_operators_and_operands() {
        check_metrics::<PhpParser>(
            "<?php
            function avg(int $a, int $b, int $c): int {
                return ($a + $b + $c) / 3;
            }",
            "foo.php",
            |metric| {
                // After #695 only the opening delimiters count: `()` and
                // `{}` fold to one operator each per balanced pair, so the
                // former `)`/`}` closers no longer inflate n1/N1 (was
                // 11 unique / 15 total).
                //
                // Operands after #1293, tallied by `get_id` (source bytes):
                //   `avg` × 1, `int` × 4 (the `primitive_type` wrapper at
                //   all four type positions — its `int` keyword child is
                //   suppressed under it), `$a` / `$b` / `$c` × 2 each,
                //   `3` × 1 ⇒ n2 = 6, N2 = 12. Between #1259 and #1293 the
                //   keyword leaf doubled the type count ⇒ 6 / 16; before
                //   #1259 each `$v` also contributed its sigil-less `name`
                //   leaf ⇒ 9 / 22.
                assert_eq!(metric.halstead.unique_operators(), 9);
                assert_eq!(metric.halstead.total_operators(), 12);
                assert_eq!(metric.halstead.unique_operands(), 6);
                assert_eq!(metric.halstead.total_operands(), 12);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_simple_function() {
        check_metrics::<PhpParser>(
            "<?php
            function inc(int $x): int { return $x + 1; }",
            "foo.php",
            |metric| {
                // After #695 only opening delimiters count: the `)`/`}`
                // closers no longer add operators (was 9 unique / 9 total).
                //
                // Operands after #1293: `inc` × 1, `int` × 2 (the
                // `primitive_type` wrapper at both type positions, its
                // `int` keyword child suppressed under it), `$x` × 2,
                // `1` × 1 ⇒ n2 = 4, N2 = 6. Between #1259 and #1293 the
                // keyword leaf doubled the type count ⇒ 4 / 8; before
                // #1259 `$x` also contributed its `x` leaf twice ⇒ 5 / 10.
                assert_eq!(metric.halstead.unique_operators(), 7);
                assert_eq!(metric.halstead.total_operators(), 7);
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 6);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_variable_reference_counts_once() {
        // Regression: issue #1259. `$x` parses as a `variable_name`
        // wrapping a `name` leaf, and both kinds were in the operand
        // arm — so every variable reference contributed twice to N2 and
        // planted a sigil-less twin (`x` beside `$x`) in the n2
        // vocabulary. Since `$var` is the most common token class in
        // PHP, that roughly doubled N2 for real files.
        //
        // Source: the issue's reproducer plus a re-reference of `$a` and
        // `$b`, so N2 exceeds n2 and the assertions can tell "counted
        // once per occurrence" from "deduplicated into the vocabulary".
        //   <?php $a = null; $b = true; $c = NULL; $a = $b;
        //
        // Operands by text key: `$a` × 2, `$b` × 2, `$c`, `null`, `true`,
        // `NULL` ⇒ n2 = 6, N2 = 8. Before the fix the `a` / `b` / `c`
        // leaves added 3 unique and 5 occurrences ⇒ 9 / 13.
        check_metrics::<PhpParser>(
            "<?php\n$a = null;\n$b = true;\n$c = NULL;\n$a = $b;\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 6);
                assert_eq!(metric.halstead.total_operands(), 8);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_dynamic_variable_name_counts_once_at_any_depth() {
        // Regression: issue #1259. Variable-variable syntax nests the
        // wrappers, so the double count compounds: `$$a` is a
        // `dynamic_variable_name` → `variable_name` → `name` chain that
        // scored 3 for one reference, and `$$$b` scored 4. Only the
        // outermost wrapper may count.
        //
        // Source: <?php $$a = 1; $$$b = 2; ${$c} = 3; $$a = 4;
        // The trailing re-assignment repeats `$$a` so N2 exceeds n2 and
        // the assertions can tell "counted once per occurrence" from
        // "deduplicated into the vocabulary".
        //
        // Operands: `$$a` × 2, `$$$b`, `${$c}`, `1`, `2`, `3`, `4`
        // ⇒ n2 = 7, N2 = 8. Before the fix: 14 / 17 (measured), each
        // target contributing its whole nesting chain — `$$a` → `$a` →
        // `a` is 3 (twice over), `$$$b` → `$$b` → `$b` → `b` is 4, and
        // `${$c}` → `$c` → `c` is 3, plus the four integers.
        check_metrics::<PhpParser>(
            "<?php $$a = 1; $$$b = 2; ${$c} = 3; $$a = 4;",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 7);
                assert_eq!(metric.halstead.total_operands(), 8);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_dynamic_variable_name_guard_is_parent_scoped() {
        // Companion to the two tests above (#1259): the guards fire on
        // the *parent* kind, never on the kind alone, so the two
        // positions where a nested node is a reference in its own right
        // keep counting.
        //
        // Source: <?php $y = "brace ${z} end"; $s = ${$a . 'b'};
        //
        // `"${z}"` is a `dynamic_variable_name` whose `name` child is
        // suppressed (the wrapper `${z}` carries the reference), while
        // `${$a . 'b'}` reaches its `$a` through a `binary_expression`,
        // so that `variable_name`'s parent is not a
        // `dynamic_variable_name` and it counts normally.
        //
        // Operands: `$y`, `${z}`, `$s`, `${$a . 'b'}`, `$a`, `'b'` — one
        // each ⇒ n2 = 6, N2 = 6. A guard written as a blanket kind
        // exclusion instead of a parent check would drop `$a` ⇒ 5 / 5.
        check_metrics::<PhpParser>(
            "<?php $y = \"brace ${z} end\"; $s = ${$a . 'b'};",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 6);
                assert_eq!(metric.halstead.total_operands(), 6);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_type_wrappers_count_the_type_once() {
        // Regression: issue #1293. A parameter type nests wrapper nodes
        // whose text spans the node below them — `primitive_type` around
        // the `int` keyword token, `named_type` around a `name`,
        // `optional_type` around either — and every level was in the
        // operand arm, so `int` scored 2 and `?int` scored 3.
        //
        // Source: the issue's first reproducer.
        //   <?php
        //   function f(int $a, bool $b, float $c, string $d, array $e,
        //              Foo $g): ?int { return 0; }
        //
        // Operands by text key: `f`, the five `primitive_type` parameter
        // types, `Foo` (the `name` under its `named_type`), `$a`..`$g`,
        // the return `int`, and `0`. `int` occurs twice (parameter and
        // return) ⇒ n2 = 14, N2 = 15. Before the fix: 15 / 23 — the
        // extra vocabulary entry being `?int`, which the `?` operator
        // already accounts for.
        check_metrics::<PhpParser>(
            "<?php\nfunction f(int $a, bool $b, float $c, string $d, \
             array $e, Foo $g): ?int { return 0; }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 14);
                assert_eq!(metric.halstead.total_operands(), 15);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_qualified_name_counts_its_components_once() {
        // Regression: issue #1293. `Foo\Bar\Baz` parses as
        // `qualified_name` → `namespace_name` → `name` × N, and all
        // three kinds were operands, so one three-part path scored 5 and
        // planted `Foo`, `Foo\Bar` and `Foo\Bar\Baz` in the vocabulary.
        // The components carry the operand and `\` stays an operator,
        // matching how PHP's own `::` and `->` already read here.
        //
        // Source: the issue's second reproducer.
        //   <?php
        //   namespace App\Sub;
        //   use Foo\Bar\Baz;
        //   $o = new \Vendor\Pkg\Thing();
        //
        // Operands: `App`, `Sub`, `Foo`, `Bar`, `Baz`, `$o`, `Vendor`,
        // `Pkg`, `Thing` — one each ⇒ n2 = 9, N2 = 9. Before the fix:
        // 14 / 14.
        check_metrics::<PhpParser>(
            "<?php\nnamespace App\\Sub;\nuse Foo\\Bar\\Baz;\n\
             $o = new \\Vendor\\Pkg\\Thing();\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 9);
                assert_eq!(metric.halstead.total_operands(), 9);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_nested_type_wrappers_count_once_at_any_depth() {
        // Companion to the two tests above (#1293): the type and
        // qualified-name wrappers compose, so a single annotation can
        // stack five levels — `?A\B` is `optional_type` → `named_type` →
        // `qualified_name` → `namespace_name` → `name`, which scored 6
        // operands for two identifiers. `union_type` and
        // `intersection_type` stack the same way over their members;
        // their `|` and `&` are already operators.
        //
        // Source:
        //   <?php function k(?A\B $p, int|string $q, C&D $r): ?A\B
        //   { return 0; }
        // The return type repeats `?A\B` so N2 exceeds n2 and the
        // assertions can tell "counted once per occurrence" from
        // "deduplicated into the vocabulary".
        //
        // Operands: `k`, `A` × 2, `B` × 2, `$p`, `int`, `string`, `$q`,
        // `C`, `D`, `$r`, `0` ⇒ n2 = 11, N2 = 13.
        check_metrics::<PhpParser>(
            "<?php function k(?A\\B $p, int|string $q, C&D $r): ?A\\B { return 0; }",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 11);
                assert_eq!(metric.halstead.total_operands(), 13);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_childless_primitive_types_still_count() {
        // Guards the direction of the #1293 fix for `primitive_type`,
        // where — unlike the qualified-name wrappers — the *wrapper*
        // carries the operand and the keyword leaf is suppressed. The
        // grammar emits no token node under `primitive_type` for
        // `callable`, `iterable`, `mixed`, `void`, `false` or `true`
        // (verified with `bca dump`), so the other direction would score
        // those six types zero — grammar-dispatch §6.
        //
        // Source:
        //   <?php function q(callable $a, iterable $b, mixed $c,
        //                    false $d, true $e): void { }
        //
        // Operands: `q`, `callable`, `iterable`, `mixed`, `false`,
        // `true`, `void`, `$a`..`$e` ⇒ n2 = 12, N2 = 12. Dropping
        // `PrimitiveType` from the operand arm instead of gating its
        // leaf gives 6 / 6.
        check_metrics::<PhpParser>(
            "<?php function q(callable $a, iterable $b, mixed $c, \
             false $d, true $e): void { }",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 12);
                assert_eq!(metric.halstead.total_operands(), 12);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_primitive_type_keyword_guard_is_parent_scoped() {
        // Companion to the test above (#1293): the keyword suppression
        // fires on the *parent* kind, never on the kind alone.
        // `array` is also the head token of an `array(…)` literal, where
        // it is the construct's only operand and must keep counting; a
        // `(int)` / `(string)` cast is a childless `cast_type` that
        // never reaches the guard at all.
        //
        // Source: <?php $x = array(1, 2); $y = (int) $x; $z = (string) $x;
        //
        // Operands: `$x` × 3, `array`, `1`, `2`, `$y`, `int`, `$z`,
        // `string` ⇒ n2 = 8, N2 = 10. A blanket kind exclusion instead
        // of a parent check would drop the `array` head ⇒ 7 / 9.
        check_metrics::<PhpParser>(
            "<?php $x = array(1, 2); $y = (int) $x; $z = (string) $x;",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 8);
                assert_eq!(metric.halstead.total_operands(), 10);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_encapsed_string_interpolation_no_double_count() {
        // Regression: issue #184. A PHP `"Hello $name!"` used to be
        // classified as a Halstead operand (the wrapping
        // `encapsed_string`) AND have its inner `variable_name`
        // (`$name`) plus the inner `name` token classified as
        // operands too. With the fix, the wrapping literal drops to
        // `Unknown` when it carries any `$var` / `${name}` / `{$expr}`
        // child, so `$name` is counted exactly once at each text
        // occurrence.
        //
        // Source:
        //   <?php $name = "world"; echo "Hello $name!";
        //
        // Inert operand: `"world"` (no interpolation, still operand).
        // Operands by text key (`get_id` keys by source bytes):
        //   `$name` × 2 (assignment LHS and `$name` inside the
        //   interpolated string), `"world"` × 1.
        // u_operands = 2, N2 = 3.
        // Without the #184 fix the wrapping `"Hello $name!"` would also
        // count → 3 / 4. This test additionally pinned the *inner* `name`
        // leaf of each `variable_name` (a further 2 occurrences, 1 unique
        // ⇒ the historical 3 / 5) until #1259 recognised that as the same
        // double count one level down.
        check_metrics::<PhpParser>(
            "<?php $name = \"world\"; echo \"Hello $name!\";",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 3);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_encapsed_string_no_interpolation_still_operand() {
        // The fix for #184 only drops `EncapsedString`/`Heredoc` from
        // the operand arm when interpolation is present. An inert
        // double-quoted string must still count as exactly one
        // operand, identical to the single-quoted equivalent.
        //
        // Source: `<?php echo "Hello world!";`
        // Operands: `"Hello world!"` × 1 → u_operands = 1, N2 = 1.
        check_metrics::<PhpParser>("<?php echo \"Hello world!\";", "foo.php", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 1);
            assert_eq!(metric.halstead.total_operands(), 1);
        });
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_heredoc_interpolation_no_double_count() {
        // Regression: issue #184. A PHP heredoc whose body
        // interpolates `$name` previously counted both the wrapping
        // `heredoc` node and the inner `$name` as operands; the fix
        // drops the wrapper when its `heredoc_body` carries any
        // interpolation child.
        //
        // Source:
        //   <?php $name = "x"; echo <<<EOT
        //   hi $name
        //   EOT;
        //
        // Operands by text key: `$name` × 2, `"x"` × 1 (inert encapsed
        // string, still an operand). With the fix u_operands = 2,
        // N2 = 3. Without it the wrapping heredoc text would add one
        // more unique operand. The sigil-less `name` leaf inside each
        // `variable_name` was counted too until #1259.
        check_metrics::<PhpParser>(
            "<?php $name = \"x\"; echo <<<EOT\nhi $name\nEOT;\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 2);
                assert_eq!(metric.halstead.total_operands(), 3);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_nowdoc_unaffected() {
        // `Nowdoc` (single-quoted heredoc) never interpolates and is
        // never matched by `php_string_has_interpolation`. It must
        // continue counting as exactly one operand regardless of the
        // text inside, mirroring single-quoted `String`.
        //
        // Source:
        //   <?php echo <<<'EOT'
        //   plain $name not interpolated
        //   EOT;
        //
        // Operands: the nowdoc literal × 1 → u_operands = 1, N2 = 1.
        check_metrics::<PhpParser>(
            "<?php echo <<<'EOT'\nplain $name not interpolated\nEOT;\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 1);
                assert_eq!(metric.halstead.total_operands(), 1);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_encapsed_string_bare_member_access_no_double_count() {
        // Regression: issue #184 follow-up. The PHP grammar allows
        // bare `$obj->prop` interpolation inside `"…"` without
        // surrounding `{ … }`; tree-sitter-php emits this as a
        // direct `member_access_expression` child of
        // `encapsed_string` (kind_id 329 in the current grammar).
        // The wrapper must drop to `Unknown` for that form too —
        // otherwise the inner `$obj` and `prop` `name` tokens are
        // walked as operands while the wrapper also counts,
        // double-counting `N2`.
        //
        // Source:
        //   <?php $obj = new stdClass; $obj->prop = "x"; echo "Hi $obj->prop!";
        //
        // Operands tallied by `get_id` (keyed on source bytes):
        //   `$obj`        × 3 (LHS assignment, member-access target,
        //                      inside the interpolated string)
        //   `prop` (name) × 2 (member-access RHS twice — a bare `name`
        //                      outside any `variable_name`, so #1259's
        //                      guard leaves it an operand)
        //   `stdClass`    × 1
        //   `"x"`         × 1
        // ⇒ u_operands = 4, N2 = 7.
        // With the bug the wrapping `"Hi $obj->prop!"` text adds one
        // more unique operand and one more occurrence ⇒ 5 / 8.
        check_metrics::<PhpParser>(
            "<?php $obj = new stdClass; $obj->prop = \"x\"; echo \"Hi $obj->prop!\";",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 7);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_encapsed_string_bare_subscript_no_double_count() {
        // Regression: issue #184 follow-up. Bare `$arr[0]` inside
        // `"…"` produces a `subscript_expression` child of
        // `encapsed_string` (kind_id 351). The wrapper must drop to
        // `Unknown` for that form.
        //
        // Source:
        //   <?php $arr = [1]; echo "Hi $arr[0]!";
        //
        // Operands tallied by `get_id`:
        //   `$arr` × 2, `1` × 1, `0` × 1.
        // ⇒ u_operands = 3, N2 = 4.
        // With the bug the wrapping `"Hi $arr[0]!"` text adds 1 / 1.
        // The inner `arr` leaf of each `variable_name` added a further
        // 1 / 2 until #1259.
        check_metrics::<PhpParser>(
            "<?php $arr = [1]; echo \"Hi $arr[0]!\";",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_shell_command_expression_inert_is_operand() {
        // Regression: issue #288. Backtick command literals (PHP's
        // `shell_command_expression`) were filtered as strings by
        // `Checker::is_string` and `Alterator::alterate`, but never
        // classified as Halstead operands — so they contributed
        // nothing to N2 / eta2. An inert backtick literal must now
        // count as exactly one operand, matching `EncapsedString`
        // and `Heredoc`.
        //
        // Source: `<?php $out = ` + backtick `ls` + backtick + `;`
        // Operands tallied by `get_id`:
        //   `$out` × 1, backtick literal × 1.
        // ⇒ u_operands = 2, N2 = 2.
        // Before the fix the backtick literal vanished from the count
        // ⇒ u_operands = 1, N2 = 1. (The inner `out` leaf of the
        // `variable_name` added another 1 / 1 until #1259.)
        check_metrics::<PhpParser>("<?php $out = `ls`;", "foo.php", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_shell_command_expression_interpolation_no_double_count() {
        // Regression: issue #288. PHP backtick literals DO support
        // `$var` interpolation (see tree-sitter-php node-types.json:
        // `shell_command_expression` children include `variable_name`,
        // `dynamic_variable_name`, `member_access_expression`,
        // `subscript_expression`). With the fix the wrapper drops to
        // `Unknown` when it carries any interpolation child, exactly
        // as `EncapsedString` does.
        //
        // Source: `<?php $dir = "/tmp"; $out = ` + backtick `ls $dir` +
        //   backtick + `;`
        //
        // Operands tallied by `get_id`:
        //   `$dir` × 2 (assignment LHS, inside backticks),
        //   `$out` × 1, `"/tmp"` × 1.
        // ⇒ u_operands = 3, N2 = 4.
        // Without the interpolation guard the wrapping backtick literal
        // would also count ⇒ u_operands = 4, N2 = 5. The sigil-less
        // `dir` / `out` leaves added a further 2 / 3 until #1259.
        check_metrics::<PhpParser>(
            "<?php $dir = \"/tmp\"; $out = `ls $dir`;",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_interpolation_opener_is_not_an_operator() {
        // Regression: issue #1314. `Php::LBRACE` is *both* the
        // compound-statement brace and the complex-interpolation
        // opener, so `"dq {$y} end"` reported a `{}` operator — and
        // reported it against the same vocabulary entry a real block
        // uses, which no other language does.
        //
        // expected: operators `=` × 2, `;` × 2 → n1 = 2, N1 = 4.
        // Operands `$s`, `$t`, `$y` × 2 → n2 = 3, N2 = 4. Before the
        // guard the two openers added `{}` → n1 = 3, N1 = 6.
        check_metrics::<PhpParser>(
            "<?php\n$s = \"dq {$y} end\";\n$t = \"dq {$y} end\";\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 2);
                assert_eq!(metric.halstead.total_operators(), 4);
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_interpolation_opener_guard_covers_every_wrapper() {
        // The opener is a direct child of four distinct parents, and
        // each is an independent leg of the guard (grammar-dispatch
        // section 11) — a fixture covering only `encapsed_string`
        // leaves the other three dead.
        //
        // One row per parent, so a failure names the leg that broke.
        // The heredoc's brace hangs off `heredoc_body` rather than
        // `heredoc`; the backtick form is `shell_command_expression`;
        // and the bare `${$y}` variable-variable is a
        // `dynamic_variable_name`, the one position that is not inside
        // a string at all.
        //
        // expected per row: operators `=` × 2, `;` × 2 → n1 = 2,
        // N1 = 4; three distinct operands with one repeated → n2 = 3,
        // N2 = 4.
        for (label, source) in [
            (
                "encapsed_string",
                "<?php\n$s = \"dq {$y} end\";\n$t = \"dq {$y} end\";\n",
            ),
            (
                "heredoc_body",
                "<?php\n$h = <<<EOT\na {$y} b\nEOT;\n$i = <<<EOT\na {$y} b\nEOT;\n",
            ),
            (
                "shell_command_expression",
                "<?php\n$b = `ls {$y}`;\n$c = `ls {$y}`;\n",
            ),
            ("dynamic_variable_name", "<?php\n$q = ${$y};\n$r = ${$y};\n"),
        ] {
            assert_halstead_counts::<PhpParser>(source, "foo.php", [2, 4, 3, 4], label);
        }
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_every_interpolation_spelling_scores_alike() {
        // The policy stated as a test (#1314). PHP writes one
        // interpolation three ways; the choice is spelling, so all
        // three must score identically. Before the guard the two
        // braced forms reported a `{}` the bare `$y` form did not.
        //
        // `"${y}"` is deprecated as of PHP 8.2 and removed in 9.0, but
        // the pinned grammar still parses it and it is still in the
        // wild, so it stays a row here.
        //
        // The fixture deliberately omits a `$y = …` declaration: with
        // one, the bare and `{$y}` forms key their operand as `$y` and
        // collapse into the declaration's entry while `${y}` keys as
        // `${y}` and does not, so n2 would differ for a reason that has
        // nothing to do with this guard.
        //
        // expected per spelling: operators `=` × 2, `;` × 2 → n1 = 2,
        // N1 = 4; operands `$s`, `$t`, the interpolated reference × 2
        // → n2 = 3, N2 = 4.
        for literal in ["\"a $y b\"", "\"a {$y} b\"", "\"a ${y} b\""] {
            assert_halstead_counts::<PhpParser>(
                &format!("<?php\n$s = {literal};\n$t = {literal};\n"),
                "foo.php",
                [2, 4, 3, 4],
                &format!("interpolation {literal}"),
            );
        }
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_compound_statement_brace_still_counts() {
        // Control for #1314: the guard is scoped to the four
        // interpolating wrappers, so a real block keeps its `{}`. A
        // guard widened to every `LBRACE` would take `{}` out of the
        // operator set entirely and fail here.
        //
        // expected: operators `function`, `()`, `{}` × 2, `if`,
        // `return`, `;` → n1 = 6, N1 = 8. Operands `f`, `1`, `2` →
        // n2 = N2 = 3.
        check_metrics::<PhpParser>(
            "<?php\nfunction f() { if (1) { return 2; } }\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 6);
                assert_eq!(metric.halstead.total_operators(), 8);
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 3);
            },
        );
    }

    #[cfg(feature = "php")]
    #[test]
    fn php_interpolation_guard_is_parent_scoped_not_ancestor_scoped() {
        // The input that separates the parent-scoped guard from the
        // ancestor-scanning mutant — the mutant #1256's post-mortem
        // says survives every ordinary fixture. PHP is one of only two
        // languages in #1314 where such an input exists: a closure
        // inside a complex interpolation puts a *compound-statement*
        // brace under an `encapsed_string` ancestor while its parent is
        // the `compound_statement`. An ancestor scan swallows it.
        //
        // expected: operators `=`, `;` × 2, `->`, `()` × 2, `function`,
        // `{}`, `return` → n1 = 7, N1 = 9. Operands `$s`, `$o`, `m`,
        // `1` → n2 = N2 = 4. Under the ancestor-scoped mutant the
        // closure's brace vanishes: n1 = 6, N1 = 8.
        check_metrics::<PhpParser>(
            "<?php\n$s = \"{$o->m(function() { return 1; })}\";\n",
            "foo.php",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 7);
                assert_eq!(metric.halstead.total_operators(), 9);
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 4);
            },
        );
    }

    #[cfg(feature = "elixir")]
    #[test]
    fn elixir_operators_and_operands() {
        // Exercises every Halstead family classified in Elixir's
        // `get_op_type`: control-flow keywords (`do`, `end`, `fn`),
        // structural punctuation — only the *opening* delimiters `(`,
        // `[` count after #695 (the `)`/`]` closers were dropped), plus
        // `,`, `.`, `@`,
        // arithmetic (`+`, `-`, `*`, `/`), comparison (`==`, `>`),
        // logical (`&&`, `||`, `and`, `or`, `!`), pipe (`|>`), capture
        // (`&`), assignment/match (`=`), and the stab arrow (`->`).
        // The body mixes identifiers, integers, atoms, and a string.
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  @doc \"add\"\n  def calc(a, b) do\n    result = a + b * 2\n    flag = result > 0 && a == b\n    out = if flag, do: result, else: -result\n    [out, a, b]\n  end\nend\n",
            "foo.ex",
            |metric| {
                // Positive headline assertions on integer counts. After
                // #695 only opening delimiters count: the `)`/`]` closers
                // no longer add operators (was 15 unique / 23 total).
                assert_eq!(metric.halstead.unique_operators(), 13);
                assert_eq!(metric.halstead.total_operators(), 21);
                assert_eq!(metric.halstead.unique_operands(), 16);
                assert_eq!(metric.halstead.total_operands(), 27);
                insta::assert_json_snapshot!(
                    metric.halstead,
                    @r#"
                {
                  "unique_operators": 13,
                  "total_operators": 21,
                  "unique_operands": 16,
                  "total_operands": 27,
                  "length": 48,
                  "estimated_program_length": 112.10571633583419,
                  "purity_ratio": 2.3355357569965456,
                  "vocabulary": 29,
                  "volume": 233.18308776612344,
                  "difficulty": 10.96875,
                  "level": 0.09116809116809117,
                  "effort": 2557.7269939346666,
                  "time": 142.09594410748147,
                  "bugs": 0.062342115670886794
                }
                "#
                );
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_operators_and_operands() {
        // A small Ruby method exercising operators (def/if/end keyword
        // tokens, `+`, `==`, `<=`, structural punctuation) and operands
        // (`n`, `1`, `factorial`). Anchors the unique/total counts on
        // both sides and snapshots the full Halstead derivation.
        //
        // Lesson 4 invariants: u_operators / u_operands here equal the
        // dedupe lengths the `--ops` accessor would emit on the same
        // source. Any future grammar bump that adds an aliased kind_id
        // to either side will trip this without snapshot drift.
        check_metrics::<RubyParser>(
            "def factorial(n)\n  return 1 if n <= 1\n  n * factorial(n - 1)\nend\n",
            "foo.rb",
            |metric| {
                // After #695 only the `(` opener counts (folded `()`); the
                // `)` closer — which appeared twice across the two calls —
                // no longer adds an operator (was 9 unique / 11 total).
                assert_eq!(metric.halstead.unique_operators(), 8);
                assert_eq!(metric.halstead.total_operators(), 9);
                assert_eq!(metric.halstead.unique_operands(), 3);
                assert_eq!(metric.halstead.total_operands(), 9);
                insta::assert_json_snapshot!(metric.halstead);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_halstead_plain_string_operand() {
        // A bare string literal contributes exactly one operand. The
        // counterpart to `ruby_halstead_interpolated_string_no_double_count`
        // — verifies the "no interpolation" branch of the same arm
        // (see `get_op_type`'s `R::String | …` case in
        // `big-code-analysis-ast/src/getter.rs`).
        // expected: operators = {def, end} = 2; operands = {f, "hello"} = 2.
        check_metrics::<RubyParser>("def f\n  \"hello\"\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 2);
            assert_eq!(metric.halstead.total_operators(), 2);
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_halstead_interpolated_string_no_double_count() {
        // Regression mirror for #180 (Bash) / #183 (C#): when a Ruby
        // string literal carries an `Interpolation` child, the
        // wrapping `String` node is intentionally classified as
        // `Unknown` so the inner expression's identifiers are not
        // double-counted as operands.
        //
        // expected: for `def f(name)\n  "Hi #{name}"\nend\n` —
        //   operators: def, (, ), #{, }, end → u_operators = 6.
        //   operands: f, name (param), name (inside `#{name}`). The
        //   wrapping `"…#{name}"` literal is skipped by the
        //   `is_child(R::Interpolation)` guard; the operand store
        //   keys by token text so the two `name` occurrences dedupe
        //   into one distinct entry → u_operands = 2, operands = 3
        //   (`f` once, `name` twice).
        // Without the guard, the wrapping literal would also count,
        // inflating u_operands to 3 and operands to 4.
        check_metrics::<RubyParser>("def f(name)\n  \"Hi #{name}\"\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 3);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_halstead_symbol_literal_operand() {
        // `:foo` is a `SimpleSymbol` leaf — counts as a single
        // operand, no interpolation guard needed (only
        // `DelimitedSymbol` (`:"…#{x}…"`) can interpolate).
        // expected: operators = {def, end} = 2; operands = {f, :ok} = 2.
        check_metrics::<RubyParser>("def f\n  :ok\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 2);
            assert_eq!(metric.halstead.unique_operands(), 2);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_halstead_regex_operand() {
        // `/foo/` parses as a `Regex` node — one operand. Its two
        // `SLASH` delimiters used to fall through to the shared
        // arithmetic arm and add a `/` operator that is nowhere in the
        // source; #1312 parent-guards them to `Unknown`.
        // expected: u_operators = {def, (, =~, end} = 4, N1 = 4 (only
        // the `(` opener counts after #695 — the `)` closer was
        // dropped; was 5 with the fabricated `/`); u_operands =
        // {f, s, /foo/} = 3, N2 = 4 (`s` twice: parameter and use).
        check_metrics::<RubyParser>("def f(s)\n  s =~ /foo/\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 4);
            assert_eq!(metric.halstead.total_operators(), 4);
            assert_eq!(metric.halstead.unique_operands(), 3);
            assert_eq!(metric.halstead.total_operands(), 4);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_regex_delimiters_are_not_operators() {
        // Regression: issue #1312, the Ruby sibling of Elixir #1256.
        // Both of a `Regex` literal's delimiter tokens are `SLASH` —
        // the same kind id real division uses — so `x = /abc/`
        // reported a `/` operator with no division in the source.
        //
        // expected: operators `=` → n1 = N1 = 1. Operands `x` and the
        // `/abc/` literal → n2 = N2 = 2. Before the guard the two
        // delimiters added `/` → n1 = 2, N1 = 3.
        check_metrics::<RubyParser>("x = /abc/\n", "foo.rb", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 1);
            assert_eq!(metric.halstead.total_operators(), 1);
            assert_eq!(metric.halstead.unique_operands(), 2);
            assert_eq!(metric.halstead.total_operands(), 2);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_regex_delimiter_choice_is_invariant() {
        // Companion to the test above (#1312): `%r`-form regexes are
        // the same literal spelled differently, so every delimiter
        // choice must produce identical counts. tree-sitter-ruby
        // aliases all of them to `SLASH` — verified with `bca dump`,
        // which shows `%r{`/`}`, `%r(`/`)`, `%r[`/`]`, `%r<`/`>`,
        // `%r|`/`|` and `%r!`/`!` every one emitting kind `SLASH` —
        // so each row here genuinely exercises the guard rather than
        // reaching a different, already-clean path.
        //
        // expected per variant: operator `=` → n1 = N1 = 1; operands
        // `x` and the literal → n2 = N2 = 2.
        for literal in [
            "/abc/", "%r{abc}", "%r(abc)", "%r[abc]", "%r<abc>", "%r|abc|", "%r!abc!",
        ] {
            assert_halstead_counts::<RubyParser>(
                &format!("x = {literal}\n"),
                "foo.rb",
                [1, 1, 2, 2],
                &format!("regex literal {literal}"),
            );
        }
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_division_survives_the_regex_guard() {
        // Control for #1312: the guard is scoped to a `Regex` parent,
        // so real division still counts. Two divisions, so a mutant
        // that collapsed repeated hits would move `N1` even though
        // `n1` held (the #1294 count-only-anchor lesson).
        //
        // expected: operators `=` and `/` × 2 → n1 = 2, N1 = 3.
        // Operands `z`, `a`, `b`, `c` → n2 = N2 = 4.
        check_metrics::<RubyParser>("z = a / b / c\n", "foo.rb", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 2);
            assert_eq!(metric.halstead.total_operators(), 3);
            assert_eq!(metric.halstead.unique_operands(), 4);
            assert_eq!(metric.halstead.total_operands(), 4);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_regex_guard_is_parent_scoped_not_ancestor_scoped() {
        // The one input that separates the correct parent-scoped guard
        // from the ancestor-scoped mutant of it (#1312, mirroring
        // #1256's Elixir case): a division *inside* a regex's `#{…}`
        // interpolation. Its `/` has `Binary` as its parent but the
        // `Regex` as a further ancestor, so an ancestor scan would
        // swallow it. Every other fixture in this file passes under
        // both spellings. Two interpolations, so the mutant moves both
        // n1 (2 → 1) and N1 (3 → 1).
        //
        // expected: operators `=`, `/` × 2 → n1 = 2, N1 = 3. Operands
        // `w`, `p`, `q`, `r`, `t` → n2 = N2 = 5; the wrapping `Regex`
        // is skipped because it carries an `Interpolation` child (the
        // #180 double-count guard).
        //
        // Was n1 = 3, N1 = 5 until #1314 dropped `#{` from the operator
        // arm. The mutant still moves both axes, so this fixture is as
        // discriminating as it was — it just no longer counts the two
        // interpolation openers alongside the two divisions.
        check_metrics::<RubyParser>("w = /a#{p / q}c#{r / t}b/\n", "foo.rb", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 2);
            assert_eq!(metric.halstead.total_operators(), 3);
            assert_eq!(metric.halstead.unique_operands(), 5);
            assert_eq!(metric.halstead.total_operands(), 5);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_regex_start_alias_never_reaches_kind_id() {
        // Drift marker for the `R::SLASH2` half of #1312's guard.
        // `SLASH2` is the aliased regex-start token: it sits in the
        // enum beside the other literal-start aliases (`DQUOTE`,
        // `COLONDQUOTE`, `BQUOTE2`, `PERCENTwLPAREN`) and the runtime
        // `public_symbol_map` collapses it to `SLASH` before
        // `kind_id()`, exactly like `LPAREN2` in #768. It is listed in
        // the guard rather than the arithmetic arm because a regex
        // delimiter is the only thing it could ever be; this pins that
        // it is currently unreachable, so a grammar bump that starts
        // emitting it fails here instead of silently changing a metric.
        let path = PathBuf::from("foo.rb");
        for source in ["x = /abc/\n", "x = %r{abc}\n"] {
            let parser = RubyParser::new(source.as_bytes().to_vec(), &path, None);
            assert!(
                !ast_has_kind_id(&parser, Ruby::SLASH2 as u16),
                "Ruby::SLASH2 must stay collapsed to Ruby::SLASH for `{source}`"
            );
            // Positive control: the id the guard actually fires on is
            // present, so the assertion above cannot pass merely
            // because no delimiter was parsed at all.
            assert!(
                ast_has_kind_id(&parser, Ruby::SLASH as u16),
                "Ruby::SLASH must be the delimiter kind for `{source}`"
            );
        }
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_subshell_delimiters_are_not_operators() {
        // Regression: issue #1360, the second delimiter family of the
        // fabrication #1312 removed for regexes. tree-sitter-ruby
        // aliases both ends of a subshell literal to `BQUOTE` — the
        // same kind id the `` def ` `` method-name marker uses — so
        // `` x = `echo hi` `` reported a `` ` `` operator with no
        // backtick method call in the source.
        //
        // expected: operator `=` → n1 = N1 = 1. Operands `x` and the
        // `` `echo hi` `` literal → n2 = N2 = 2. Before the guard the
        // two delimiters added `` ` `` → n1 = 2, N1 = 3.
        assert_halstead_counts::<RubyParser>(
            "x = `echo hi`\n",
            "foo.rb",
            [1, 1, 2, 2],
            "backtick subshell",
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_subshell_delimiter_choice_is_invariant() {
        // Companion to the test above (#1360): `%x`-form subshells are
        // the same literal spelled differently, so every delimiter
        // choice must produce identical counts. tree-sitter-ruby
        // aliases all of them to `BQUOTE` — verified with `bca dump`,
        // which shows `` ` ``/`` ` ``, `%x{`/`}`, `%x(`/`)`, `%x[`/`]`,
        // `%x<`/`>`, `%x|`/`|` and `%x!`/`!` every one emitting kind
        // `BQUOTE` — so each row here genuinely exercises the guard
        // rather than reaching a different, already-clean path. Note
        // the `%x!…!` and `%x|…|` closers in particular: they are
        // `BQUOTE`, not the `BANG` / `PIPE` operators they look like.
        //
        // The empty row records that `` `` `` parses to a `Subshell`
        // holding nothing but its two delimiters, and still bills that
        // wrapper as one operand once both are suppressed. It is
        // documentation, not a discriminator: the guard deletes nothing
        // from the operand arm, so grammar-dispatch §6's
        // childless-variant-regresses-to-zero hazard cannot arise here
        // and this row moves with the first row under every mutant.
        //
        // expected per variant: operator `=` → n1 = N1 = 1; operands
        // `x` and the literal → n2 = N2 = 2.
        for literal in [
            "`echo`", "%x{echo}", "%x(echo)", "%x[echo]", "%x<echo>", "%x|echo|", "%x!echo!", "``",
        ] {
            assert_halstead_counts::<RubyParser>(
                &format!("x = {literal}\n"),
                "foo.rb",
                [1, 1, 2, 2],
                &format!("subshell literal {literal}"),
            );
        }
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_backtick_method_name_survives_the_subshell_guard() {
        // Control for #1360, and the reason the kind is gated rather
        // than dropped from the operator arm (grammar-dispatch §6):
        // `` ` `` is a legal Ruby method name. `bca dump` at the pinned
        // grammar shows `` def `(cmd) `` emitting a `BQUOTE` wrapped in
        // a named `operator` node, so its parent is `Operator` and the
        // parent-scoped guard leaves it alone. Deleting `BQUOTE` from
        // the operator arm would have scored this construct zero.
        //
        // expected: operators `def`, `` ` ``, `(` and `end` →
        // n1 = N1 = 4 (only the `(` opener counts after #695).
        // Operand `cmd` twice, parameter and use → n2 = 1, N2 = 2.
        assert_halstead_counts::<RubyParser>(
            "def `(cmd)\n  cmd\nend\n",
            "foo.rb",
            [4, 4, 1, 2],
            "backtick method name",
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_subshell_guard_is_parent_scoped_not_ancestor_scoped() {
        // The one input that separates the correct parent-scoped guard
        // from the ancestor-scoped mutant of it (#1360, mirroring
        // #1312's regex case): backtick *methods* used inside a
        // subshell's `#{…}` interpolation. Their `BQUOTE` has the named
        // `operator` node as its parent but the `Subshell` as a further
        // ancestor, so an ancestor scan would swallow both. Every other
        // fixture in this file passes under either spelling. Two
        // markers — a definition and a call — so the mutant moves both
        // n1 (7 → 6) and N1 (10 → 8), per the #1294 count-only-anchor
        // lesson.
        //
        // expected: operators `=` (1), `def` (1), `` ` `` (2), `(` (2),
        // `;` (2), `end` (1), `.` (1) → n1 = 7, N1 = 10. Operands `n`,
        // `c` × 2, `s`, `"x"` → n2 = 4, N2 = 5; the wrapping `Subshell`
        // is skipped because it carries `Interpolation` children (the
        // #180 double-count guard), and its `a` / `b` string content is
        // classified by no arm.
        check_metrics::<RubyParser>(
            "n = `a#{def `(c); c; end}b#{s.`(\"x\")}`\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 7);
                assert_eq!(metric.halstead.total_operators(), 10);
                assert_eq!(metric.halstead.unique_operands(), 4);
                assert_eq!(metric.halstead.total_operands(), 5);
            },
        );
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_subshell_start_alias_never_reaches_kind_id() {
        // Drift marker for #1360's guard, the `BQUOTE2` sibling of
        // `ruby_regex_start_alias_never_reaches_kind_id`. `BQUOTE2`
        // sits in the enum's literal-start alias block beside `DQUOTE`,
        // `COLONDQUOTE` and `SLASH2`, and the runtime
        // `public_symbol_map` collapses it to `BQUOTE` before
        // `kind_id()`, exactly like `LPAREN2` in #768.
        //
        // `BQUOTE2` is therefore in no dispatch arm at all — not the
        // guard and not the operator arm — which is the asymmetry with
        // `SLASH2`, a kind #1312 had to *move* out of the arithmetic
        // arm. Adding it to the guard would change nothing, since the
        // wildcard already answers `Unknown` for it. What that leaves
        // unguarded is the reverse direction: a bump that started
        // emitting `BQUOTE2` would drop a subshell opener silently
        // (already the wanted answer) but would also stop counting a
        // `` def ` `` marker spelled that way. This pins the
        // reachability so such a bump fails here rather than moving a
        // metric unobserved.
        let path = PathBuf::from("foo.rb");
        for source in ["x = `echo`\n", "x = %x{echo}\n"] {
            let parser = RubyParser::new(source.as_bytes().to_vec(), &path, None);
            assert!(
                !ast_has_kind_id(&parser, Ruby::BQUOTE2 as u16),
                "Ruby::BQUOTE2 must stay collapsed to Ruby::BQUOTE for `{source}`"
            );
            // Positive control: the id the guard actually fires on is
            // present, so the assertion above cannot pass merely
            // because no delimiter was parsed at all.
            assert!(
                ast_has_kind_id(&parser, Ruby::BQUOTE as u16),
                "Ruby::BQUOTE must be the delimiter kind for `{source}`"
            );
        }
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_interpolation_opener_is_not_an_operator() {
        // Behaviour change, not a fabrication fix: #1314 drops
        // `HASHLBRACE` from Ruby's operator arm. `#{` is a token of its
        // own here — unlike PHP's `{`, which aliases the
        // compound-statement brace — so nothing was being miscounted;
        // the question was whether an interpolation opener is an
        // operation at all, and across the five interpolating languages
        // three already said no. Ruby Halstead operator counts drop for
        // interpolated literals as a result.
        //
        // Asserted as an invariance: the interpolated and plain
        // spellings of one string must now score identically, which is
        // the policy rather than a magic number. Before the change the
        // interpolated row was n1 = 2, N1 = 3.
        //
        // expected per row: operator `=` × 2 → n1 = 1, N1 = 2; operands
        // `s`, `t`, and the literal's content contribution × 2 →
        // n2 = 3, N2 = 4.
        for literal in ["\"a #{y} b\"", "\"a b\""] {
            assert_halstead_counts::<RubyParser>(
                &format!("s = {literal}\nt = {literal}\n"),
                "foo.rb",
                [1, 2, 3, 4],
                &format!("literal {literal}"),
            );
        }
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_interpolation_opener_drop_covers_every_literal() {
        // `HASHLBRACE` is one arm, but it fires under every Ruby
        // literal that interpolates, so the drop is not specific to
        // double-quoted strings. A symbol and a regex — two literals
        // whose `#{…}` reaches the same token — must contribute no
        // operator for the opener either.
        //
        // expected: operator `=` × 3 → n1 = 1, N1 = 3. Operands `y`,
        // `1`, `a`, `b`, plus the two interpolated `y` references →
        // n2 = 4, N2 = 6. Before the change each `#{` added one →
        // n1 = 2, N1 = 5.
        check_metrics::<RubyParser>("y = 1\na = :\"s#{y}\"\nb = /r#{y}/\n", "foo.rb", |metric| {
            assert_eq!(metric.halstead.unique_operators(), 1);
            assert_eq!(metric.halstead.total_operators(), 3);
            assert_eq!(metric.halstead.unique_operands(), 4);
            assert_eq!(metric.halstead.total_operands(), 6);
        });
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_element_containers_count_elements_not_the_composite_1353() {
        // #1353. `chained_string`, `string_array` and `symbol_array`
        // hold *classified operand* children instead of the raw
        // `string_content` every other string-like literal wraps, so
        // the arm's shared `Interpolation` guard never fired and the
        // wrapper was billed alongside each element. Every row below
        // scored n2 4 / N2 4 for three operands, the extra entry being
        // the wrapper's whole-span text — which made the vocabulary
        // depend on how the author grouped the literals.
        //
        // `assert_ops_operands` pins the operand *text*, not just the
        // count: a wrapper coming back would show up as `"one" "two"` /
        // `%w[x y]` / `%i[p q]` rather than as an off-by-one number.
        //
        // The kind assertions are the grammar-dispatch §1 / §2 drift
        // marker — a bump that renumbers a wrapper or an element would
        // otherwise leave these counts passing while measuring a
        // construct the arm no longer names.
        //
        // Two of the three rows also pin the arm's *membership*:
        // dropping `StringArray` or `SymbolArray` from it fails
        // `ruby_empty_word_and_symbol_arrays_still_bill_one_operand_1353`.
        // `ChainedString`'s membership is unobservable and no test can
        // pin it — `repeat1($.string)` guarantees the guard always
        // fires, so `Unknown` and "not in the arm at all" are the same
        // answer for every input. It is listed for symmetry with its
        // siblings, and correct-by-construction is the only defence
        // available there.
        for (source, wrapper, element, operands) in [
            (
                "a = \"one\" \"two\"\n",
                Ruby::ChainedString,
                Ruby::String,
                vec!["a", "\"one\"", "\"two\""],
            ),
            (
                "b = %w[x y]\n",
                Ruby::StringArray,
                Ruby::BareString,
                vec!["b", "x", "y"],
            ),
            (
                "c = %i[p q]\n",
                Ruby::SymbolArray,
                Ruby::BareSymbol,
                vec!["c", "p", "q"],
            ),
        ] {
            let parser =
                RubyParser::new(source.as_bytes().to_vec(), &PathBuf::from("foo.rb"), None);
            assert!(
                ast_has_kind_id(&parser, wrapper as u16),
                "the container kind this arm gates on is unreachable for `{source}`"
            );
            assert!(
                ast_has_kind_id(&parser, element as u16),
                "the element kind this arm gates on is unreachable for `{source}`"
            );

            // expected: operator `=` → n1 = N1 = 1; operands are the
            // assignment target and the two elements → n2 = N2 = 3.
            assert_halstead_counts::<RubyParser>(source, "foo.rb", [1, 1, 3, 3], source);
            assert_ops_operands::<RubyParser>(source, "foo.rb", 3, operands);
        }
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_empty_word_and_symbol_arrays_still_bill_one_operand_1353() {
        // The childless spelling, and the whole reason #1353 gates the
        // three container kinds instead of dropping them from the arm
        // (grammar-dispatch §6). `%w[]` / `%i[]` parse to a wrapper
        // holding nothing but its two delimiter tokens, so the tempting
        // "just delete the wrapper" fix — the one #1351 was right to
        // take for Bash's `command_name` — would score an empty literal
        // zero operands where the source plainly has a literal. This is
        // the assertion to watch fail against that alternative.
        //
        // expected: operator `=` → n1 = N1 = 1; operands the assignment
        // target and the empty literal itself → n2 = N2 = 2.
        for (source, operands) in [
            ("d = %w[]\n", vec!["d", "%w[]"]),
            ("e = %i[]\n", vec!["e", "%i[]"]),
        ] {
            assert_halstead_counts::<RubyParser>(source, "foo.rb", [1, 1, 2, 2], source);
            assert_ops_operands::<RubyParser>(source, "foo.rb", 2, operands);
        }
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_interpolated_array_elements_are_not_double_counted_1353() {
        // `bare_string` and `bare_symbol` are two aliases of a single
        // grammar production (`_literal_contents`), one per array form,
        // so `%W[…]` and `%I[…]` must score identically. Until #1353
        // only `bare_string` carried the interpolation guard and
        // `bare_symbol` sat in the plain operand arm, so `%I[a#{n}b c]`
        // billed the element `a#{n}b` *and* the `n` inside it (n2 4)
        // where `%W[a#{n}b c]` billed 3.
        //
        // Asserted as an invariance over the two spellings, the way
        // `ruby_interpolation_opener_is_not_an_operator` is — the
        // policy is the claim, not the magic number. The third row is
        // the composed case: a `chained_string` whose own guard defers
        // to an element that is itself interpolated.
        //
        // expected per row: operator `=` → n1 = N1 = 1; operands the
        // assignment target, the interpolated expression `n`, and the
        // one inert element → n2 = N2 = 3. The operand *text* is pinned
        // too, because 3 is also the count an implementation that
        // suppressed the inert element instead of the wrapper would
        // report.
        for (source, operands) in [
            ("w = %W[a#{n}b c]\n", vec!["w", "n", "c"]),
            ("w = %I[a#{n}b c]\n", vec!["w", "n", "c"]),
            ("a = \"x#{n}\" \"y\"\n", vec!["a", "n", "\"y\""]),
        ] {
            assert_halstead_counts::<RubyParser>(source, "foo.rb", [1, 1, 3, 3], source);
            assert_ops_operands::<RubyParser>(source, "foo.rb", 3, operands);
        }
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_suffixed_numeric_literals_bill_one_operand_1359() {
        // #1359, the wrapper/leaf double count one arm below #1353's.
        // `rational` and `complex` wrap the numeral they suffix, and
        // `get_op_type` billed every level: `a = 1r` scored n2 3 / N2 3
        // for two operands, and `c = 3ri` — a `complex` over a
        // `rational` over an `integer` — scored n2 3 / N2 4 for the
        // same two.
        //
        // The rows are ordered by nesting depth on purpose, because the
        // half-fix is a plausible one to write. Guard the two leaf
        // kinds and not the intermediate `rational` — `R::Integer |
        // R::Float` where the arm says `R::Integer | R::Float |
        // R::Rational` — and the `1r` and `2i` rows still pass; the
        // `ri` rows, whose middle `rational` must be suppressed as well
        // as the leaf beneath it, are the two that fail (measured:
        // `c = 3ri` reports n2 3 / N2 3).
        //
        // The trailing rows are the ones that must *not* move. `g = 4`
        // has no wrapper at all and pins that the guard is scoped to
        // the numerals inside one (grammar-dispatch §6 — nothing
        // regresses to zero). `"#{4r}"` and `-3r` put the wrapper
        // somewhere other than an assignment right-hand side, under a
        // node that guards its own children (`Interpolation`, whose
        // enclosing `String` is suppressed by the arm above) and under
        // one that does not (`unary`); both must still bill the
        // wrapper once. They do *not* pin parent-versus-ancestor
        // scoping and nothing can: `complex` and `rational` admit
        // numeral children only, so an ancestor-scoped guard would
        // classify every Ruby input identically. And `1r + 1r` is the
        // row where N2 and n2 come apart, so the `N2` column is
        // load-bearing on its own rather than tracking `n2`.
        //
        // The kind assertions are the grammar-dispatch §1 / §2 drift
        // marker: a bump that renumbered `complex` or `rational`, or
        // stopped nesting them, would leave the counts passing while
        // measuring a construct the guard no longer names. `IntOrFloat`
        // is the §2 half — the hidden `_int_or_float` the two wrappers
        // are written over, which a bump could promote into the
        // numeral's parent and silently stop the guard firing. Not
        // every kind a row mentions is one the guard names
        // (`Interpolation` is context), and `unary` and `binary` are
        // deliberately absent: they carry five and three aliased
        // variants here, so naming one would pin the alias rather than
        // the shape.
        for (source, kinds, counts, operands) in [
            (
                "a = 1r\n",
                &[Ruby::Rational as u16, Ruby::Integer as u16][..],
                [1, 1, 2, 2],
                vec!["a", "1r"],
            ),
            (
                "b = 2i\n",
                &[Ruby::Complex as u16, Ruby::Integer as u16][..],
                [1, 1, 2, 2],
                vec!["b", "2i"],
            ),
            (
                "c = 3ri\n",
                &[
                    Ruby::Complex as u16,
                    Ruby::Rational as u16,
                    Ruby::Integer as u16,
                ][..],
                [1, 1, 2, 2],
                vec!["c", "3ri"],
            ),
            (
                "d = 1.5r\n",
                &[Ruby::Rational as u16, Ruby::Float as u16][..],
                [1, 1, 2, 2],
                vec!["d", "1.5r"],
            ),
            (
                "e = 2.5i\n",
                &[Ruby::Complex as u16, Ruby::Float as u16][..],
                [1, 1, 2, 2],
                vec!["e", "2.5i"],
            ),
            (
                "f = 1.5ri\n",
                &[
                    Ruby::Complex as u16,
                    Ruby::Rational as u16,
                    Ruby::Float as u16,
                ][..],
                [1, 1, 2, 2],
                vec!["f", "1.5ri"],
            ),
            (
                "g = 4\n",
                &[Ruby::Integer as u16][..],
                [1, 1, 2, 2],
                vec!["g", "4"],
            ),
            (
                "h = \"#{4r}\"\n",
                &[Ruby::Interpolation as u16, Ruby::Rational as u16][..],
                [1, 1, 2, 2],
                vec!["h", "4r"],
            ),
            (
                "i = -3r\n",
                &[Ruby::Rational as u16, Ruby::Integer as u16][..],
                [2, 2, 2, 2],
                vec!["i", "3r"],
            ),
            (
                "j = 1r + 1r\n",
                &[Ruby::Rational as u16, Ruby::Integer as u16][..],
                [2, 2, 2, 3],
                vec!["j", "1r"],
            ),
        ] {
            let parser =
                RubyParser::new(source.as_bytes().to_vec(), &PathBuf::from("foo.rb"), None);
            for kind in kinds {
                assert!(
                    ast_has_kind_id(&parser, *kind),
                    "the kind this row measures is unreachable for `{source}`"
                );
            }
            assert!(
                !ast_has_kind_id(&parser, Ruby::IntOrFloat as u16),
                "`_int_or_float` is hidden; a grammar that emits it would \
                 sit between the wrapper and the numeral for `{source}`"
            );

            assert_halstead_counts::<RubyParser>(source, "foo.rb", counts, source);
            assert_ops_operands::<RubyParser>(source, "foo.rb", operands.len(), operands);
        }
    }

    #[cfg(feature = "ruby")]
    #[test]
    fn ruby_numeric_suffixes_stay_distinct_operands_1359() {
        // The reason #1359 keeps the *wrapper* and gates the leaf
        // rather than dropping the two wrapper kinds from the arm, as
        // #1351 and #1358 did for their Bash wrappers. `1`, `1r`, `1i`
        // and `1ri` are four distinct Ruby constants — Integer,
        // Rational, Complex and Complex-of-Rational — and only the
        // wrapper's span carries the suffix that says which.
        //
        // This is the assertion to watch fail against the leaf-keeping
        // alternative: billing the `integer` would file all four under
        // the operand text `1`, reporting n2 5 / N2 8 where the source
        // plainly has eight distinct operands. The count alone does not
        // say that, so the vocabulary is pinned by text.
        //
        // expected: operator `=` → n1 1, N1 4; four targets and four
        // constants, none repeated → n2 = N2 = 8.
        let source = "w = 1\nx = 1r\ny = 1i\nz = 1ri\n";
        assert_halstead_counts::<RubyParser>(source, "foo.rb", [1, 4, 8, 8], source);
        assert_ops_operands::<RubyParser>(
            source,
            "foo.rb",
            8,
            vec!["w", "x", "y", "z", "1", "1r", "1i", "1ri"],
        );
    }

    /// Comprehensive iRules Halstead test exercising every operator family
    /// classified in `get_op_type`: declaration/control keywords (`proc`,
    /// `set`, `if`, `return`), structural punctuation (`{}` `[]` `()`),
    /// arithmetic (`+`), comparison (`>`), the word-form string comparator
    /// (`eq`), and short-circuit logical (`&&`). Anchored on the integer
    /// `n1`/`N1`/`n2`/`N2` headline values; the float fields are derived and
    /// bit-brittle, so they are not pinned.
    ///
    /// The second half pins the lesson-4 invariant: the independent
    /// text-keyed `operands_and_operators` store must dedupe to the same
    /// `n1`/`n2`. A classification change that moved one store without the
    /// other (e.g. a kind landing in both the operator and operand arms)
    /// would break this even though the snapshot stayed green.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_operators_and_operands() {
        let source = "proc f { a b } {
    set x [expr { $a + $b }]
    if { $x > 0 && $a eq \"go\" } {
        return $x
    }
    return 0
}
";
        check_metrics::<IrulesParser>(source, "foo.irule", |metric| {
            // After #695 only opening delimiters count: the `}`/`]`
            // closers no longer add operators (was 12 unique / 20 total).
            assert_eq!(metric.halstead.unique_operators(), 10);
            assert_eq!(metric.halstead.total_operators(), 14);
            // Operands fell 12 / 16 → 10 / 14 with #1354: the proc body
            // and the `if` body are `BracedWord` script kinds and are no
            // longer operands beside the commands they contain.
            assert_eq!(metric.halstead.unique_operands(), 10);
            assert_eq!(metric.halstead.total_operands(), 14);
        });

        let path = PathBuf::from("foo.irule");
        let parser = IrulesParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        let unique_operators: HashSet<&str> = ops.operators.iter().map(String::as_str).collect();
        let unique_operands: HashSet<&str> = ops.operands.iter().map(String::as_str).collect();
        assert_eq!(
            unique_operators.len(),
            10,
            "dedupe(ops.operators) must equal n1; operators were {:?}",
            ops.operators
        );
        assert_eq!(
            unique_operands.len(),
            10,
            "dedupe(ops.operands) must equal n2; operands were {:?}",
            ops.operands
        );
    }

    /// An inert `"hello world"` double-quoted string (no `$var` / `[cmd]`
    /// interpolation child) contributes exactly **one** operand — the
    /// wrapping `QuotedWord`. Operands are `f`, `s` and `"hello world"` —
    /// n2 = 3, the same as Tcl since #1294 restored its `set` target to
    /// the operand count and #1354 dropped the proc-body `braced_word`
    /// from both. Mirrors `tcl_inert_quoted_word_counts_as_operand`
    /// (#277).
    #[cfg(feature = "irules")]
    #[test]
    fn irules_inert_quoted_word_counts_as_operand() {
        let source = "proc f {} {\n    set s \"hello world\"\n}\n";
        check_metrics::<IrulesParser>(source, "foo.irule", |metric| {
            // After #695 only the `{` opener counts; the `}` closer no
            // longer adds an operator (was 4 unique / 6 total).
            assert_eq!(metric.halstead.unique_operators(), 3);
            assert_eq!(metric.halstead.total_operators(), 4);
            assert_eq!(metric.halstead.unique_operands(), 3);
            assert_eq!(metric.halstead.total_operands(), 3);
        });

        let path = PathBuf::from("foo.irule");
        let parser = IrulesParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        // The inert quoted word is present as exactly one operand (not
        // dropped, not split): dropping it would mean the inert branch was
        // over-guarded.
        let quoted = ops
            .operands
            .iter()
            .filter(|o| o.as_str() == "\"hello world\"")
            .count();
        assert_eq!(quoted, 1, "inert quoted word must be one operand");
        let unique_operands: HashSet<&str> = ops.operands.iter().map(String::as_str).collect();
        assert_eq!(unique_operands.len(), 3, "operands were {:?}", ops.operands);
    }

    /// Regression for the `QuotedWord` interpolation guard (the #277 /
    /// Bash-#180 / C#-#183 / PHP-#184 pattern). An interpolated
    /// `"$x is $y"` must contribute **zero** operands for the wrapping
    /// `QuotedWord`; the inner `$x` / `$y` `variable_substitution` nodes are
    /// walked separately and count on their own. Operands are `f`, `x`, `y`,
    /// `s`, `$x`, `$y` = 6 (7 before #1354 dropped the proc-body
    /// `braced_word`). If the guard regressed (wrapper classified
    /// `Operand`), the wrapper string would add a 7th operand. This is the
    /// branch that had no test before.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_interpolated_quoted_word_no_double_count() {
        let source = "proc f {x y} {\n    set s \"$x is $y\"\n}\n";
        check_metrics::<IrulesParser>(source, "foo.irule", |metric| {
            // After #695 only the `{` opener counts; the `}` closer no
            // longer adds an operator (was 4 unique / 6 total).
            assert_eq!(metric.halstead.unique_operators(), 3);
            assert_eq!(metric.halstead.total_operators(), 4);
            assert_eq!(metric.halstead.unique_operands(), 6);
            assert_eq!(metric.halstead.total_operands(), 6);
        });

        let path = PathBuf::from("foo.irule");
        let parser = IrulesParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        // The wrapping interpolated string must NOT appear as an operand;
        // its inner substitutions must. The wrapper, if wrongly counted,
        // would surface as the quoted literal `"$x is $y"` (with quotes,
        // like the inert `"hello world"` operand). Match that exact token —
        // a substring check would false-match the proc-body `braced_word`
        // operand, which legitimately contains the source text.
        assert!(
            !ops.operands.iter().any(|o| o.as_str() == "\"$x is $y\""),
            "interpolated wrapper must not be an operand; operands were {:?}",
            ops.operands
        );
        assert!(
            ops.operands.iter().any(|o| o.as_str() == "$x")
                && ops.operands.iter().any(|o| o.as_str() == "$y"),
            "inner $x / $y substitutions must each be operands; operands were {:?}",
            ops.operands
        );
        let unique_operands: HashSet<&str> = ops.operands.iter().map(String::as_str).collect();
        assert_eq!(unique_operands.len(), 6, "operands were {:?}", ops.operands);
    }

    /// Exercises the operator families not covered by
    /// `irules_operators_and_operands`: bitwise (`& | ^ ~ << >>`), ternary
    /// (`? :`), the keyword string comparators (`starts_with`, `ends_with`,
    /// `contains`, `matches`, `eq`, `ne`), and the keyword logical operator
    /// (`and`). Pins every operator-family arm in `get_op_type` plus the
    /// lesson-4 dedupe invariant.
    #[cfg(feature = "irules")]
    #[test]
    fn irules_bitwise_ternary_string_ops() {
        let source = "proc f { a b } {
    set bits [expr { $a & $b | $a ^ ~$b }]
    set sh [expr { $a << 2 | $b >> 1 }]
    set t [expr { $a > 0 ? $a : $b }]
    if { $a starts_with \"x\" && $b ends_with \"y\" } { return 1 }
    if { $a contains \"z\" || $b matches \"q\" } { return 2 }
    if { $a eq \"m\" and $b ne \"n\" } { return 3 }
    return $b
}
";
        check_metrics::<IrulesParser>(source, "foo.irule", |metric| {
            // After #695 only opening delimiters count: the `}`/`]`
            // closers no longer add operators (was 26 unique / 57 total).
            assert_eq!(metric.halstead.unique_operators(), 24);
            assert_eq!(metric.halstead.total_operators(), 43);
            // Operands fell 23 / 42 → 19 / 38 with #1354: the proc body
            // and the three single-statement `if` bodies are
            // `BracedWord` script kinds and no longer count as operands.
            assert_eq!(metric.halstead.unique_operands(), 19);
            assert_eq!(metric.halstead.total_operands(), 38);
        });

        let path = PathBuf::from("foo.irule");
        let parser = IrulesParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        let unique_operators: HashSet<&str> = ops.operators.iter().map(String::as_str).collect();
        let unique_operands: HashSet<&str> = ops.operands.iter().map(String::as_str).collect();
        assert_eq!(
            unique_operators.len(),
            24,
            "dedupe(ops.operators) must equal n1; operators were {:?}",
            ops.operators
        );
        assert_eq!(
            unique_operands.len(),
            19,
            "dedupe(ops.operands) must equal n2; operands were {:?}",
            ops.operands
        );
    }

    /// A bare `$x` produces one `variable_substitution` operand. Its inner
    /// `id` leaf (the *named* `Id` node — not the anonymous `Id2` token Tcl
    /// has there) must NOT be counted separately, or every variable
    /// reference double-counts. `get_op_type` excludes `Id` whose parent is
    /// a `VariableSubstitution`. Operands: `f`, the proc arg `x`, `return`
    /// and `$x` — four, with no duplicate (`total_operands()` == 4; the
    /// proc-body `braced_word` was a fifth before #1354). If the guard
    /// regressed, the inner `id` "x" would add a fifth operand occurrence
    /// (it text-collides with the proc arg `x`, so `u_operands` would stay
    /// 4 but `total_operands()` would rise to 5 — hence the total, not just
    /// the unique count, is asserted).
    #[cfg(feature = "irules")]
    #[test]
    fn irules_array_reference_bills_the_reference_and_the_index() {
        // The iRules twin of
        // `tcl_array_reference_bills_the_reference_and_the_index`. Until
        // `ArrayIndex` left the operand arm this fixture billed `(k)` and
        // `($i)` beside the six operands below — the grammar-dispatch §5
        // wrapper-plus-leaf count, and a divergence from Tcl.
        assert_ops_operands::<IrulesParser>(
            "set arr(k) 1\nset z \"$arr($i)\"\n",
            "foo.irule",
            6,
            vec!["arr", "k", "1", "z", "$arr($i)", "$i"],
        );
    }

    #[cfg(feature = "irules")]
    #[test]
    fn irules_bare_variable_operand() {
        let source = "proc f {x} {\n    return $x\n}\n";
        check_metrics::<IrulesParser>(source, "foo.irule", |metric| {
            // After #695 only the `{` opener counts (folded `{}`); the
            // `}` closer no longer adds an operator (was 3 unique / 5 total).
            assert_eq!(metric.halstead.unique_operators(), 2);
            assert_eq!(metric.halstead.total_operators(), 3);
            assert_eq!(metric.halstead.unique_operands(), 4);
            assert_eq!(metric.halstead.total_operands(), 4);
        });

        let path = PathBuf::from("foo.irule");
        let parser = IrulesParser::new(source.as_bytes().to_vec(), &path, None);
        let ops = crate::ops::ops_inner(&parser, None).expect("ops walk succeeds");
        let bare_var = ops.operands.iter().filter(|o| o.as_str() == "$x").count();
        assert_eq!(
            bare_var, 1,
            "bare $x must be exactly one operand (inner id leaf not double-counted); operands were {:?}",
            ops.operands
        );
    }

    #[cfg(feature = "irules")]
    #[test]
    fn irules_braced_word_delimiter_is_not_an_operator() {
        // Regression: issue #1314. The iRules twin of
        // `tcl_braced_word_delimiter_is_not_an_operator` — the two
        // getters are deliberate clones, so the guard lands in both and
        // is asserted in both.
        //
        // One fixture covers the guard and its control: `{braced word}`
        // and `{y}` are values whose openers must not count, while the
        // handler body, the `if` condition and the `if` body are
        // `BracedWord` / `Expr` and must keep theirs. A guard keyed on
        // the brace alone would take `{}` out of the operator set
        // entirely and fail here.
        //
        // expected: operators `when`, `set` × 2, `if`, `contains`,
        // `[]`, `{}` × 3 → n1 = 6, N1 = 9. Every operand is distinct →
        // n2 = N2 = 7: `HTTP_REQUEST`, `a`, `b`, `HTTP::uri`, `"x"` and
        // the two braced words `{braced word}` and `{y}`. Before the
        // guard the two value openers added two more `{}` occurrences →
        // N1 = 11; before #1354 the handler and `if` bodies and the
        // inner `braced` / `word` / `y` were operands too → n2 = 12.
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST {\n  set a {braced word}\n  if {[HTTP::uri] contains \"x\"} { set b {y} }\n}\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.halstead.unique_operators(), 6);
                assert_eq!(metric.halstead.total_operators(), 9);
                assert_eq!(metric.halstead.unique_operands(), 7);
                assert_eq!(metric.halstead.total_operands(), 7);
            },
        );
    }

    /// Regression for #563: the two Halstead `Display` labels must use the
    /// underscore key that matches the JSON/CSV field name, so a user can grep
    /// the same token across `Display` and JSON. The space-separated forms
    /// (`estimated program length` / `purity ratio`) were the only outliers,
    /// mirroring the `dump` fix in #562.
    #[cfg(feature = "cpp")]
    #[test]
    fn display_halstead_labels_use_underscore_keys() {
        check_metrics::<CppParser>("int a = 42;", "foo.cpp", |metric| {
            let out = metric.halstead.to_string();
            assert!(
                out.contains("estimated_program_length: "),
                "Display must use the underscore key `estimated_program_length`:\n{out}"
            );
            assert!(
                out.contains("purity_ratio: "),
                "Display must use the underscore key `purity_ratio`:\n{out}"
            );
            assert!(
                !out.contains("estimated program length"),
                "Display must not emit the space-separated `estimated program length`:\n{out}"
            );
            assert!(
                !out.contains("purity ratio"),
                "Display must not emit the space-separated `purity ratio`:\n{out}"
            );
        });
    }

    /// `@"…"` is one `string_literal` holding its `@` as a child, so the
    /// literal is the operand, keyed by its whole text, and the marker is
    /// not an operator on top — it was, which planted a phantom `@` in
    /// n1 for a file whose only `@` was in NSString literals and billed
    /// the same byte in both streams. Boxing (`@42`) keeps its `@`: there
    /// the token is a child of the `at_expression`, not of the literal.
    #[cfg(feature = "objc")]
    #[test]
    fn objc_nsstring_literal_is_one_operand() {
        // expected: [n1, N1, n2, N2]. Before the guard the first two rows
        // read [8, 8, 5, 5] and [8, 9, 6, 6] — one `@` operator per
        // literal; the boxing control is unchanged.
        let cases = [
            ("NSString *s = @\"str\";", [7, 7, 5, 5]),
            ("NSString *t = @\"x\" @\"y\";", [7, 7, 6, 6]),
            ("NSNumber *n = @42;", [8, 8, 5, 5]),
        ];
        for (body, counts) in cases {
            let source = format!("@implementation Foo\n- (void)m {{\n    {body}\n}}\n@end\n");
            assert_halstead_counts::<ObjcParser>(&source, "foo.m", counts, body);
        }
        assert_ops_operands::<ObjcParser>(
            "@implementation Foo\n- (void)m {\n    NSString *s = @\"str\";\n}\n@end\n",
            "foo.m",
            5,
            vec!["Foo", "m", "NSString", "s", "@\"str\""],
        );
    }

    /// Comprehensive Objective-C Halstead fixture exercising a message
    /// send (`[self log:@"hi"]`), an ObjC string literal (`@"hi"`), an
    /// `if`, a short-circuit `&&`, arithmetic (`+`), comparisons, and
    /// assignment. Pins every field and enforces the lesson-4 invariants
    /// `unique_operators == n1` / `unique_operands == n2` via the
    /// independent `--ops` store.
    #[cfg(feature = "objc")]
    #[test]
    fn objc_operators_and_operands() {
        let source = "@implementation Foo
- (int)bar:(int)x {
    int y = x + 1;
    if (x > 0 && y < 10) {
        [self log:@\"hi\"];
    }
    return y;
}
@end
";
        check_metrics::<ObjcParser>(source, "foo.m", |metric| {
            // n1 = 14 unique operators:
            //   `&&`, `()`, `+`, `-`, `:`, `;`, `<`, `=`, `>`,
            //   `[]` (message send), `if`, `int`, `return`, `{}`.
            //   The `@` of `@"hi"` is part of the literal's operand
            //   key, not an operator (see `objc_nsstring_literal_is_one_operand`).
            // n2 = 10 unique operands:
            //   `Foo`, `bar`, `log`, `self`, `x`, `y`, `0`, `1`, `10`,
            //   `@"hi"` (the ObjC string literal).
            assert_eq!(metric.halstead.unique_operators(), 14);
            assert_eq!(metric.halstead.unique_operands(), 10);
            insta::assert_json_snapshot!(metric.halstead, @r#"
            {
              "unique_operators": 14,
              "total_operators": 22,
              "unique_operands": 10,
              "total_operands": 14,
              "length": 36,
              "estimated_program_length": 86.52224985768008,
              "purity_ratio": 2.403395829380002,
              "vocabulary": 24,
              "volume": 165.0586500259616,
              "difficulty": 9.8,
              "level": 0.1020408163265306,
              "effort": 1617.5747702544238,
              "time": 89.86526501413465,
              "bugs": 0.04593266617952463
            }
            "#);
        });
        // Lesson-4 invariant: dedupe(ops.operands) == n2 (10), via the
        // independent text-keyed `--ops` store.
        assert_ops_operands::<ObjcParser>(
            source,
            "foo.m",
            10,
            vec![
                "Foo", "bar", "log", "self", "x", "y", "0", "1", "10", "@\"hi\"",
            ],
        );
    }

    /// #1316 fixture separating the vocabulary and occurrence axes
    /// (#1294): `'x'` appears twice, so a correct fix adds four `n2`
    /// entries and five `N2` hits. The `'ab'` multi-character constant
    /// is also the grammar-dispatch section 5 pin — that literal carries
    /// *two* `character` children and must still bill one operand.
    ///
    /// Both #1316 fixtures are plain C, which every C-family grammar
    /// parses to the same shape, so one source proves the same thing
    /// about each of the four clones.
    #[cfg(any(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
    const C_FAMILY_CHAR_REPEATS: &str =
        "char a = 'x';\nchar b = 'x';\nchar c = 'y';\nchar d = '\\n';\nint e = 'ab';\n";

    /// #1316 fixture holding all five spellings the grammars admit. Each
    /// opens on a distinct delimiter kind (`'`, `L'`, `u'`, `U'`, `u8'`),
    /// and operands key on source text, so the five are five vocabulary
    /// entries rather than one.
    #[cfg(any(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
    const C_FAMILY_CHAR_PREFIXES: &str =
        "char a = 'x';\nchar b = L'x';\nchar c = u'x';\nchar d = U'x';\nchar e = u8'x';\n";

    /// Asserts both #1316 fixtures for one C-family language, through
    /// the metrics store *and* the text-keyed `--ops` store (the
    /// lesson-4 invariant `n2 == len(dedupe(ops.operands))`).
    ///
    /// The `--ops` half pins *which text* each literal is billed under,
    /// which the counts cannot see: billing a literal's `character`
    /// payload instead of the whole literal keeps `n2` at 9 while the
    /// vocabulary silently becomes `x` rather than `'x'`. (Billing
    /// *both* is caught earlier, by the counts.) It is a second *walk*
    /// rather than a second classification — `ops_inner` reads the keys
    /// of the same `HalsteadMaps` — which is worth knowing before
    /// reading it as independent corroboration of the count.
    #[cfg(any(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
    #[track_caller]
    fn assert_char_literal_operands<T: crate::MetricSuite>(file: &str, label: &str) {
        // `char` x4 and `int` are text-keyed primitive operators, so
        // n1 = 4 (`;`, `=`, `char`, `int`) and N1 = 5 + 5 + 4 + 1.
        // Operands: `a`..`e`, plus `'x'` (twice), `'y'`, `'\n'`, `'ab'`.
        let repeats = format!("{label}: repeated / escaped / multi-char literals");
        assert_halstead_counts::<T>(C_FAMILY_CHAR_REPEATS, file, [4, 15, 9, 10], &repeats);
        assert_ops_operands::<T>(
            C_FAMILY_CHAR_REPEATS,
            file,
            9,
            vec!["a", "b", "c", "d", "e", "'x'", "'y'", "'\\n'", "'ab'"],
        );

        // Every declaration is `char` here, so the `int` primitive
        // operator of the other fixture is gone and n1 drops to 3. Ten
        // distinct operands, each seen once.
        let prefixes = format!("{label}: L / u / U / u8 prefixed literals");
        assert_halstead_counts::<T>(C_FAMILY_CHAR_PREFIXES, file, [3, 15, 10, 10], &prefixes);
        assert_ops_operands::<T>(
            C_FAMILY_CHAR_PREFIXES,
            file,
            10,
            vec![
                "a", "b", "c", "d", "e", "'x'", "L'x'", "u'x'", "U'x'", "u8'x'",
            ],
        );
    }

    /// Regression for #1316: a C-family character literal is a Halstead
    /// operand.
    ///
    /// `char_literal` was in no arm of `CCode` / `CppCode` /
    /// `MozcppCode` / `ObjcCode`'s `get_op_type`, so a character literal
    /// contributed *nothing* — not an operator (correct) and not an
    /// operand (wrong) — while Rust, Java, Kotlin, C#, Go and Elixir all
    /// counted theirs. Both fixtures measured `n2` 5, `N2` 5 before the
    /// fix: the five declared identifiers and not one literal.
    ///
    /// Each language asserts separately over the same source rather than
    /// sharing one call, so reverting one clone's arm fails that row
    /// alone (grammar-dispatch section 11) — verified by perturbing each
    /// of the four arms in turn. A single shared assertion would be
    /// satisfied by whichever clone still had the arm.
    ///
    /// Mozcpp owns no file extension, so no integration snapshot ever
    /// reaches its clone; its row is the whole coverage that arm has.
    #[cfg(all(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
    #[test]
    fn c_family_char_literals_are_operands() {
        assert_char_literal_operands::<CParser>("chars.c", "c");
        assert_char_literal_operands::<CppParser>("chars.cpp", "cpp");
        assert_char_literal_operands::<MozcppParser>("chars.cpp", "mozcpp");
        assert_char_literal_operands::<ObjcParser>("chars.m", "objc");
    }

    /// ObjC boxes a character literal as `@'y'` — an `at_expression`
    /// wrapping the same `char_literal`, with the `@` counted as its own
    /// operator. The wrapper is in no operand arm, so the boxed form
    /// bills exactly the literal it wraps and stays distinct from a bare
    /// one (#1316).
    #[cfg(feature = "objc")]
    #[test]
    fn objc_boxed_char_literal_is_one_operand() {
        let source = "char a = 'x';\nid b = @'y';\n";
        // n1: `char`, `=`, `;`, `@`. N1: 1 + 2 + 2 + 1.
        // n2 / N2: `a`, `b`, `'x'`, `'y'` — `id` is a `typedefed_specifier`
        // and is classified by neither arm. Before #1316 this was n2 2,
        // N2 2.
        assert_halstead_counts::<ObjcParser>(source, "boxed.m", [4, 6, 4, 4], "objc @'y'");
        assert_ops_operands::<ObjcParser>(source, "boxed.m", 4, vec!["a", "b", "'x'", "'y'"]);
    }

    /// Walks both #1316 fixtures under all four C-family `Getter`s and
    /// pins the two grammar facts the new operand arm rests on.
    ///
    /// * **Grammar-dispatch section 1.** In the positions these
    ///   fixtures exercise, every node the grammar spells `char_literal`
    ///   carries the one `kind_id` the arm lists. That is the weaker
    ///   half of the alias evidence — an alias arises in a *different*
    ///   syntactic position, which no fixture can enumerate. The strong
    ///   half is that these generated enums do carry numeric-suffix
    ///   aliases in quantity (`language_c.rs` alone has ninety) and none
    ///   of the four spells a `CharLiteral2`, so its absence is a
    ///   measurement rather than a silence. This loop is what notices if
    ///   a grammar bump changes that under an existing fixture.
    /// * **Grammar-dispatch section 5.** No child of a `char_literal` is
    ///   classified. That is what makes listing the wrapper safe rather
    ///   than a wrapper/leaf double count: the opening delimiter, the
    ///   closing `'`, and the `character` / `escape_sequence` payload
    ///   must all stay `Unknown`, or every literal would bill two
    ///   operands and a prefixed one three.
    ///
    /// Both loops are non-vacuous by assertion, since a fixture that
    /// stopped containing a character literal would otherwise make this
    /// test pass having checked nothing.
    #[cfg(all(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
    #[test]
    fn c_family_char_literal_internals_stay_unclassified() {
        #[cfg(any(feature = "c", feature = "cpp", feature = "mozcpp", feature = "objc"))]
        fn check<L: LanguageInfo + Getter>(char_literal: u16, label: &str) {
            let mut literals = 0_usize;
            let mut children = 0_usize;
            for source in [C_FAMILY_CHAR_REPEATS, C_FAMILY_CHAR_PREFIXES] {
                for_each_node_with_chain::<L>(source.as_bytes(), |node, chain| {
                    if node.kind() == "char_literal" {
                        assert_eq!(
                            node.kind_id(),
                            char_literal,
                            "{label}: a `char_literal` carries kind_id {} rather than the \
                             {char_literal} the operand arm lists — an alias the arm cannot see",
                            node.kind_id()
                        );
                        literals += 1;
                    }
                    if chain
                        .last()
                        .is_none_or(|parent| parent.kind_id() != char_literal)
                    {
                        return;
                    }
                    children += 1;
                    // `_with_code` is the spelling `compute_halstead`
                    // calls. The default forwards to the byte-less form,
                    // so today the two agree for every C-family
                    // language — which is exactly why asking the wrong
                    // one would read as correct right up until one of
                    // these four grew an override (grammar-dispatch
                    // section 7).
                    assert!(
                        matches!(
                            L::get_op_type_with_code(
                                node,
                                source.as_bytes(),
                                Ancestors::known(chain)
                            ),
                            TokenRole::Unknown
                        ),
                        "{label}: `{}` inside a character literal is classified, so the \
                         literal now double-counts against its wrapper",
                        node.kind()
                    );
                });
            }
            // Ten literals across the two fixtures; each holds two
            // delimiters plus at least one payload leaf, and `'ab'` two.
            assert_eq!(literals, 10, "{label}: fixtures lost a character literal");
            assert_eq!(children, 31, "{label}: fixtures lost a literal's internals");
        }

        check::<CCode>(C::CharLiteral as u16, "c");
        check::<CppCode>(Cpp::CharLiteral as u16, "cpp");
        check::<MozcppCode>(Mozcpp::CharLiteral as u16, "mozcpp");
        check::<ObjcCode>(Objc::CharLiteral as u16, "objc");
    }

    /// #1361 fixture pairing the two spellings of a member access whose
    /// receiver is the enclosing object: `this->x` and `p->x`.
    ///
    /// The pairing is the point, not decoration. `field_expression` is
    /// `<receiver> -> <field>`, so the two lines are the same AST shape
    /// and must bill the same *kinds* of thing — a receiver operand, the
    /// `->` operator, a field operand. Before the fix `this` was in
    /// neither arm, so the two shapes scored differently and `m1` billed
    /// a `->` with only one operand around it.
    ///
    /// Plain C++ that the mozcpp fork parses identically, so one source
    /// proves the same thing about both clones.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    const CPP_THIS_RECEIVER_PARITY: &str = "struct S {
         int x;
         int m1() { return this->x; }
         int m2(S* p) { return p->x; }
     };";

    /// #1361 fixture holding one representative position per kind of
    /// container the pinned `tree-sitter-cpp` can put a `this` in: the
    /// `->` receiver, a dereference inside a parenthesised expression, a
    /// bare return value, both lambda-capture spellings (`[this]` and
    /// `[=, this]`), a `decltype` trailing return type, a constructor
    /// body following a member-initialiser list, and a call argument.
    ///
    /// Representative, not exhaustive — `delete this;`, `throw this;`,
    /// `[&, this]`, a default member initialiser and a `this->template
    /// f<int>()` all parse cleanly too. Every one of them is the same
    /// childless `{this:215}` leaf under an unclassified wrapper, which
    /// is precisely why the arm needs no guard and why enumerating them
    /// would add rows without adding a distinct path (grammar-dispatch
    /// section 11).
    ///
    /// C++23's explicit object parameter (`int g(this S&& self)`) is
    /// deliberately absent: the pinned grammar cannot parse it and emits
    /// `type_identifier "this"` plus an `ERROR`, which
    /// `for_each_node_with_chain` rejects outright. That spelling is
    /// already an operand through `TypeIdentifier`, so the construct is
    /// unaffected by this arm either way.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    const CPP_THIS_POSITIONS: &str = "struct S {
         int x;
         void g(S*);
         int arrow() { return this->x; }
         int deref() { return (*this).x; }
         S* ret() { return this; }
         void cap() { auto l = [this]() { return x; }; }
         void cap2() { auto l = [=, this]() { return x; }; }
         auto trail() -> decltype(this->x) { return x; }
         S(int v) : x(v) { this->x = v; }
         void call() { g(this); }
     };";

    /// Asserts `CPP_THIS_RECEIVER_PARITY` for one C++-family language,
    /// through the metrics store *and* the text-keyed `--ops` store
    /// (the lesson-4 invariant `n2 == len(dedupe(ops.operands))`).
    ///
    /// The `--ops` half pins *which text* the new operand is billed
    /// under, which the counts alone cannot see: billing the enclosing
    /// `field_expression` instead of the `this` leaf would hold `n2` at
    /// 6 while the vocabulary silently became `this->x`.
    #[cfg(any(feature = "cpp", feature = "mozcpp"))]
    #[track_caller]
    fn assert_this_receiver_parity<T: crate::MetricSuite>(file: &str, label: &str) {
        // Operators, keyed by kind_id except the text-keyed primitives:
        // `{` x3 (class body, `m1`, `m2`), `int` x3, `;` x4 (the field,
        // the two returns, the struct terminator), `(` x2, `return` x2,
        // `->` x2, and the one `*` of `S* p`. `struct` is in no arm, and
        // #695 dropped every closing delimiter. n1 = 7, N1 = 17.
        //
        // Operands, keyed by source text: `S` x2 (the name and the
        // parameter type), `x` x3, `m1`, `m2`, `p` x2, and — the fix —
        // `this` x1. n2 = 6, N2 = 10. Before #1361: n2 5, N2 9, with
        // every operator count identical, which is the whole claim.
        let counts = format!("{label}: this->x and p->x are the same shape");
        assert_halstead_counts::<T>(CPP_THIS_RECEIVER_PARITY, file, [7, 17, 6, 10], &counts);
        assert_ops_operands::<T>(
            CPP_THIS_RECEIVER_PARITY,
            file,
            6,
            vec!["S", "x", "m1", "m2", "p", "this"],
        );
    }

    /// Regression for #1361: a C++ `this` is a Halstead operand.
    ///
    /// `Cpp::This` / `Mozcpp::This` were in neither arm of
    /// `CppCode::get_op_type` / `MozcppCode::get_op_type`, so a `this`
    /// contributed *nothing* — not an operator and not an operand —
    /// while eleven of the fourteen languages here bill their
    /// self-reference as an operand. Same shape as #1316's character
    /// literals, and the inverse of the #1351-#1355 over-counts.
    ///
    /// Each language asserts separately over the same source rather than
    /// sharing one call, so reverting one clone's arm fails that row
    /// alone (grammar-dispatch section 11). Mozcpp owns no file
    /// extension, so no integration snapshot reaches its clone; this row
    /// and `cpp_and_mozcpp_agree_on_this` in `tests/parity/` are the
    /// whole coverage that arm has.
    #[cfg(all(feature = "cpp", feature = "mozcpp"))]
    #[test]
    fn cpp_this_is_an_operand() {
        assert_this_receiver_parity::<CppParser>("this.cpp", "cpp");
        assert_this_receiver_parity::<MozcppParser>("this.cpp", "mozcpp");
    }

    /// The `This` arm is unconditional: every `this` in
    /// `CPP_THIS_POSITIONS` classifies as an operand whatever encloses
    /// it (#1361).
    ///
    /// The counts in `cpp_this_is_an_operand` are measured on one
    /// position only. An arm reached through a parent-scoped guard —
    /// the shape the neighbouring `RawStringLiteral` `LPAREN` arm uses,
    /// and the shape a reviewer might reasonably add here — would pass
    /// that test and still drop `this` in a lambda capture or a
    /// `decltype`. This walk is what makes the arm's unconditional
    /// reach a measurement rather than an assumption.
    ///
    /// Named for the *property* rather than for the fixture: the fixture
    /// samples one position per container kind and is deliberately not
    /// exhaustive (see `CPP_THIS_POSITIONS`), so a name promising "every
    /// position" would claim more than it checks.
    #[cfg(all(feature = "cpp", feature = "mozcpp"))]
    #[test]
    fn cpp_this_is_an_operand_regardless_of_position() {
        #[cfg(any(feature = "cpp", feature = "mozcpp"))]
        fn check<L: LanguageInfo + Getter>(label: &str) {
            let mut seen = 0_usize;
            for_each_node_with_chain::<L>(CPP_THIS_POSITIONS.as_bytes(), |node, chain| {
                if node.kind() != "this" {
                    return;
                }
                seen += 1;
                // `_with_code` is the spelling `compute_halstead` calls.
                // The default forwards to the byte-less form, so the two
                // agree for both languages today — which is exactly why
                // asking the wrong one would read as correct right up
                // until one of them grew an override
                // (grammar-dispatch section 7).
                assert!(
                    matches!(
                        L::get_op_type_with_code(
                            node,
                            CPP_THIS_POSITIONS.as_bytes(),
                            Ancestors::known(chain)
                        ),
                        TokenRole::Operand
                    ),
                    "{label}: a `this` under `{}` is not an operand",
                    chain.last().map_or("<root>", Node::kind)
                );
            });
            // One per position: `->` receiver, `(*this)`, bare return,
            // `[this]`, `[=, this]`, `decltype(this->x)`, the
            // constructor body, and the call argument.
            assert_eq!(seen, 8, "{label}: fixture lost a `this` position");
        }

        check::<CppCode>("cpp");
        check::<MozcppCode>("mozcpp");
    }

    /// Pins the two grammar facts the #1361 operand arm rests on, across
    /// both fixtures and both languages.
    ///
    /// * **Grammar-dispatch section 1.** Every node the grammar spells
    ///   `this` carries the one `kind_id` the arm lists. That is the
    ///   weaker half of the alias evidence — an alias arises in a
    ///   *different* syntactic position, which no fixture can enumerate.
    ///   The strong half is that these generated enums carry
    ///   numeric-suffix aliases in quantity (`FunctionDefinition2..4`,
    ///   `QualifiedIdentifier2..4`, `LPAREN2`, `Try2`, `GT2` in this one
    ///   file) and neither spells a `This2` — `This = 215` is the sole
    ///   variant rendering `"this"` in `language_cpp.rs` and
    ///   `language_mozcpp.rs`. This loop is what notices if a grammar
    ///   bump changes that under an existing fixture.
    /// * **Grammar-dispatch section 5.** A `this` is a childless leaf and
    ///   no node containing it is classified. That is both halves of the
    ///   double-count question: nothing below it can be billed a second
    ///   time, and no `field_expression` / `pointer_expression` /
    ///   `lambda_capture_specifier` / `argument_list` wrapper bills the
    ///   same source text from above.
    #[cfg(all(feature = "cpp", feature = "mozcpp"))]
    #[test]
    fn cpp_this_is_a_childless_unaliased_leaf() {
        #[cfg(any(feature = "cpp", feature = "mozcpp"))]
        fn check<L: LanguageInfo + Getter>(this: u16, label: &str) {
            let mut seen = 0_usize;
            for source in [CPP_THIS_RECEIVER_PARITY, CPP_THIS_POSITIONS] {
                for_each_node_with_chain::<L>(source.as_bytes(), |node, chain| {
                    if node.kind() != "this" {
                        return;
                    }
                    seen += 1;
                    assert_eq!(
                        node.kind_id(),
                        this,
                        "{label}: a `this` carries kind_id {} rather than the {this} the \
                         operand arm lists — an alias the arm cannot see",
                        node.kind_id()
                    );
                    assert_eq!(
                        node.child_count(),
                        0,
                        "{label}: `this` grew children, which the operand arm would now \
                         double-count against"
                    );
                    assert!(!chain.is_empty(), "{label}: a `this` cannot be the root");
                    // Every ancestor, not just the parent. The claim is
                    // that *no node containing* a `this` is classified,
                    // and `(*this)` alone puts two wrappers between the
                    // leaf and the nearest classified node — checking
                    // only `chain.last()` would assert something
                    // narrower than the comment on the arm promises.
                    // `chain` is the *node's* ancestry, so the ancestor
                    // at `i` has `chain[..i]` for its own.
                    for (i, ancestor) in chain.iter().enumerate() {
                        assert!(
                            matches!(
                                L::get_op_type_with_code(
                                    ancestor,
                                    source.as_bytes(),
                                    Ancestors::known(&chain[..i])
                                ),
                                TokenRole::Unknown
                            ),
                            "{label}: `{}` contains a `this` and is itself classified, so the \
                             reference now counts twice",
                            ancestor.kind()
                        );
                    }
                });
            }
            // One `this` in the parity fixture, eight in the positions
            // fixture. Asserted so a fixture that stopped containing one
            // cannot make this test pass having checked nothing.
            assert_eq!(seen, 9, "{label}: fixtures lost a `this`");
        }

        check::<CppCode>(Cpp::This as u16, "cpp");
        check::<MozcppCode>(Mozcpp::This as u16, "mozcpp");
    }

    /// Builds a `HalsteadMaps` from explicit occurrence counts.
    ///
    /// The per-language tests above reach these maps only through a
    /// parse, which cannot produce a *chosen* overlap between a child
    /// and its parent — the cases `merge` exists to get right.
    fn halstead_maps_of<'a>(
        operators: &[(u16, u64)],
        primitive_operators: &[(&'a [u8], u64)],
        operands: &[(&'a [u8], u64)],
    ) -> HalsteadMaps<'a> {
        HalsteadMaps {
            operators: operators.iter().copied().collect(),
            primitive_operators: primitive_operators.iter().copied().collect(),
            operands: operands.iter().copied().collect(),
        }
    }

    /// `HalsteadMaps::operators` must stay on the crate's integer hasher.
    ///
    /// Swapping a hasher moves no metric value, so every other test in
    /// this file passes just as well with #1108 reverted. Both halves
    /// here are needed: the typed binding stops compiling if the field
    /// goes back to a default-hasher `HashMap`, and the `type_name`
    /// comparison still fails at runtime if `IntKeyHashMap` itself is
    /// ever redefined to wrap `RandomState`.
    ///
    /// The two text-keyed maps are pinned to SipHash in the same test,
    /// because moving *them* would be a regression rather than an
    /// optimisation. `crate::int_hash`'s module doc is the single place
    /// that argues why analysed source text does not qualify.
    #[test]
    fn halstead_operator_map_uses_the_int_key_hasher() {
        use std::any::{type_name, type_name_of_val};
        use std::hash::BuildHasherDefault;

        use crate::int_hash::IntKeyHasher;

        let maps = HalsteadMaps::new();

        let operators: &IntKeyHashMap<u16, u64> = &maps.operators;
        assert_eq!(
            type_name_of_val(operators.hasher()),
            type_name::<BuildHasherDefault<IntKeyHasher>>(),
            "the kind_id-keyed operator map must use the int_hash hasher"
        );

        let siphash = type_name::<std::collections::hash_map::RandomState>();
        assert_eq!(
            type_name_of_val(maps.operands.hasher()),
            siphash,
            "operand keys come from the analysed source, so the keyed hash \
             is what stops a crafted file from flooding this map"
        );
        assert_eq!(
            type_name_of_val(maps.primitive_operators.hasher()),
            siphash,
            "primitive-operator keys come from the analysed source, so the \
             keyed hash is what stops a crafted file from flooding this map"
        );
    }

    /// `merge` sums overlapping keys and adopts disjoint ones, in all
    /// three maps, and `finalize` reads the union back as n1/N1/n2/N2.
    ///
    /// Every count differs from every other and none is zero, so a
    /// dropped key, an overwrite where an addition belongs, or a map
    /// crossed with its neighbour all change the totals.
    #[test]
    fn halstead_maps_merge_sums_overlaps_and_adopts_disjoint_keys() {
        let mut parent = halstead_maps_of(
            &[(1, 2), (2, 3)],
            &[(b"int", 1)],
            &[(b"alpha", 4), (b"beta", 7)],
        );
        let child = halstead_maps_of(
            &[(2, 5), (7, 11)],
            &[(b"double", 13)],
            &[(b"alpha", 17), (b"gamma", 19)],
        );

        parent.merge(&child);

        // expected: operators {1: 2, 2: 3+5, 7: 11}; primitives
        // {int: 1, double: 13}; operands {alpha: 4+17, beta: 7,
        // gamma: 19}.
        assert_eq!(
            parent,
            halstead_maps_of(
                &[(1, 2), (2, 8), (7, 11)],
                &[(b"int", 1), (b"double", 13)],
                &[(b"alpha", 21), (b"beta", 7), (b"gamma", 19)],
            )
        );

        let mut stats = Stats::default();
        parent.finalize(&mut stats);
        // expected: n1 = 3 kind ids + 2 primitives; N1 = (2+8+11) +
        // (1+13); n2 = 3 texts; N2 = 21+7+19.
        assert_eq!(stats.unique_operators(), 5);
        assert_eq!(stats.total_operators(), 35);
        assert_eq!(stats.unique_operands(), 3);
        assert_eq!(stats.total_operands(), 47);
    }

    /// Merging an empty child leaves the parent untouched.
    ///
    /// A space with no operators or operands is the common case for a
    /// leaf getter or an empty function body, and `finalize` runs on
    /// the parent afterwards either way.
    #[test]
    fn halstead_maps_merge_of_empty_child_is_a_no_op() {
        let mut parent = halstead_maps_of(&[(3, 5)], &[(b"char", 2)], &[(b"delta", 9)]);
        let before = parent.clone();

        parent.merge(&HalsteadMaps::new());

        assert_eq!(parent, before);

        let mut stats = Stats::default();
        parent.finalize(&mut stats);
        // expected: n1 = 1 kind id + 1 primitive; N1 = 5 + 2; n2 = 1;
        // N2 = 9.
        assert_eq!(stats.unique_operators(), 2);
        assert_eq!(stats.total_operators(), 7);
        assert_eq!(stats.unique_operands(), 1);
        assert_eq!(stats.total_operands(), 9);
    }

    /// Folding a chain of nested spaces bottom-up must reach the union
    /// of every level, re-merging already-merged maps on the way up.
    ///
    /// This is what `spaces.rs` and `ops.rs` actually do: each space is
    /// merged into its parent as the walk pops it, so by the time the
    /// root sees a grandchild's counts they have already passed through
    /// one `merge`. The literal expectation below is what discriminates
    /// — the `nested == flat` cross-check on its own does not, because
    /// any entry-wise fold over the same levels agrees with itself
    /// however it is associated, including a broken one.
    #[test]
    fn halstead_maps_merge_folds_a_nested_chain() {
        let levels = [
            halstead_maps_of(&[(1, 1)], &[(b"int", 1)], &[(b"a", 1)]),
            halstead_maps_of(&[(1, 2), (2, 3)], &[], &[(b"a", 2), (b"b", 4)]),
            halstead_maps_of(&[(2, 5)], &[(b"long", 6)], &[(b"b", 7)]),
            halstead_maps_of(&[(3, 8)], &[(b"int", 9)], &[(b"c", 10)]),
        ];

        // Bottom-up: the deepest level folds into its parent, that
        // result into *its* parent, and so on up to the root.
        let mut nested = levels[levels.len() - 1].clone();
        for level in levels.iter().rev().skip(1) {
            let mut outer = level.clone();
            outer.merge(&nested);
            nested = outer;
        }

        // Flat: every level merged directly into the root.
        let mut flat = levels[0].clone();
        for level in &levels[1..] {
            flat.merge(level);
        }

        // expected: every key summed across the four levels — operators
        // {1: 1+2, 2: 3+5, 3: 8}, primitives {int: 1+9, long: 6},
        // operands {a: 1+2, b: 4+7, c: 10}.
        assert_eq!(
            nested,
            halstead_maps_of(
                &[(1, 3), (2, 8), (3, 8)],
                &[(b"int", 10), (b"long", 6)],
                &[(b"a", 3), (b"b", 11), (b"c", 10)],
            )
        );
        assert_eq!(nested, flat);

        let mut stats = Stats::default();
        nested.finalize(&mut stats);
        // expected: n1 = 3 kind ids + 2 primitives; N1 = (3+8+8) +
        // (10+6); n2 = 3 texts; N2 = 3+11+10.
        assert_eq!(stats.unique_operators(), 5);
        assert_eq!(stats.total_operators(), 35);
        assert_eq!(stats.unique_operands(), 3);
        assert_eq!(stats.total_operands(), 24);
    }

    /// A `kind_id` at the top of the `u16` range must behave like any
    /// other key.
    ///
    /// The largest grammar in the workspace (`mozcpp`) tops out around
    /// 640 symbols, so nothing near `u16::MAX` occurs today — but the
    /// map is keyed by the raw id, and a dense-array representation
    /// (the shape #1108 considered and rejected) is exactly what such a
    /// key would break. Pinning it keeps that trade-off honest if the
    /// representation is ever revisited.
    #[test]
    fn halstead_maps_handle_the_full_kind_id_range() {
        let mut parent = halstead_maps_of(&[(0, 3), (u16::MAX, 5)], &[], &[]);
        parent.merge(&halstead_maps_of(&[(u16::MAX, 7)], &[], &[]));

        let mut stats = Stats::default();
        parent.finalize(&mut stats);
        // expected: two distinct kind ids, occurrences 3 and 5+7.
        assert_eq!(stats.unique_operators(), 2);
        assert_eq!(stats.total_operators(), 15);
    }
}