perf(cognitive): read function depth off the ancestor chain

[dekobon]

Summary

Closes the last of #1062's four Node::parent sites.
increment_function_depth asked every function node whether a function
encloses it by climbing with Node::parent, which tree_sitter
resolves by descending from the root. That is O(depth) per step, so
Cognitive stayed O(depth²) on nested function definitions
everywhere it is called.

The scan now reads the ancestor chain the walker hands down (Ancestors,
from #1084), so a step is a slice index. It was deferred out of #1084 to
bound that change's blast radius; all 19 call sites (22 languages,
counting the four the JS-family macro expands to) already had an
ancestors value in scope, so this is one helper signature plus one
argument per call — no per-language logic moves.

Code review then turned up two more per-node climbs inside the same
metric that the issue never listed: Kotlin's when-default check and
Ruby's case-default check each called node.parent() once per else
node, so a deeply nested if/else chain stayed quadratic in the very
metric this PR makes linear on nested definitions. Both read the same
chain now, and cognitive has no Node::parent call left in
production.

The in_function-flag mechanism sketched on the issue was not needed,
and neither was the per-language proof it would have required that each
match arm's kind set equals its stops set.

Measured

cargo bench -p big-code-analysis-bench --bench scaling, new
cognitive/nested-fn probe (Rust, Metric::Cognitive, depths
1000 / 2000 / 4000), fitted time ~ depth^k:

build	k	verdict
Node::parent climb (pre-fix body, new probe)	2.04	OVER BOUND
ancestor chain	1.21	ok (bound 1.50)

At depth 4000 the walk drops from ~150 ms to ~16 ms. No other probe
moved; nom/nested-fn on the same shape fits 1.13 and is the metric
control.

The probe is new because nom/nested-fn never reached this function —
it selects Metric::Nom. Its shape gains one if per level so
cognitive scores n(n+1)/2 on it, which moves if function depth stops
being counted, so the value column guards the walk as well as the
timing.

Correctness

Cognitive values are unchanged in every language. Two tests pin that:

• cognitive_function_depth_is_inherited_at_depth — the closed form
  n(n+1)/2 at depth 1000 for nested Rust fns.
• function_depth_surcharge_holds_across_languages — an if costs 1 in
  a top-level function and 2 one function deeper, for C, Objective-C,
  Mozcpp, JavaScript, MozJS, TypeScript, TSX, Ruby, Lua, Bash and
  iRules. Those were the languages whose function-depth arm had no test
  of its own; C++, C#, Groovy, Java, Kotlin, Perl, PHP, Python, Rust and
  Tcl already had one. Go is deliberately absent — its stop set is
  function_declaration / method_declaration, neither of which the
  grammar admits inside a function body, so the surcharge is unreachable
  there and a nested Go function takes the lambda path.

Both verified by perturbation: with *depth += 1 turned into
*depth += 0, the cross-language test reports all 11 rows and the
whole-suite run fails exactly 10 tests out of 3,110 — precise rather
than coarse.

The second commit is a test-audit fix: the surcharge table asserted only
the two costs, so a row whose snippet stopped parsing would keep
reporting 1 and 2 off an error-recovery tree (verified — appending
garbage to the C source left the test green). Each row now rejects an
ERROR-node parse first, which matters for the rows leaning on GNU nested
functions, Lua's nested function statement and an iRules proc inside
a proc.

Baseline

RubyCode::compute's halstead.effort crosses its recorded
.bca-baseline.toml value twice here — 52,423 → 53,271 on the added
argument, then → 53,802 on the case-default fix. Refreshed with
make self-scan-write-baseline-headroom in each of those commits, per
the baseline-refresh discipline in AGENTS.md; skipping it turns
make self-scan red on a clean checkout for everyone, not just the
author.

Still open elsewhere

The Node::parent climbs that remain are all outside cognitive and
outside every probed walk: the JS/TS is_func / is_closure walk,
Elixir's Npa / Npm / get_func_space_name / suppression-marker
lookups, the Halstead get_op_type getters, and per-node lookups in
several loc, npa / npm, cyclomatic and checker arms. That
last group was missing from the inventories in the CHANGELOG and
benchmarking.md, which read as exhaustive; both now say otherwise.
All stay tracked in #1088, which has been updated to record that its
deferred increment_function_depth item is done.

Validation

• make pre-commit green on the final tree.
• cargo test --workspace --all-features: 3,110 + 75 passing, 0 failed.
• Reviewed with the review, rust-optimize, audit-tests and
  code-review passes; every finding is folded into the four commits.
  The Kotlin / Ruby fix is covered by five existing tests, confirmed by
  perturbation (swapping in the grandparent fails exactly those five
  and nothing else).

Fixes #1062

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 98.10%. Comparing base (415ab6a) to head (07c4ac1).

Additional details and impacted files

@@            Coverage Diff             @@
##             main    #1095      +/-   ##
==========================================
+ Coverage   98.09%   98.10%   +0.01%     
==========================================
  Files         272      272              
  Lines       67426    67527     +101     
  Branches    66996    67097     +101     
==========================================
+ Hits        66143    66249     +106     
+ Misses        873      868       -5     
  Partials      410      410              

Flag	Coverage Δ
rust	98.09% <100.00%> (+0.01%)	⬆️

Flags with carried forward coverage won't be shown. Click here to find out more.

Files with missing lines	Coverage Δ
src/metrics/cognitive.rs	99.85% <100.00%> (+<0.01%)	⬆️
src/metrics/cognitive/bash.rs	100.00% <100.00%> (ø)
src/metrics/cognitive/c.rs	100.00% <100.00%> (ø)
src/metrics/cognitive/cpp.rs	100.00% <100.00%> (ø)
src/metrics/cognitive/csharp.rs	100.00% <100.00%> (ø)
src/metrics/cognitive/go.rs	97.91% <100.00%> (+0.04%)	⬆️
src/metrics/cognitive/groovy.rs	100.00% <100.00%> (ø)
src/metrics/cognitive/irules.rs	94.11% <100.00%> (+0.11%)	⬆️
src/metrics/cognitive/java.rs	100.00% <100.00%> (ø)
src/metrics/cognitive/kotlin.rs	100.00% <100.00%> (ø)
... and 11 more

... and 5 files with indirect coverage changes

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[dekobon]

Test coverage follow-up (07c4ac15)

Patch coverage was 93.88% — 92 hits, 4 misses, 2 partials — and all six
sat in one place: the failure-reporting branch of
function_depth_surcharge_holds_across_languages.

L9840 partial: if (flat_cost, nested_cost) != (1, 2) {
L9841 miss:        wrong.push(format!(
L9842 miss:            "{lang:?}: expected 1 then 2, got …"
L9843 miss:        ));
L9844 partial: }
L9850 miss:    wrong.join("\n"),

A hand-rolled diagnostic that runs only when the test fails is
unreachable on a green run by construction, so the fix is to not write
it. The table now builds a measured column and compares it against
expected with one assert_eq!, which keeps the "show every language
at once" property that the accumulator existed for and improves the
failure output — both columns, so you can see which rows are right:

left:  [(C, 1, 1), (Objc, 1, 1), (Mozcpp, 1, 1), …]
right: [(C, 1, 2), (Objc, 1, 2), (Mozcpp, 1, 2), …]

The gap the report could not see

Chasing those lines sent me back to what actually proves this change
correct. a_known_chain_answers_exactly_what_climbing_answers pins the
equivalence the whole PR rests on — a known chain answers exactly what
Node::parent climbing answers — over C, Java, Python and Elixir
fixtures. None of them contains a function nested inside a function,
Kotlin's when/else, or Ruby's case/else: the three shapes this
PR added as consumers. Parity over the machinery is not parity over the
shape a caller asks about. Added a fixture for each, checked against
their AST dumps rather than assumed.

Fixture rot

visited > 20 does not keep a fixture honest. A grammar bump that
flattened the nesting a row was added for would leave a large,
clean-parsing tree that exercises nothing, while every parity assertion
kept passing. assert_parity now takes the kinds that must appear
inside another node of the same kind; flattening the Rust fixture to
two sibling fns trips it:

rust: no `function_item` sits inside another `function_item`, so the
fixture no longer exercises the nesting it was added for

make pre-commit green.