big_code_analysis/metrics/

nargs.rs

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

use std::fmt;

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

/// The `NArgs` metric.
///
/// This metric counts the number of arguments
/// of functions/closures.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct Stats {
    fn_nargs: usize,
    closure_nargs: usize,
    fn_nargs_sum: usize,
    closure_nargs_sum: usize,
    fn_nargs_min: usize,
    closure_nargs_min: usize,
    fn_nargs_max: usize,
    closure_nargs_max: usize,
    total_functions: usize,
    total_closures: usize,
}

impl Default for Stats {
    fn default() -> Self {
        Self {
            fn_nargs: 0,
            closure_nargs: 0,
            fn_nargs_sum: 0,
            closure_nargs_sum: 0,
            fn_nargs_min: usize::MAX,
            closure_nargs_min: usize::MAX,
            fn_nargs_max: 0,
            closure_nargs_max: 0,
            total_functions: 0,
            total_closures: 0,
        }
    }
}

impl fmt::Display for Stats {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "function_args: {}, closure_args: {}, function_args_average: {}, closure_args_average: {}, total: {}, average: {}, function_args_min: {}, function_args_max: {}, closure_args_min: {}, closure_args_max: {}",
            self.function_args_sum(),
            self.closure_args_sum(),
            self.function_args_average(),
            self.closure_args_average(),
            self.total(),
            self.average(),
            self.function_args_min(),
            self.function_args_max(),
            self.closure_args_min(),
            self.closure_args_max()
        )
    }
}

impl Stats {
    /// Merges a second `NArgs` metric into the first one
    pub fn merge(&mut self, other: &Stats) {
        self.closure_nargs_min = self.closure_nargs_min.min(other.closure_nargs_min);
        self.closure_nargs_max = self.closure_nargs_max.max(other.closure_nargs_max);
        self.fn_nargs_min = self.fn_nargs_min.min(other.fn_nargs_min);
        self.fn_nargs_max = self.fn_nargs_max.max(other.fn_nargs_max);
        self.fn_nargs_sum += other.fn_nargs_sum;
        self.closure_nargs_sum += other.closure_nargs_sum;
    }

    /// Returns the number of function arguments in a space.
    #[inline]
    #[must_use]
    pub fn function_args(&self) -> u64 {
        self.fn_nargs as u64
    }

    /// Returns the number of closure arguments in a space.
    #[inline]
    #[must_use]
    pub fn closure_args(&self) -> u64 {
        self.closure_nargs as u64
    }

    /// Returns the number of function arguments sum in a space.
    #[inline]
    #[must_use]
    pub fn function_args_sum(&self) -> u64 {
        self.fn_nargs_sum as u64
    }

    /// Returns the number of closure arguments sum in a space.
    #[inline]
    #[must_use]
    pub fn closure_args_sum(&self) -> u64 {
        self.closure_nargs_sum as u64
    }

    /// Returns the average number of functions arguments in a space.
    #[inline]
    #[must_use]
    pub fn function_args_average(&self) -> f64 {
        crate::metrics::average(self.fn_nargs_sum as f64, self.total_functions)
    }

    /// Returns the average number of closures arguments in a space.
    #[inline]
    #[must_use]
    pub fn closure_args_average(&self) -> f64 {
        crate::metrics::average(self.closure_nargs_sum as f64, self.total_closures)
    }

    /// Returns the total number of arguments of each function and
    /// closure in a space.
    #[inline]
    #[must_use]
    pub fn total(&self) -> u64 {
        self.function_args_sum() + self.closure_args_sum()
    }

    /// Returns the `NArgs` metric average value
    ///
    /// This value is computed dividing the `NArgs` value
    /// for the total number of functions/closures in a space.
    #[inline]
    #[must_use]
    pub fn average(&self) -> f64 {
        crate::metrics::average(
            self.total() as f64,
            self.total_functions + self.total_closures,
        )
    }
    /// Returns the minimum number of function arguments in a space.
    ///
    /// Collapses the `usize::MAX` sentinel that `Stats::default()` plants
    /// into `fn_nargs_min` to `0.0`, so a never-observed space
    /// serializes to a meaningful number rather than `1.8446744e19`.
    #[inline]
    #[must_use]
    pub fn function_args_min(&self) -> u64 {
        if self.fn_nargs_min == usize::MAX {
            0
        } else {
            self.fn_nargs_min as u64
        }
    }
    /// Returns the maximum number of function arguments in a space.
    #[inline]
    #[must_use]
    pub fn function_args_max(&self) -> u64 {
        self.fn_nargs_max as u64
    }
    /// Returns the minimum number of closure arguments in a space.
    ///
    /// Same `usize::MAX` sentinel collapse as `function_args_min`.
    #[inline]
    #[must_use]
    pub fn closure_args_min(&self) -> u64 {
        if self.closure_nargs_min == usize::MAX {
            0
        } else {
            self.closure_nargs_min as u64
        }
    }
    /// Returns the maximum number of closure arguments in a space.
    #[inline]
    #[must_use]
    pub fn closure_args_max(&self) -> u64 {
        self.closure_nargs_max as u64
    }
    #[inline]
    pub(crate) fn compute_sum(&mut self) {
        self.closure_nargs_sum += self.closure_nargs;
        self.fn_nargs_sum += self.fn_nargs;
    }
    #[inline]
    pub(crate) fn compute_minmax(&mut self) {
        self.closure_nargs_min = self.closure_nargs_min.min(self.closure_nargs);
        self.closure_nargs_max = self.closure_nargs_max.max(self.closure_nargs);
        self.fn_nargs_min = self.fn_nargs_min.min(self.fn_nargs);
        self.fn_nargs_max = self.fn_nargs_max.max(self.fn_nargs);
        self.compute_sum();
    }
    pub(crate) fn finalize(&mut self, total_functions: usize, total_closures: usize) {
        self.total_functions = total_functions;
        self.total_closures = total_closures;
    }
}

#[inline]
fn compute_args<T: Checker>(node: &Node, nargs: &mut usize) {
    if let Some(params) = node.child_by_field_name("parameters") {
        let node_params = params;
        node_params.act_on_child(&mut |n| {
            if !T::is_non_arg(n) {
                *nargs += 1;
            }
        });
    } else if node.child_by_field_name("parameter").is_some() {
        // JS/TS/TSX/MozJS arrow functions with a bare identifier parameter
        // (`x => …`) use the singular `parameter` field instead of the plural
        // `parameters` field. The grammar guarantees this is exactly one
        // identifier, so count it as one argument.
        *nargs += 1;
    }
}

#[doc(hidden)]
/// Per-language counting of function arguments.
pub(crate) trait NArgs
where
    Self: Checker,
    Self: std::marker::Sized,
{
    /// Walk `node` and update `stats` with this metric for the language
    /// implementing the trait.
    fn compute(node: &Node, stats: &mut Stats) {
        if Self::is_func(node) {
            compute_args::<Self>(node, &mut stats.fn_nargs);
            return;
        }

        if Self::is_closure(node) {
            compute_args::<Self>(node, &mut stats.closure_nargs);
        }
    }
}

impl NArgs for CppCode {
    fn compute(node: &Node, stats: &mut Stats) {
        if Self::is_func(node) {
            if let Some(declarator) = node.child_by_field_name("declarator") {
                let new_node = declarator;
                compute_args::<Self>(&new_node, &mut stats.fn_nargs);
            }
            return;
        }

        if Self::is_closure(node)
            && let Some(declarator) = node.child_by_field_name("declarator")
        {
            let new_node = declarator;
            compute_args::<Self>(&new_node, &mut stats.closure_nargs);
        }
    }
}

impl NArgs for CCode {
    fn compute(node: &Node, stats: &mut Stats) {
        if Self::is_func(node) {
            if let Some(declarator) = node.child_by_field_name("declarator") {
                let new_node = declarator;
                compute_args::<Self>(&new_node, &mut stats.fn_nargs);
            }
            return;
        }

        if Self::is_closure(node)
            && let Some(declarator) = node.child_by_field_name("declarator")
        {
            let new_node = declarator;
            compute_args::<Self>(&new_node, &mut stats.closure_nargs);
        }
    }
}

impl NArgs for MozcppCode {
    fn compute(node: &Node, stats: &mut Stats) {
        if Self::is_func(node) {
            if let Some(declarator) = node.child_by_field_name("declarator") {
                let new_node = declarator;
                compute_args::<Self>(&new_node, &mut stats.fn_nargs);
            }
            return;
        }

        if Self::is_closure(node)
            && let Some(declarator) = node.child_by_field_name("declarator")
        {
            let new_node = declarator;
            compute_args::<Self>(&new_node, &mut stats.closure_nargs);
        }
    }
}

// Objective-C carries parameters in three different shapes, so it cannot
// share the single-`declarator`-field C/C++ impl:
//   * free `function_definition`s use the C declarator → `parameters`
//     field, counted exactly as in C;
//   * a `method_definition` lists one `method_parameter` per labelled
//     argument (`- (void)foo:(int)a bar:(int)b` → 2; the unary
//     `- (void)foo` → 0);
//   * a block `^(int x){ … }` holds its params in a `parameter_list`
//     child rather than under a `parameters` field.
impl NArgs for ObjcCode {
    fn compute(node: &Node, stats: &mut Stats) {
        match node.kind_id().into() {
            Objc::FunctionDefinition | Objc::FunctionDefinition2 => {
                if let Some(declarator) = node.child_by_field_name("declarator") {
                    compute_args::<Self>(&declarator, &mut stats.fn_nargs);
                }
            }
            Objc::MethodDefinition => {
                // Both `method_parameter` aliases are accepted per the
                // #285 / lesson-2 defensive convention: real parse trees
                // emit `MethodParameter` (475), but the grammar also
                // declares the `MethodParameter2` (476) alias, so list it
                // too rather than risk a future bump emitting it.
                node.act_on_child(&mut |n| {
                    if matches!(
                        n.kind_id().into(),
                        Objc::MethodParameter | Objc::MethodParameter2
                    ) {
                        stats.fn_nargs += 1;
                    }
                });
            }
            Objc::BlockLiteral => {
                if let Some(params) = node.first_child(|id| Objc::ParameterList == id) {
                    params.act_on_child(&mut |n| {
                        if matches!(
                            n.kind_id().into(),
                            Objc::ParameterDeclaration | Objc::VariadicParameter
                        ) {
                            stats.closure_nargs += 1;
                        }
                    });
                }
            }
            _ => {}
        }
    }
}

// Go's `parameter_declaration` allows multiple names to share one type
// (`func f(a, b int)` is one parameter_declaration with two `name` children
// but two formal parameters). Count names rather than declarations so the
// reported nargs matches Go's parameter count.
fn compute_go_args(node: &Node, nargs: &mut usize) {
    let Some(params) = node.child_by_field_name("parameters") else {
        return;
    };
    *nargs += params
        .children()
        .map(|child| match child.kind_id().into() {
            Go::ParameterDeclaration => child
                .children()
                .filter(|c| c.kind_id() == Go::Identifier)
                .count()
                .max(1),
            Go::VariadicParameterDeclaration => 1,
            _ => 0,
        })
        .sum::<usize>();
}

impl NArgs for GoCode {
    fn compute(node: &Node, stats: &mut Stats) {
        if Self::is_func(node) {
            compute_go_args(node, &mut stats.fn_nargs);
            return;
        }

        if Self::is_closure(node) {
            compute_go_args(node, &mut stats.closure_nargs);
        }
    }
}

fn compute_kotlin_func_args(node: &Node, nargs: &mut usize) {
    if let Some(params) = node
        .children()
        .find(|c| c.kind_id() == Kotlin::FunctionValueParameters)
    {
        params.act_on_child(&mut |n| {
            if n.kind_id() == Kotlin::Parameter {
                *nargs += 1;
            }
        });
    }
}

fn compute_kotlin_lambda_args(node: &Node, nargs: &mut usize) {
    // Lambda parameters are plain identifiers or destructuring patterns separated
    // by commas; there is no typed `Parameter` wrapper node (unlike function
    // value parameters), so a negative COMMA filter is the correct predicate here.
    if let Some(params) = node
        .children()
        .find(|c| c.kind_id() == Kotlin::LambdaParameters)
    {
        params.act_on_child(&mut |n| {
            if n.kind_id() != Kotlin::COMMA {
                *nargs += 1;
            }
        });
    }
}

impl NArgs for KotlinCode {
    fn compute(node: &Node, stats: &mut Stats) {
        if Self::is_func(node) {
            compute_kotlin_func_args(node, &mut stats.fn_nargs);
            return;
        }

        if Self::is_closure(node) {
            if node.kind_id() == Kotlin::LambdaLiteral {
                compute_kotlin_lambda_args(node, &mut stats.closure_nargs);
            } else {
                compute_kotlin_func_args(node, &mut stats.closure_nargs);
            }
        }
    }
}

fn compute_lua_args(node: &Node, nargs: &mut usize) {
    let Some(params) = node.child_by_field_name("parameters") else {
        return;
    };
    *nargs += params
        .children()
        .filter(|c| matches!(c.kind_id().into(), Lua::Identifier | Lua::VarargExpression))
        .count();
}

impl NArgs for LuaCode {
    fn compute(node: &Node, stats: &mut Stats) {
        if Self::is_func(node) {
            compute_lua_args(node, &mut stats.fn_nargs);
        } else if Self::is_closure(node) {
            compute_lua_args(node, &mut stats.closure_nargs);
        }
    }
}

fn compute_tcl_args(node: &Node, nargs: &mut usize) {
    let Some(params) = node.child_by_field_name("arguments") else {
        return;
    };
    *nargs += params
        .children()
        .filter(|c| c.kind_id() == Tcl::Argument)
        .count();
}

impl NArgs for TclCode {
    fn compute(node: &Node, stats: &mut Stats) {
        if Self::is_func(node) {
            compute_tcl_args(node, &mut stats.fn_nargs);
        }
    }
}

// iRules counterpart of `compute_tcl_args`. Only `procedure` carries an
// `arguments` *field*; `when_event` handlers have no formal parameters
// (the event context is implicit), so they correctly count zero. `{a 5}`
// default-valued parameters parse as a single `argument`, so each formal
// parameter contributes one regardless of its default.
fn compute_irules_args(node: &Node, nargs: &mut usize) {
    let Some(params) = node.child_by_field_name("arguments") else {
        return;
    };
    *nargs += params
        .children()
        .filter(|c| c.kind_id() == Irules::Argument)
        .count();
}

impl NArgs for IrulesCode {
    fn compute(node: &Node, stats: &mut Stats) {
        if Self::is_func(node) {
            compute_irules_args(node, &mut stats.fn_nargs);
        }
    }
}

implement_metric_trait!(
    [NArgs],
    PythonCode,
    MozjsCode,
    JavascriptCode,
    TypescriptCode,
    TsxCode,
    RustCode,
    PreprocCode,
    CcommentCode,
    JavaCode,
    PerlCode,
    BashCode,
    PhpCode,
    CsharpCode,
    ElixirCode,
    RubyCode
);

// Groovy closures use `closure_parameters` as an unnamed child rather
// than a `parameters` field, so the default NArgs walker (which looks
// for a `parameters` field) misses them. Match the closure_parameters
// child directly and count its `closure_parameter` grand-children.
impl NArgs for GroovyCode {
    fn compute(node: &Node, stats: &mut Stats) {
        use crate::languages::language_groovy::Groovy;

        if Self::is_func(node) {
            compute_args::<Self>(node, &mut stats.fn_nargs);
            return;
        }

        if Self::is_closure(node)
            && let Some(params) = node.first_child(|id| id == Groovy::ClosureParameters)
        {
            params.act_on_child(&mut |n| {
                if n.kind_id() == Groovy::ClosureParameter {
                    stats.closure_nargs += 1;
                }
            });
        }
    }
}

#[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 crate::tools::check_metrics;

    use super::*;

    /// Regression for #227: a `Stats::default()` that never sees an
    /// observation must not leak the `usize::MAX` sentinel for
    /// `fn_args_min` or `closure_args_min`. Both getters collapse
    /// the sentinel to `0.0` so JSON never emits `1.8446744e19`.
    #[test]
    fn nargs_empty_file_min_is_zero() {
        let stats = Stats::default();
        assert_eq!(stats.function_args_min(), 0);
        assert_eq!(stats.closure_args_min(), 0);
    }

    #[test]
    fn python_no_functions_and_closures() {
        check_metrics::<PythonParser>("a = 42", "foo.py", |metric| {
            // 0 functions + 0 closures
            insta::assert_json_snapshot!(
                metric.nargs,
                @r#"
            {
              "function_args": 0,
              "closure_args": 0,
              "function_args_average": 0.0,
              "closure_args_average": 0.0,
              "total": 0,
              "average": 0.0,
              "function_args_min": 0,
              "function_args_max": 0,
              "closure_args_min": 0,
              "closure_args_max": 0
            }
            "#
            );
        });
    }

    #[test]
    fn rust_no_functions_and_closures() {
        check_metrics::<RustParser>("let a = 42;", "foo.rs", |metric| {
            // 0 functions + 0 closures
            insta::assert_json_snapshot!(
                metric.nargs,
                @r#"
            {
              "function_args": 0,
              "closure_args": 0,
              "function_args_average": 0.0,
              "closure_args_average": 0.0,
              "total": 0,
              "average": 0.0,
              "function_args_min": 0,
              "function_args_max": 0,
              "closure_args_min": 0,
              "closure_args_max": 0
            }
            "#
            );
        });
    }

    #[test]
    fn cpp_no_functions_and_closures() {
        check_metrics::<CppParser>("int a = 42;", "foo.cpp", |metric| {
            // 0 functions + 0 closures
            insta::assert_json_snapshot!(
                metric.nargs,
                @r#"
            {
              "function_args": 0,
              "closure_args": 0,
              "function_args_average": 0.0,
              "closure_args_average": 0.0,
              "total": 0,
              "average": 0.0,
              "function_args_min": 0,
              "function_args_max": 0,
              "closure_args_min": 0,
              "closure_args_max": 0
            }
            "#
            );
        });
    }

    #[test]
    fn javascript_no_functions_and_closures() {
        check_metrics::<JavascriptParser>("var a = 42;", "foo.js", |metric| {
            // 0 functions + 0 closures
            insta::assert_json_snapshot!(
                metric.nargs,
                @r#"
            {
              "function_args": 0,
              "closure_args": 0,
              "function_args_average": 0.0,
              "closure_args_average": 0.0,
              "total": 0,
              "average": 0.0,
              "function_args_min": 0,
              "function_args_max": 0,
              "closure_args_min": 0,
              "closure_args_max": 0
            }
            "#
            );
        });
    }

    #[test]
    fn python_single_function() {
        check_metrics::<PythonParser>(
            "def f(a, b):
                 if a:
                     return a",
            "foo.py",
            |metric| {
                // 1 function
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn rust_single_function() {
        check_metrics::<RustParser>(
            "fn f(a: bool, b: usize) {
                 if a {
                     return a;
                }
             }",
            "foo.rs",
            |metric| {
                // 1 function
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn c_single_function() {
        check_metrics::<CParser>(
            "int f(int a, int b) {
                 if (a) {
                     return a;
                }
             }",
            "foo.c",
            |metric| {
                // 1 function
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn javascript_single_function() {
        check_metrics::<JavascriptParser>(
            "function f(a, b) {
                 return a * b;
             }",
            "foo.js",
            |metric| {
                // 1 function
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn python_single_lambda() {
        check_metrics::<PythonParser>("bar = lambda a: True", "foo.py", |metric| {
            // 1 lambda
            insta::assert_json_snapshot!(
                metric.nargs,
                @r#"
            {
              "function_args": 0,
              "closure_args": 1,
              "function_args_average": 0.0,
              "closure_args_average": 1.0,
              "total": 1,
              "average": 1.0,
              "function_args_min": 0,
              "function_args_max": 0,
              "closure_args_min": 1,
              "closure_args_max": 1
            }
            "#
            );
        });
    }

    #[test]
    fn rust_single_closure() {
        check_metrics::<RustParser>("let bar = |i: i32| -> i32 { i + 1 };", "foo.rs", |metric| {
            // 1 lambda
            insta::assert_json_snapshot!(
                metric.nargs,
                @r#"
            {
              "function_args": 0,
              "closure_args": 1,
              "function_args_average": 0.0,
              "closure_args_average": 1.0,
              "total": 1,
              "average": 1.0,
              "function_args_min": 0,
              "function_args_max": 0,
              "closure_args_min": 0,
              "closure_args_max": 1
            }
            "#
            );
        });
    }

    #[test]
    fn cpp_single_lambda() {
        check_metrics::<CppParser>(
            "auto bar = [](int x, int y) -> int { return x + y; };",
            "foo.cpp",
            |metric| {
                // 1 lambda
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 2,
                  "function_args_average": 0.0,
                  "closure_args_average": 2.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 2,
                  "closure_args_max": 2
                }
                "#
                );
            },
        );
    }

    #[test]
    fn javascript_single_closure() {
        check_metrics::<JavascriptParser>("function (a, b) {return a + b};", "foo.js", |metric| {
            // 1 lambda
            insta::assert_json_snapshot!(
                metric.nargs,
                @r#"
            {
              "function_args": 0,
              "closure_args": 2,
              "function_args_average": 0.0,
              "closure_args_average": 2.0,
              "total": 2,
              "average": 2.0,
              "function_args_min": 0,
              "function_args_max": 0,
              "closure_args_min": 0,
              "closure_args_max": 2
            }
            "#
            );
        });
    }

    #[test]
    fn python_functions() {
        check_metrics::<PythonParser>(
            "def f(a, b):
                 if a:
                     return a
            def f(a, b):
                 if b:
                     return b",
            "foo.py",
            |metric| {
                // 2 functions
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 4,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 4,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );

        check_metrics::<PythonParser>(
            "def f(a, b):
                 if a:
                     return a
            def f(a, b, c):
                 if b:
                     return b",
            "foo.py",
            |metric| {
                // 2 functions
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 5,
                  "closure_args": 0,
                  "function_args_average": 2.5,
                  "closure_args_average": 0.0,
                  "total": 5,
                  "average": 2.5,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn rust_functions() {
        check_metrics::<RustParser>(
            "fn f(a: bool, b: usize) {
                 if a {
                     return a;
                }
             }
             fn f1(a: bool, b: usize) {
                 if a {
                     return a;
                }
             }",
            "foo.rs",
            |metric| {
                // 2 functions
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 4,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 4,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );

        check_metrics::<RustParser>(
            "fn f(a: bool, b: usize) {
                 if a {
                     return a;
                }
             }
             fn f1(a: bool, b: usize, c: usize) {
                 if a {
                     return a;
                }
             }",
            "foo.rs",
            |metric| {
                // 2 functions
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 5,
                  "closure_args": 0,
                  "function_args_average": 2.5,
                  "closure_args_average": 0.0,
                  "total": 5,
                  "average": 2.5,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    /// The `self` receiver (`self`, `&self`, `&mut self`) parses as a
    /// `self_parameter` node and, like Go's `receiver` field and C++'s
    /// implicit `this`, must not be counted as a formal parameter (#457).
    #[test]
    fn rust_method_excludes_self_receiver() {
        check_metrics::<RustParser>(
            "struct S;
             impl S {
                 fn a(self) {}                  // self          -> 0 args
                 fn b(&self, x: i32) {}         // &self     + 1 -> 1 arg
                 fn c(&mut self, x: i32, y: i32) {} // &mut self + 2 -> 2 args
             }",
            "foo.rs",
            |metric| {
                // 3 methods: 0 + 1 + 2 explicit params. The three receiver
                // forms contribute nothing. sum = 3, max = 2.
                let s = &metric.nargs;
                assert_eq!(s.function_args_sum(), 3);
                assert_eq!(s.function_args_max(), 2);
            },
        );

        // A *typed* receiver (`self: Box<Self>`, `self: Rc<Self>`,
        // `self: Pin<&mut Self>`) parses as an ordinary `parameter` node —
        // not `self_parameter` — but its binding is the `self` keyword, so
        // it is still a receiver and must be excluded too, matching the
        // bare-receiver case and Go/C++ receiver parity (#457). A normal
        // `parameter` like `x: i32` binds an `identifier`, never `self`.
        check_metrics::<RustParser>(
            "use std::rc::Rc;
             use std::pin::Pin;
             struct S;
             impl S {
                 fn a(self: Box<Self>, x: i32, y: i32) {} // receiver + 2 -> 2
                 fn b(self: Rc<Self>, x: i32) {}          // receiver + 1 -> 1
                 fn c(self: Pin<&mut Self>) {}            // receiver     -> 0
             }",
            "foo.rs",
            |metric| {
                // Each typed receiver contributes nothing. sum = 2+1+0 = 3,
                // max = 2 (from method `a`).
                let s = &metric.nargs;
                assert_eq!(s.function_args_sum(), 3);
                assert_eq!(s.function_args_max(), 2);
            },
        );
    }

    #[test]
    fn c_functions() {
        check_metrics::<CParser>(
            "int f(int a, int b) {
                 if (a) {
                     return a;
                }
             }
             int f1(int a, int b) {
                 if (a) {
                     return a;
                }
             }",
            "foo.c",
            |metric| {
                // 2 functions
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 4,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 4,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );

        check_metrics::<CppParser>(
            "int f(int a, int b) {
                 if (a) {
                     return a;
                }
             }
             int f1(int a, int b, int c) {
                 if (a) {
                     return a;
                }
             }",
            "foo.c",
            |metric| {
                // 2 functions
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 5,
                  "closure_args": 0,
                  "function_args_average": 2.5,
                  "closure_args_average": 0.0,
                  "total": 5,
                  "average": 2.5,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn javascript_functions() {
        check_metrics::<JavascriptParser>(
            "function f(a, b) {
                 return a * b;
             }
             function f1(a, b) {
                 return a * b;
             }",
            "foo.js",
            |metric| {
                // 2 functions
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 4,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 4,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );

        check_metrics::<JavascriptParser>(
            "function f(a, b) {
                 return a * b;
             }
             function f1(a, b, c) {
                 return a * b;
             }",
            "foo.js",
            |metric| {
                // 2 functions
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 5,
                  "closure_args": 0,
                  "function_args_average": 2.5,
                  "closure_args_average": 0.0,
                  "total": 5,
                  "average": 2.5,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn python_nested_functions() {
        check_metrics::<PythonParser>(
            "def f(a, b):
                 def foo(a):
                     if a:
                         return 1
                 bar = lambda a: lambda b: b or True or True
                 return bar(foo(a))(a)",
            "foo.py",
            |metric| {
                // 2 functions + 2 lambdas = 4
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 3,
                  "closure_args": 2,
                  "function_args_average": 1.5,
                  "closure_args_average": 1.0,
                  "total": 5,
                  "average": 1.25,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 2
                }
                "#
                );
            },
        );
    }

    #[test]
    fn rust_nested_functions() {
        check_metrics::<RustParser>(
            "fn f(a: i32, b: i32) -> i32 {
                 fn foo(a: i32) -> i32 {
                     return a;
                 }
                 let bar = |a: i32, b: i32| -> i32 { a + 1 };
                 let bar1 = |b: i32| -> i32 { b + 1 };
                 return bar(foo(a), a);
             }",
            "foo.rs",
            |metric| {
                // 2 functions + 2 lambdas = 4
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 3,
                  "closure_args": 3,
                  "function_args_average": 1.5,
                  "closure_args_average": 1.5,
                  "total": 6,
                  "average": 1.5,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 2
                }
                "#
                );
            },
        );
    }

    #[test]
    fn cpp_nested_functions() {
        check_metrics::<CppParser>(
            "int f(int a, int b, int c) {
                 auto foo = [](int x) -> int { return x; };
                 auto bar = [](int x, int y) -> int { return x + y; };
                 return bar(foo(a), a);
             }",
            "foo.cpp",
            |metric| {
                // 1 functions + 2 lambdas = 3
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 3,
                  "closure_args": 3,
                  "function_args_average": 3.0,
                  "closure_args_average": 1.5,
                  "total": 6,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 3
                }
                "#
                );
            },
        );
    }

    /// Default arguments still surface as separate `parameter_declaration`
    /// nodes — defaults are not removed from the count.  A 3-param function
    /// whose third parameter has a default value reports `nargs = 3`.
    #[test]
    fn cpp_default_arguments() {
        check_metrics::<CppParser>(
            "int f(int a, int b, int c = 0) {
                 return a + b + c;
             }",
            "foo.cpp",
            |metric| {
                // 1 function, 3 parameters (defaults still count).
                let s = &metric.nargs;
                assert_eq!(s.function_args_sum(), 3);
                assert_eq!(s.function_args_max(), 3);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 3,
                  "closure_args": 0,
                  "function_args_average": 3.0,
                  "closure_args_average": 0.0,
                  "total": 3,
                  "average": 3.0,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    /// C-style variadic `...` parameter contributes +1 (one named declarator
    /// plus the `...` declarator).  The grammar emits the variadic ellipsis
    /// as a sibling parameter node that `compute_args` counts via the
    /// `is_non_arg` filter (which excludes only `(`, `)`, and `,`).
    #[test]
    fn c_variadic_function() {
        check_metrics::<CParser>(
            "int printf(const char* fmt, ...) {
                 return 0;
             }",
            "foo.c",
            |metric| {
                // 1 function, 2 nargs: `fmt` and `...`
                let s = &metric.nargs;
                assert_eq!(s.function_args_sum(), 2);
                assert_eq!(s.function_args_max(), 2);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    /// C++ template parameter packs (`Args... args`) count as one runtime
    /// parameter (the parameter pack itself), not as N — the template
    /// arguments are compile-time and live on the template-parameter list,
    /// not on `parameters`.  The tree-sitter-cpp grammar represents
    /// `Args... args` as a single `variadic_parameter_declaration` under
    /// `parameters`.
    #[test]
    fn cpp_template_parameter_pack() {
        check_metrics::<CppParser>(
            "template<typename... Args>
             int sum(int seed, Args... args) {
                 return seed;
             }",
            "foo.cpp",
            |metric| {
                // 1 function, 2 nargs: `seed` and `Args... args`
                let s = &metric.nargs;
                assert_eq!(s.function_args_sum(), 2);
                assert_eq!(s.function_args_max(), 2);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    /// Lambda capture list (`[=, &x]`) is not part of the parameter list.
    /// `compute_args` reads the `declarator` field, which only contains the
    /// `( … )` parameter list.  Variables captured for the closure body do
    /// not inflate `nargs`.
    #[test]
    fn cpp_lambda_capture_not_counted() {
        check_metrics::<CppParser>(
            "int f() {
                 int x = 1;
                 int y = 2;
                 auto g = [=, &x](int a, int b) -> int { return a + b + x + y; };
                 return g(1, 2);
             }",
            "foo.cpp",
            |metric| {
                // 1 function (0 args), 1 lambda (2 args: a, b — captures `=, &x` excluded).
                let s = &metric.nargs;
                assert_eq!(s.function_args_sum(), 0);
                assert_eq!(s.closure_args_sum(), 2);
                assert_eq!(s.closure_args_max(), 2);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 2,
                  "function_args_average": 0.0,
                  "closure_args_average": 2.0,
                  "total": 2,
                  "average": 1.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 2
                }
                "#
                );
            },
        );
    }

    /// Implicit `this` on a member function is not part of the AST
    /// parameter list — it is an implicit argument at the language level
    /// only.  A non-static member function `void M(int a)` reports
    /// `nargs = 1`, not 2.
    #[test]
    fn cpp_member_function_this_not_counted() {
        check_metrics::<CppParser>(
            "struct S {
                 int x;
                 int set(int a) {     // implicit `this` is NOT counted
                     this->x = a;
                     return a;
                 }
             };",
            "foo.cpp",
            |metric| {
                // 1 member function with 1 explicit parameter `a`.
                let s = &metric.nargs;
                assert_eq!(s.function_args_sum(), 1);
                assert_eq!(s.function_args_max(), 1);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 1,
                  "closure_args": 0,
                  "function_args_average": 1.0,
                  "closure_args_average": 0.0,
                  "total": 1,
                  "average": 1.0,
                  "function_args_min": 0,
                  "function_args_max": 1,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn go_zero_args() {
        check_metrics::<GoParser>(
            "package main
            func f() {}",
            "foo.go",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 0,
                  "function_args_average": 0.0,
                  "closure_args_average": 0.0,
                  "total": 0,
                  "average": 0.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn go_multiple_args() {
        check_metrics::<GoParser>(
            "package main
            func f(a int, b string, c bool) {}",
            "foo.go",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 3,
                  "closure_args": 0,
                  "function_args_average": 3.0,
                  "closure_args_average": 0.0,
                  "total": 3,
                  "average": 3.0,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn go_method_excludes_receiver() {
        check_metrics::<GoParser>(
            "package main
            type T struct{}
            func (t *T) Greet(name string) string {
                return name
            }",
            "foo.go",
            |metric| {
                // Receiver is in a separate `receiver` field and is not counted.
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 1,
                  "closure_args": 0,
                  "function_args_average": 1.0,
                  "closure_args_average": 0.0,
                  "total": 1,
                  "average": 1.0,
                  "function_args_min": 0,
                  "function_args_max": 1,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn go_variadic() {
        check_metrics::<GoParser>(
            "package main
            func f(args ...int) {}",
            "foo.go",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 1,
                  "closure_args": 0,
                  "function_args_average": 1.0,
                  "closure_args_average": 0.0,
                  "total": 1,
                  "average": 1.0,
                  "function_args_min": 0,
                  "function_args_max": 1,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn go_grouped_params() {
        check_metrics::<GoParser>(
            "package main
            func f(a, b int, c string) {}",
            "foo.go",
            |metric| {
                // `a, b int` is one parameter_declaration with two `name`
                // children — semantically two parameters.
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 3,
                  "closure_args": 0,
                  "function_args_average": 3.0,
                  "closure_args_average": 0.0,
                  "total": 3,
                  "average": 3.0,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn go_func_literal_args() {
        check_metrics::<GoParser>(
            "package main
            var f = func(x, y int) int { return x + y }",
            "foo.go",
            |metric| {
                // Closure with grouped params: `x, y int` -> 2 closure args.
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 2,
                  "function_args_average": 0.0,
                  "closure_args_average": 2.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 2
                }
                "#
                );
            },
        );
    }

    #[test]
    fn javascript_nested_functions() {
        check_metrics::<JavascriptParser>(
            "function f(a, b) {
                 function foo(a, c) {
                     return a;
                 }
                 var bar = function (a, b) {return a + b};
                 function (a) {return a};
                 return bar(foo(a), a);
             }",
            "foo.js",
            |metric| {
                // 3 functions + 1 lambdas = 4
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 6,
                  "closure_args": 1,
                  "function_args_average": 2.0,
                  "closure_args_average": 1.0,
                  "total": 7,
                  "average": 1.75,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 1
                }
                "#
                );
            },
        );
    }

    #[test]
    fn perl_no_functions_and_closures() {
        check_metrics::<PerlParser>(
            "my $x = 1;
             print $x;",
            "foo.pl",
            |metric| {
                // Cross-check via nom that no spurious sub/closure was
                // recognised — symmetric with the other `perl_*` nargs
                // tests, and would catch a regression that miscounted
                // `print` (or similar) as a function.
                assert_eq!(metric.nom.functions_sum(), 0);
                assert_eq!(metric.nom.closures_sum(), 0);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 0,
                  "function_args_average": 0.0,
                  "closure_args_average": 0.0,
                  "total": 0,
                  "average": 0.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn perl_single_function() {
        // Perl args arrive via `@_` rather than as formal parameters in the
        // `sub` signature, so nargs is always 0. To make sure the test still
        // discriminates "function parsed" from "function silently dropped",
        // also assert nom recognised exactly one function.
        check_metrics::<PerlParser>(
            "sub greet {
                my ($name) = @_;
                print \"hi $name\";
            }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.nom.functions_sum(), 1);
                assert_eq!(metric.nom.closures_sum(), 0);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 0,
                  "function_args_average": 0.0,
                  "closure_args_average": 0.0,
                  "total": 0,
                  "average": 0.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn perl_single_closure() {
        // Same caveat as `perl_single_function`: closures take their
        // arguments through `@_`, so nargs stays 0. Assert via nom that the
        // anonymous function was actually identified as a closure.
        check_metrics::<PerlParser>(
            "my $f = sub {
                my ($x) = @_;
                return $x + 1;
            };",
            "foo.pl",
            |metric| {
                assert_eq!(metric.nom.functions_sum(), 0);
                assert_eq!(metric.nom.closures_sum(), 1);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 0,
                  "function_args_average": 0.0,
                  "closure_args_average": 0.0,
                  "total": 0,
                  "average": 0.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn perl_multiple_functions() {
        // Same caveat as `perl_single_function`. Assert nom counted both
        // top-level subs so the test fails if either sub is dropped.
        check_metrics::<PerlParser>(
            "sub a { return 1; }
             sub b {
                 my ($x, $y) = @_;
                 return $x + $y;
             }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.nom.functions_sum(), 2);
                assert_eq!(metric.nom.closures_sum(), 0);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 0,
                  "function_args_average": 0.0,
                  "closure_args_average": 0.0,
                  "total": 0,
                  "average": 0.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn perl_nested_closure() {
        // Same caveat as `perl_single_function`. Assert nom recognised one
        // outer sub plus one nested closure.
        check_metrics::<PerlParser>(
            "sub outer {
                my $inner = sub { return 42; };
                return $inner->();
            }",
            "foo.pl",
            |metric| {
                assert_eq!(metric.nom.functions_sum(), 1);
                assert_eq!(metric.nom.closures_sum(), 1);
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 0,
                  "function_args_average": 0.0,
                  "closure_args_average": 0.0,
                  "total": 0,
                  "average": 0.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn java_no_functions() {
        check_metrics::<JavaParser>(
            "class Foo {
                 int x = 42;
                 String name = \"hello\";
             }",
            "foo.java",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 0,
                  "function_args_average": 0.0,
                  "closure_args_average": 0.0,
                  "total": 0,
                  "average": 0.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn java_single_method() {
        check_metrics::<JavaParser>(
            "class Foo {
                 void greet(String name, int count) {
                     return;
                 }
             }",
            "foo.java",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn java_multiple_methods() {
        check_metrics::<JavaParser>(
            "class Foo {
                 void a(int x) {
                     return;
                 }
                 void b(int x, int y, int z) {
                     return;
                 }
             }",
            "foo.java",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 4,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 4,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn java_constructor_args() {
        check_metrics::<JavaParser>(
            "class Foo {
                 Foo(String name, int age) {
                     return;
                 }
             }",
            "foo.java",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    /// Java's explicit receiver parameter (`void m(S this, int a)`, JLS
    /// 8.4.1) parses as a `receiver_parameter` node — distinct from a real
    /// `formal_parameter` — and binds `this`, not a value. Like Rust's
    /// `self_parameter` (#457), Go's `receiver` field, and C++'s implicit
    /// `this`, it must not be counted as a formal parameter (#470).
    #[test]
    fn java_method_excludes_explicit_receiver() {
        check_metrics::<JavaParser>(
            "class S {
                 void m(S this, int a) {}   // receiver + 1 -> 1 arg
                 void n(int a, int b) {}     // control: 2 real params
                 void r(S this) {}           // receiver only  -> 0 args
             }",
            "foo.java",
            |metric| {
                // m:1 + n:2 + r:0. The two receiver parameters contribute
                // nothing. Pre-fix, the receivers inflated this to sum = 5
                // (m:2 + n:2 + r:1), max = 2. After #470: sum = 3, max = 2.
                let s = &metric.nargs;
                assert_eq!(s.function_args_sum(), 3);
                assert_eq!(s.function_args_max(), 2);
            },
        );
    }

    #[test]
    fn java_lambda_args() {
        check_metrics::<JavaParser>(
            "class Foo {
                 void run() {
                     Runnable r = (int a, int b) -> a + b;
                 }
             }",
            "foo.java",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 2,
                  "function_args_average": 0.0,
                  "closure_args_average": 2.0,
                  "total": 2,
                  "average": 1.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 2
                }
                "#
                );
            },
        );
    }

    #[test]
    fn groovy_no_functions_and_closures() {
        check_metrics::<GroovyParser>("int x = 1", "foo.groovy", |metric| {
            assert_eq!(metric.nargs.total(), 0);
        });
    }

    #[test]
    fn groovy_single_method() {
        check_metrics::<GroovyParser>(
            "class A {
                void greet(String name, int times) {
                    println(name)
                }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 2);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
            },
        );
    }

    #[test]
    fn groovy_multiple_methods() {
        check_metrics::<GroovyParser>(
            "class A {
                int add(int x, int y) { x + y }
                int sub(int x, int y, int z) { x - y - z }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 5);
            },
        );
    }

    #[test]
    fn groovy_lambda_args() {
        // Two-parameter Groovy closure inside a method body. Groovy's
        // primary lambda-shaped construct is the closure
        // (`{ params -> body }`); the dekobon grammar does not model
        // Java's `(params) -> body` arrow form because real-world
        // Groovy code rarely uses it.
        check_metrics::<GroovyParser>(
            "class Foo {
                void run() {
                    def f = { int a, int b -> a + b }
                }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.nargs.closure_args_sum(), 2);
            },
        );
    }

    #[test]
    fn groovy_implicit_it_not_counted() {
        // The `it` implicit closure parameter is just an identifier in
        // the grammar — no `formal_parameters` node. `nargs` counts
        // declared parameters only, so this closure has 0.
        check_metrics::<GroovyParser>(
            "class A {
                void apply() {
                    [1, 2, 3].each { println(it) }
                }
            }",
            "foo.groovy",
            |metric| {
                assert_eq!(metric.nargs.closure_args_sum(), 0);
            },
        );
    }

    #[test]
    fn csharp_no_functions() {
        check_metrics::<CsharpParser>(
            "class Foo {
                 int x = 42;
                 string Name = \"hello\";
             }",
            "foo.cs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 0,
                  "function_args_average": 0.0,
                  "closure_args_average": 0.0,
                  "total": 0,
                  "average": 0.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn csharp_single_method() {
        check_metrics::<CsharpParser>(
            "class Foo {
                 void Greet(string name, int count) {
                     return;
                 }
             }",
            "foo.cs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn csharp_multiple_methods() {
        check_metrics::<CsharpParser>(
            "class Foo {
                 void A(int x) {
                     return;
                 }
                 void B(int x, int y, int z) {
                     return;
                 }
             }",
            "foo.cs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 4,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 4,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn csharp_constructor_args() {
        check_metrics::<CsharpParser>(
            "class Foo {
                 public Foo(string name, int age) {
                     return;
                 }
             }",
            "foo.cs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn csharp_lambda_args() {
        check_metrics::<CsharpParser>(
            "class Foo {
                 void Run() {
                     System.Func<int, int, int> f = (int a, int b) => a + b;
                 }
             }",
            "foo.cs",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 2,
                  "function_args_average": 0.0,
                  "closure_args_average": 2.0,
                  "total": 2,
                  "average": 1.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 2
                }
                "#
                );
            },
        );
    }

    #[test]
    fn tsx_function_and_arrow() {
        check_metrics::<TsxParser>(
            "function add(a: number, b: number): number {
                 return a + b;
             }
             const multiply = (x: number, y: number) => x * y;",
            "foo.tsx",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 4,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 4,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn typescript_typed_and_optional_params() {
        check_metrics::<TypescriptParser>(
            "function format(value: number, prefix?: string, suffix?: string): string {
                 return (prefix ?? '') + value.toString() + (suffix ?? '');
             }
             const identity = (x: number): number => x;",
            "foo.ts",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 4,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 4,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn mozjs_single_function() {
        check_metrics::<MozjsParser>(
            "function f(a, b) {
                 return a * b;
             }",
            "foo.js",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn mozjs_closure_args() {
        check_metrics::<MozjsParser>("function (a, b) {return a + b};", "foo.js", |metric| {
            insta::assert_json_snapshot!(
                metric.nargs,
                @r#"
            {
              "function_args": 0,
              "closure_args": 2,
              "function_args_average": 0.0,
              "closure_args_average": 2.0,
              "total": 2,
              "average": 2.0,
              "function_args_min": 0,
              "function_args_max": 0,
              "closure_args_min": 0,
              "closure_args_max": 2
            }
            "#
            );
        });
    }

    // Regression tests for issue #77: bare-identifier arrow functions
    // (`x => x`) use the singular `parameter` field instead of the plural
    // `parameters` field, and were previously counted as nargs=0.
    //
    // `total` is used so the assertion is independent of whether the
    // arrow function is classified as a function or a closure (this depends
    // on its enclosing context — e.g. a `VariableDeclarator` ancestor makes
    // it a function).

    #[test]
    fn javascript_bare_arrow_function() {
        check_metrics::<JavascriptParser>("const f = x => x;", "foo.js", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn javascript_async_bare_arrow_function() {
        check_metrics::<JavascriptParser>("const f = async x => x;", "foo.js", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn javascript_parenthesized_arrow_function() {
        check_metrics::<JavascriptParser>("const f = (x) => x;", "foo.js", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn javascript_multi_parenthesized_arrow_function() {
        check_metrics::<JavascriptParser>("const f = (x, y) => x + y;", "foo.js", |metric| {
            assert_eq!(metric.nargs.total(), 2);
        });
    }

    #[test]
    fn typescript_bare_arrow_function() {
        check_metrics::<TypescriptParser>("const f = x => x;", "foo.ts", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn typescript_async_bare_arrow_function() {
        check_metrics::<TypescriptParser>("const f = async x => x;", "foo.ts", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn typescript_parenthesized_arrow_function() {
        check_metrics::<TypescriptParser>("const f = (x: number) => x;", "foo.ts", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn typescript_multi_parenthesized_arrow_function() {
        check_metrics::<TypescriptParser>(
            "const f = (x: number, y: number) => x + y;",
            "foo.ts",
            |metric| {
                assert_eq!(metric.nargs.total(), 2);
            },
        );
    }

    #[test]
    fn tsx_bare_arrow_function() {
        check_metrics::<TsxParser>("const f = x => x;", "foo.tsx", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn tsx_async_bare_arrow_function() {
        check_metrics::<TsxParser>("const f = async x => x;", "foo.tsx", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn tsx_parenthesized_arrow_function() {
        check_metrics::<TsxParser>("const f = (x: number) => x;", "foo.tsx", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn tsx_multi_parenthesized_arrow_function() {
        check_metrics::<TsxParser>(
            "const f = (x: number, y: number) => x + y;",
            "foo.tsx",
            |metric| {
                assert_eq!(metric.nargs.total(), 2);
            },
        );
    }

    #[test]
    fn mozjs_bare_arrow_function() {
        check_metrics::<MozjsParser>("const f = x => x;", "foo.js", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn mozjs_async_bare_arrow_function() {
        check_metrics::<MozjsParser>("const f = async x => x;", "foo.js", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn mozjs_parenthesized_arrow_function() {
        check_metrics::<MozjsParser>("const f = (x) => x;", "foo.js", |metric| {
            assert_eq!(metric.nargs.total(), 1);
        });
    }

    #[test]
    fn mozjs_multi_parenthesized_arrow_function() {
        check_metrics::<MozjsParser>("const f = (x, y) => x + y;", "foo.js", |metric| {
            assert_eq!(metric.nargs.total(), 2);
        });
    }

    #[test]
    fn kotlin_nargs_functions_and_closures() {
        check_metrics::<KotlinParser>(
            "fun add(a: Int, b: Int): Int {
                val transform = { x: Int, y: Int -> x + y }
                return transform(a, b)
            }",
            "foo.kt",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 2,
                  "function_args_average": 2.0,
                  "closure_args_average": 2.0,
                  "total": 4,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 2
                }
                "#
                );
            },
        );
    }

    #[test]
    fn lua_no_functions_and_closures() {
        check_metrics::<LuaParser>("local x = 1", "foo.lua", |metric| {
            // No functions or closures: both halves are zero.
            assert_eq!(metric.nargs.function_args_sum(), 0);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
            insta::assert_json_snapshot!(metric.nargs);
        });
    }

    #[test]
    fn lua_single_function() {
        check_metrics::<LuaParser>("function f(a, b) return a + b end", "foo.lua", |metric| {
            // f(a, b) → fn_args_sum 2, no closures.
            assert_eq!(metric.nargs.function_args_sum(), 2);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
            insta::assert_json_snapshot!(metric.nargs);
        });
    }

    #[test]
    fn lua_single_closure() {
        check_metrics::<LuaParser>(
            "local f = function(a, b) return a + b end",
            "foo.lua",
            |metric| {
                // Anonymous `function(a, b)` bound via `local` → closure_args_sum 2.
                assert_eq!(metric.nargs.function_args_sum(), 0);
                assert_eq!(metric.nargs.closure_args_sum(), 2);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn lua_functions() {
        check_metrics::<LuaParser>(
            "function f(a) return a end
function g(x, y, z) return x + y + z end",
            "foo.lua",
            |metric| {
                // f(a)=1 + g(x,y,z)=3 → fn_args_sum 4.
                assert_eq!(metric.nargs.function_args_sum(), 4);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn lua_vararg_function() {
        // `...` is a vararg_expression node and counts as one argument.
        check_metrics::<LuaParser>("function f(a, ...) return a end", "foo.lua", |metric| {
            // a + ... → fn_args_sum 2.
            assert_eq!(metric.nargs.function_args_sum(), 2);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
            insta::assert_json_snapshot!(metric.nargs);
        });
    }

    #[test]
    fn lua_colon_method_nargs() {
        // Colon syntax: `self` is implicit and NOT in the `parameters` node.
        // Only explicit params (a, b) are counted.
        check_metrics::<LuaParser>(
            "function obj:method(a, b) return a + b end",
            "foo.lua",
            |metric| {
                // Only explicit a, b → fn_args_sum 2 (implicit self excluded).
                assert_eq!(metric.nargs.function_args_sum(), 2);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn tcl_no_functions() {
        check_metrics::<TclParser>("set x 1", "foo.tcl", |metric| {
            // Bare `set` command, no procs → both halves zero.
            assert_eq!(metric.nargs.function_args_sum(), 0);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
            insta::assert_json_snapshot!(metric.nargs);
        });
    }

    #[test]
    fn tcl_single_function() {
        check_metrics::<TclParser>("proc f {a b} { puts $a }", "foo.tcl", |metric| {
            // proc f {a b} → fn_args_sum 2.
            assert_eq!(metric.nargs.function_args_sum(), 2);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
            insta::assert_json_snapshot!(metric.nargs);
        });
    }

    #[test]
    fn tcl_single_function_no_args() {
        check_metrics::<TclParser>("proc f {} { puts hello }", "foo.tcl", |metric| {
            // proc f {} → empty arg list, fn_args_sum 0.
            assert_eq!(metric.nargs.function_args_sum(), 0);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
            insta::assert_json_snapshot!(metric.nargs);
        });
    }

    #[test]
    fn tcl_functions() {
        check_metrics::<TclParser>(
            "proc f {a b} { puts $a }
proc g {x y z} { puts $x }",
            "foo.tcl",
            |metric| {
                // f(a,b)=2 + g(x,y,z)=3 → fn_args_sum 5.
                assert_eq!(metric.nargs.function_args_sum(), 5);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn tcl_nested_functions() {
        check_metrics::<TclParser>(
            "proc outer {a} {
    proc inner {x y} { puts $x }
    inner $a $a
}",
            "foo.tcl",
            |metric| {
                // outer(a)=1 + inner(x,y)=2 → fn_args_sum 3.
                assert_eq!(metric.nargs.function_args_sum(), 3);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn tcl_args_vararg() {
        // `args` is the Tcl variadic catch-all; it counts as one argument.
        check_metrics::<TclParser>("proc f {a b args} { puts $a }", "foo.tcl", |metric| {
            // a + b + args → fn_args_sum 3 (variadic is one slot).
            assert_eq!(metric.nargs.function_args_sum(), 3);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
            insta::assert_json_snapshot!(metric.nargs);
        });
    }

    #[test]
    fn tcl_default_arg() {
        // `{name default}` is a single argument with a default value.
        check_metrics::<TclParser>(
            "proc greet {{name World} greeting} {
    puts \"$greeting, $name!\"
}",
            "foo.tcl",
            |metric| {
                // {name World} counts as one slot + greeting → fn_args_sum 2.
                assert_eq!(metric.nargs.function_args_sum(), 2);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn kotlin_zero_args() {
        check_metrics::<KotlinParser>("fun f(): Int { return 42 }", "foo.kt", |metric| {
            // fun f() → empty parameter list, fn_args_sum 0.
            assert_eq!(metric.nargs.function_args_sum(), 0);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
            insta::assert_json_snapshot!(metric.nargs);
        });
    }

    #[test]
    fn kotlin_single_arg() {
        check_metrics::<KotlinParser>(
            "fun double(x: Int): Int { return x * 2 }",
            "foo.kt",
            |metric| {
                // double(x) → fn_args_sum 1.
                assert_eq!(metric.nargs.function_args_sum(), 1);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn kotlin_multiple_args() {
        check_metrics::<KotlinParser>(
            "fun add(a: Int, b: Int, c: Int): Int { return a + b + c }",
            "foo.kt",
            |metric| {
                // add(a, b, c) → fn_args_sum 3.
                assert_eq!(metric.nargs.function_args_sum(), 3);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn kotlin_default_args() {
        check_metrics::<KotlinParser>(
            "fun greet(name: String = \"World\", greeting: String = \"Hello\"): String {
                 return \"$greeting, $name!\"
             }",
            "foo.kt",
            |metric| {
                // Defaults still count as parameter slots → fn_args_sum 2.
                assert_eq!(metric.nargs.function_args_sum(), 2);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn kotlin_empty_lambda() {
        // Two lambdas in the same function body: one with two explicit parameters
        // (proving the lambda path is taken and args are counted), and one with an
        // explicit empty parameter list `{ -> expr }` (proving
        // `compute_kotlin_lambda_args` returns 0 for it without crashing or
        // accidentally counting tokens inside the arrow expression).
        // If the grammar fails to parse either lambda, `total_closures` would be
        // lower than 2, making the snapshot unambiguous.
        check_metrics::<KotlinParser>(
            "fun f() {
                 val two = { x: Int, y: Int -> x + y }
                 val zero = { -> 42 }
             }",
            "foo.kt",
            |metric| {
                // Outer fun f() has 0 params; two lambdas counted as closures:
                // {x, y -> ...} contributes 2, {-> 42} contributes 0 →
                // closure_args_sum 2 across two closure entries.
                assert_eq!(metric.nargs.function_args_sum(), 0);
                assert_eq!(metric.nargs.closure_args_sum(), 2);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn kotlin_anonymous_function() {
        // `fun(x: Int, y: Int) = x + y` — anonymous function expression.
        // The grammar surfaces it as an `AnonymousFunction` node, which routes
        // through `compute_kotlin_func_args` (not the lambda path).
        check_metrics::<KotlinParser>(
            "val add = fun(x: Int, y: Int): Int = x + y",
            "foo.kt",
            |metric| {
                // Anonymous fun(x, y) is classified as a closure → closure_args_sum 2.
                assert_eq!(metric.nargs.function_args_sum(), 0);
                assert_eq!(metric.nargs.closure_args_sum(), 2);
                insta::assert_json_snapshot!(metric.nargs);
            },
        );
    }

    #[test]
    fn php_no_functions_and_closures() {
        check_metrics::<PhpParser>("<?php $a = 42;", "foo.php", |metric| {
            insta::assert_json_snapshot!(
                metric.nargs,
                @r#"
            {
              "function_args": 0,
              "closure_args": 0,
              "function_args_average": 0.0,
              "closure_args_average": 0.0,
              "total": 0,
              "average": 0.0,
              "function_args_min": 0,
              "function_args_max": 0,
              "closure_args_min": 0,
              "closure_args_max": 0
            }
            "#
            );
        });
    }

    #[test]
    fn php_single_function() {
        // Two parameters in a regular function.
        check_metrics::<PhpParser>(
            "<?php
            function f(bool $a, int $b): bool {
                if ($a) { return $a; }
                return false;
            }",
            "foo.php",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn php_single_closure() {
        // Anonymous function with 2 params + arrow function with 1 param.
        // Each is a separate closure space.
        check_metrics::<PhpParser>(
            "<?php
            $f = function (int $a, int $b) { return $a + $b; };
            $g = fn (int $x) => $x * 2;",
            "foo.php",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 0,
                  "closure_args": 3,
                  "function_args_average": 0.0,
                  "closure_args_average": 1.5,
                  "total": 3,
                  "average": 1.5,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 2
                }
                "#
                );
            },
        );
    }

    #[test]
    fn php_functions() {
        // Two top-level functions, 1 + 2 args.
        check_metrics::<PhpParser>(
            "<?php
            function a(int $x): int { return $x; }
            function b(int $x, int $y): int { return $x + $y; }",
            "foo.php",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 3,
                  "closure_args": 0,
                  "function_args_average": 1.5,
                  "closure_args_average": 0.0,
                  "total": 3,
                  "average": 1.5,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#
                );
            },
        );
    }

    #[test]
    fn php_nested_functions() {
        // PHP cannot define nested named functions inside a function body
        // syntactically, but a class with methods exhibits the same shape:
        // a top-level scope plus inner function-spaces.
        check_metrics::<PhpParser>(
            "<?php
            class A {
                public function outer(int $a): int {
                    $f = function (int $b) use ($a) { return $a + $b; };
                    return $f($a);
                }
            }",
            "foo.php",
            |metric| {
                insta::assert_json_snapshot!(
                    metric.nargs,
                    @r#"
                {
                  "function_args": 1,
                  "closure_args": 1,
                  "function_args_average": 1.0,
                  "closure_args_average": 1.0,
                  "total": 2,
                  "average": 1.0,
                  "function_args_min": 0,
                  "function_args_max": 1,
                  "closure_args_min": 0,
                  "closure_args_max": 1
                }
                "#
                );
            },
        );
    }

    #[test]
    fn elixir_default_nargs_is_zero() {
        // Documents Elixir's current default-impl behaviour. `def` calls
        // are not recognised as functions (`is_func` returns `false`),
        // and Elixir anonymous functions hold their parameters inside
        // a `stab_clause` (not a parameter-list field), so the default
        // `NArgs::compute` heuristic finds no formal parameters to
        // count. This anchors the limitation so a future real impl
        // that wires up `stab_clause`-based argument counting cannot
        // silently regress to zero.
        check_metrics::<ElixirParser>(
            "defmodule Foo do\n  def add(a, b), do: a + b\n  def use_anon do\n    add2 = fn x, y -> x + y end\n    add2.(1, 2)\n  end\nend\n",
            "foo.ex",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 0);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
            },
        );
    }

    #[test]
    fn ruby_no_functions_and_closures() {
        check_metrics::<RubyParser>("a = 42\n", "foo.rb", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 0);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
        });
    }

    #[test]
    fn ruby_single_function() {
        // Single method with 3 parameters.
        check_metrics::<RubyParser>("def foo(a, b, c)\n  a + b + c\nend\n", "foo.rb", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 3);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
        });
    }

    #[test]
    fn ruby_single_closure() {
        // A bare block `[1,2,3].each { |x| ... }` is the only closure
        // here; `each` is a method call so the method-args count is 0.
        check_metrics::<RubyParser>("[1, 2, 3].each { |x| puts x }\n", "foo.rb", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 0);
            assert_eq!(metric.nargs.closure_args_sum(), 1);
        });
    }

    #[test]
    fn ruby_functions() {
        // Two methods, args=2 and args=1; one lambda with args=2.
        check_metrics::<RubyParser>(
            "def add(a, b)\n  a + b\nend\n\ndef neg(x)\n  -x\nend\n\nf = ->(a, b) { a * b }\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 3);
                assert_eq!(metric.nargs.closure_args_sum(), 2);
            },
        );
    }

    #[test]
    fn ruby_nested_functions() {
        // An outer method with 1 arg containing an inner method with 2.
        check_metrics::<RubyParser>(
            "def outer(a)\n  def inner(b, c)\n    b + c\n  end\n  inner(a, a)\nend\n",
            "foo.rb",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 3);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
            },
        );
    }

    /// PEP 570 positional-only `/` and PEP 3102 keyword-only `*` markers are
    /// punctuation, not parameters. The grammar emits them as
    /// `positional_separator` / `keyword_separator` siblings of the real
    /// parameter nodes; both must be excluded from nargs (issue #414).
    #[test]
    fn python_both_parameter_separators() {
        // 1 function, 3 real parameters: pos_only, normal, kw_only.
        check_metrics::<PythonParser>(
            "def f(pos_only, /, normal, *, kw_only): pass",
            "foo.py",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 3);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
            },
        );
    }

    /// Trailing positional-only `/` (no following parameter) is still excluded.
    #[test]
    fn python_positional_separator_only() {
        // 1 function, 2 real parameters: a, b (`/` excluded).
        check_metrics::<PythonParser>("def f(a, b, /): pass", "foo.py", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 2);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
        });
    }

    /// Leading keyword-only `*` (forcing all following parameters to be
    /// keyword-only) is excluded.
    #[test]
    fn python_keyword_separator_only() {
        // 1 function, 2 real parameters: a, b (`*` excluded).
        check_metrics::<PythonParser>("def f(*, a, b): pass", "foo.py", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 2);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
        });
    }

    /// Lambdas accept the same keyword-only `*` separator; it is excluded
    /// from the closure arg count.
    #[test]
    fn python_lambda_keyword_separator() {
        // 1 lambda, 2 real parameters: a, b (`*` excluded).
        check_metrics::<PythonParser>("g = lambda a, *, b: a", "foo.py", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 0);
            assert_eq!(metric.nargs.closure_args_sum(), 2);
        });
    }

    /// Regression guard: `*args` / `**kwargs` are real parameter nodes
    /// (`list_splat_pattern` / `dictionary_splat_pattern`), not separators,
    /// and must keep contributing to the count after the #414 fix.
    #[test]
    fn python_args_kwargs_still_counted() {
        // 1 function, 3 parameters: a, *args, **kwargs.
        check_metrics::<PythonParser>("def f(a, *args, **kwargs): pass", "foo.py", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 3);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
        });
    }

    /// A file of bare top-level commands has no function spaces, so the
    /// argument count is zero.
    #[test]
    fn irules_no_functions_and_closures() {
        check_metrics::<IrulesParser>("set x 1\nlog local0. $x\n", "foo.irule", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 0);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
        });
    }

    /// A `when` handler is a function space but has no formal parameters
    /// (the event context is implicit), so its argument count is zero —
    /// `when_event` carries no `arguments` field. Guards edge case #10.
    #[test]
    fn irules_handler_zero_args() {
        check_metrics::<IrulesParser>(
            "when HTTP_REQUEST { log local0. \"hit\" }\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 0);
                assert_eq!(metric.nargs.closure_args_sum(), 0);
                // The handler is still counted as a function space.
                assert_eq!(metric.nom.functions_sum(), 1);
            },
        );
    }

    /// A `proc` with two formal parameters contributes two arguments.
    #[test]
    fn irules_single_proc() {
        check_metrics::<IrulesParser>("proc f { a b } { return $a }\n", "foo.irule", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 2);
            assert_eq!(metric.nargs.closure_args_sum(), 0);
        });
    }

    /// A `proc` with an empty argument list contributes zero arguments.
    #[test]
    fn irules_proc_no_args() {
        check_metrics::<IrulesParser>("proc f { } { return 1 }\n", "foo.irule", |metric| {
            assert_eq!(metric.nargs.function_args_sum(), 0);
        });
    }

    /// A default-valued parameter (`{b 5}`) is a single `argument`, so each
    /// formal parameter counts once regardless of its default: `{a {b 5} c}`
    /// is three arguments.
    #[test]
    fn irules_proc_arg_defaults() {
        check_metrics::<IrulesParser>(
            "proc f { a {b 5} c } { return $a }\n",
            "foo.irule",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 3);
            },
        );
    }

    /// A `proc` and a `when` handler in one file: only the proc's two
    /// parameters count; the handler contributes zero.
    #[test]
    fn irules_multiple_functions() {
        check_metrics::<IrulesParser>(
            "proc add { a b } { return [expr { $a + $b }] }
when HTTP_REQUEST { log local0. \"hit\" }
",
            "foo.irule",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 2);
                assert_eq!(metric.nom.functions_sum(), 2);
            },
        );
    }

    /// Objective-C unary method `- (void)foo` declares zero arguments.
    #[test]
    fn objc_no_args() {
        check_metrics::<ObjcParser>(
            "@implementation Foo
- (void)foo {
    [self doWork];
}
@end
",
            "foo.m",
            |metric| {
                assert_eq!(metric.nargs.total(), 0);
                insta::assert_json_snapshot!(metric.nargs, @r#"
                {
                  "function_args": 0,
                  "closure_args": 0,
                  "function_args_average": 0.0,
                  "closure_args_average": 0.0,
                  "total": 0,
                  "average": 0.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#);
            },
        );
    }

    /// Objective-C keyword method `- (void)foo:(int)a bar:(int)b` has two
    /// `method_parameter` children, so `function_args` is 2.
    #[test]
    fn objc_method_two_args() {
        check_metrics::<ObjcParser>(
            "@implementation Foo
- (void)foo:(int)a bar:(int)b {
    [self use:a];
}
@end
",
            "foo.m",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 2);
                insta::assert_json_snapshot!(metric.nargs, @r#"
                {
                  "function_args": 2,
                  "closure_args": 0,
                  "function_args_average": 2.0,
                  "closure_args_average": 0.0,
                  "total": 2,
                  "average": 2.0,
                  "function_args_min": 0,
                  "function_args_max": 2,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#);
            },
        );
    }

    /// Free C `function_definition` inside an ObjC translation unit counts
    /// its declarator parameters: `void f(int a, int b, int c)` has 3.
    #[test]
    fn objc_function_args() {
        check_metrics::<ObjcParser>(
            "void f(int a, int b, int c) {
    return;
}
",
            "foo.m",
            |metric| {
                assert_eq!(metric.nargs.function_args_sum(), 3);
                insta::assert_json_snapshot!(metric.nargs, @r#"
                {
                  "function_args": 3,
                  "closure_args": 0,
                  "function_args_average": 3.0,
                  "closure_args_average": 0.0,
                  "total": 3,
                  "average": 3.0,
                  "function_args_min": 0,
                  "function_args_max": 3,
                  "closure_args_min": 0,
                  "closure_args_max": 0
                }
                "#);
            },
        );
    }

    /// Objective-C block literal `^(int x, int y){ … }` is a closure
    /// whose `parameter_list` holds two `parameter_declaration`s, so
    /// `closure_args` is 2.
    #[test]
    fn objc_block_args() {
        check_metrics::<ObjcParser>(
            "@implementation Foo
- (void)bar {
    void (^blk)(int, int) = ^(int x, int y){
        [self use:x];
    };
    blk(1, 2);
}
@end
",
            "foo.m",
            |metric| {
                assert_eq!(metric.nargs.closure_args_sum(), 2);
                insta::assert_json_snapshot!(metric.nargs, @r#"
                {
                  "function_args": 0,
                  "closure_args": 2,
                  "function_args_average": 0.0,
                  "closure_args_average": 2.0,
                  "total": 2,
                  "average": 1.0,
                  "function_args_min": 0,
                  "function_args_max": 0,
                  "closure_args_min": 0,
                  "closure_args_max": 2
                }
                "#);
            },
        );
    }

    /// Regression for #782: the textual `Display` headline must report
    /// the cross-space *sum* (`function_args_sum`/`closure_args_sum`),
    /// matching the JSON/YAML/TOML/CBOR serializers, not the per-space
    /// direct accumulator. At a parent space that rolls up child
    /// function-spaces (the file/unit space of `python_nested_functions`)
    /// the accumulator under-counts: it reflects only the direct
    /// function `f` (2 args) and no merged closures (0), while the sum
    /// is 3 function args (f=2, foo=1) and 2 closure args. Before the
    /// fix Display printed `function_args: 2, closure_args: 0`.
    #[test]
    fn display_headline_matches_sum_for_nested_functions() {
        check_metrics::<PythonParser>(
            "def f(a, b):
                 def foo(a):
                     if a:
                         return 1
                 bar = lambda a: lambda b: b or True or True
                 return bar(foo(a))(a)",
            "foo.py",
            |metric| {
                let stats = &metric.nargs;
                // The summed accessors are the cross-format source of truth.
                assert_eq!(stats.function_args_sum(), 3);
                assert_eq!(stats.closure_args_sum(), 2);

                // The Display headline must echo those sums verbatim.
                let rendered = stats.to_string();
                assert!(
                    rendered.starts_with(&format!(
                        "function_args: {}, closure_args: {},",
                        stats.function_args_sum(),
                        stats.closure_args_sum()
                    )),
                    "Display headline diverged from the summed accessors: {rendered}"
                );
            },
        );
    }
}