Function count_complexity

src/extraction/complexity.rs:62–169

Counts complexity metrics by iterating over all descendants of `node`. Uses an explicit stack instead of recursion (NASA Power of 10, Rule 1). The nesting depth tracks how many nesting-type ancestors enclose each node. `source` is needed to extract method/macro names for unchecked-call and assertion detection. Pass an empty slice to skip name-based matching.

(
    node: TsNode<'_>,
    config: &ComplexityConfig,
    source: &[u8],
)

/// `source` is needed to extract method/macro names for unchecked-call and
/// assertion detection. Pass an empty slice to skip name-based matching.
pub fn count_complexity(
    node: TsNode<'_>,
    config: &ComplexityConfig,
    source: &[u8],
) -> ComplexityMetrics {
    const MAX_ITERATIONS: usize = 500_000;
    debug_assert!(
        !config.branch_types.is_empty() || !config.loop_types.is_empty(),
        "count_complexity called with config that has no branch or loop types"
    );
    debug_assert!(
        node.child_count() > 0,
        "count_complexity called on a node with no children"
    );
    let mut metrics = ComplexityMetrics::default();

    // Stack: (tree-sitter node, current nesting depth)
    let mut stack: Vec<(TsNode<'_>, u32)> = Vec::new();

    // Seed with direct children of the function node. Earlier revisions used
    // `node.child(i)` in a `for i in 0..N` loop — tree-sitter's `child(i)`
    // is O(i) because it walks sibling links from the first child, so the
    // seed loop alone was O(N²) for high-fanout nodes (e.g. the giant
    // `switch` in `kernel/bpf/verifier.c` with thousands of cases). Use a
    // cursor for O(1) per step.
    push_children(&mut stack, node, 0);

    let mut iterations: usize = 0;

    while let Some((current, depth)) = stack.pop() {
        iterations += 1;
        if iterations >= MAX_ITERATIONS {
            break;
        }

        let kind = current.kind();

        // Classify the node.
        if config.branch_types.contains(&kind) {
            metrics.branches += 1;
        }
        if config.loop_types.contains(&kind) {
            metrics.loops += 1;
        }
        if config.return_types.contains(&kind) {
            metrics.returns += 1;
        }

        // Unsafe blocks.
        if config.unsafe_types.contains(&kind) {
            metrics.unsafe_blocks += 1;
        }

        // Unchecked operator types (e.g. non_null_assertion_expression, `!!`).
        if config.unchecked_types.contains(&kind) {
            metrics.unchecked_calls += 1;
        }