Skip to content

fix: post-#1701 follow-up batch (9 issues) - #1824

Merged
dekobon merged 17 commits into
mainfrom
fix/batch-2026-11-04
Nov 5, 2026
Merged

dekobon merged 17 commits into
mainfrom
fix/batch-2026-11-04

Conversation

@dekobon

@dekobon dekobon commented Nov 5, 2026

Copy link
Copy Markdown
Owner

Post-#1701 follow-up batch: the issues the role tables made cheaper to fix well. Plan: the brief and execution plan were reviewed by astra-review and sol-review before work started; five design decisions (D1–D5 below) were put to the maintainer and are recorded in each issue's ## Resolution.

Issues

# Change Kind
#1284 cyclomatic / cognitive / nexits average / min / max all read the SpaceKind::Function population — numerator, divisor and extrema from one predicate (FunctionPopulation<T>); spaceless closures leave the divisor; sum unchanged. D1: scope is these three; nargs' two-channel form is #1809. Changed; 1,753 snapshots
#1800, #1765 Cognitive follows Sonar v1.7 "Ignore shorthand": ?? / ??=, Elvis ?:, Perl // / //= no longer score; cyclomatic unchanged; safe navigation pinned at 0 in 9 languages. D2: PHP break N / continue N +1 for any explicit level, break 1 included — and Bash break n, found by the whole-branch review. Changed
#1796 (b) keep the TS/TSX after_code bypass; decision on the two DocTarget rows. comment-only
#1793 no_chain gate modifier. D5 + A+B: a no_chain gate has signature fn(&Node, &[u8]) (compiler-enforced), every row emits CHAIN_GATED beside TEXT_GATED, 21 byte-less forwards assert !TEXT_GATED && !CHAIN_GATED, 17 byte-gated forwards assert !CHAIN_GATED, and a derived backstop compares every unchained row under the real and the empty chain with Node::parent climb counters bracketing both owns_kind and the opens_space fold. zero drift (0 / 46 606)
#1797 D4: rename HoldsDocInBody → DocBodyResidual; no adapter change. zero drift
#1647 A comment of any kind inside a Rust outer-attribute run is part of it (both scans, both oracles); /// above the attribute pruned with the item. src/wire.rs self-scan sloc 718 → 495. Fixed
#1399 D3: an attribute is public iff any generated accessor is; npa re-files on a later private :b through the shared Ruby ledger; private "foo" resolves for npm and npa; splat / non-literal stay unmodelled by decision. Fixed
#1646 The two cheap items: PHP define() DocBlock (through grouping parentheses; imported aliases documented as NameResolver's), Doxygen quoted text and <![CDATA[. Six Doxygen bullets remain on the issue with a triage table. Fixed, partial

Review and passes

  • Astra checkpoint after waves 1–2 (3 findings fixed), then simplify-rust (42 asserts → 2 macros; FunctionPopulation<T>; −308 lines), rust-optimize, audit-tests (3 tests made to discriminate, each perturbation-verified) — all zero-drift against the post-batch tree.
  • Six whole-branch reviewers (review, code-review max, performance, under-reviewed areas, astra-review, architecture) → one fix commit; astra-review of that commit → one more (Bash break -- is no level; the function-named-break limit stated and pinned).
  • lessons-learned: no new numbered entry; lesson 114 gains the refactor(roles): add child_gated_by and CHAIN_GATED so byte-less forwards assert no gate reads the chain #1793 sub-example; three rule additions.

Evidence

  • make pre-commit: BCA_GATE: pass on HEAD. check-test-lang-gates-compare COMPARE_REF=origin/main OK. role-census / role-coverage / role-bypass OK (bypass baseline empty). self-scan-baseline-fresh 0/0/0/0; self-scan-profile-parity byte-identical. chain-audit 650 passed. role-parity-corpus pass. bench-scaling 111/111.
  • Drift, pre-batch (07822c69) → post-batch: 22 272 of 46 606 outputs differ, all in metric views, 0 in ops / dump / find / count — attributed per item on each issue. Every refactor item and every pass: 0 / 46 606 against its own base, with the command and both bca --version build-input digests on the issue.
  • Perturbation records (utils/perturb.py, old / new strings) are on each issue; long records are gist-linked.
  • Rebased twice onto origin/main (the gix branch, then chore(deps): drop basic-toml from enums via askama features (RUSTSEC-2026-0374) #1822); .bca-baseline.toml regenerated at each -merge conflict, never resolved; batch content verified byte-identical against a backup ref both times.

Submodule

tests/repositories/big-code-analysis-output → d411e605 (pushed; #1284 and #1800 snapshots). .role-coverage-observed.txt refreshed in the same commits.

Closes #1284, #1800, #1765, #1796, #1793, #1797, #1647, #1399. Refs #1646, #1809.

`cyclomatic`, `cognitive` and `nexits` reported an `average` / `min` /
`max` triple drawn from two populations: the divisor counted function
spaces (`function_spaces` for cyclomatic, `nom.total()` for the other
two, which also counts spaceless closures such as Python lambdas) while
the numerator and the extrema folded every space's own value, the file
unit and containers included. `fn f() {}` reported cyclomatic
`average 2.0` against `min 1, max 1`; a Python function holding one
lambda reported cognitive `average 7.0` against `min 14, max 14`; and
the unit's own 0 pinned file-level cognitive `min` at 0 on nearly every
file. 3 499 spaces in DeepSpeech, 400 in pdf.js and 392 in serde had an
average outside `[min, max]`.

All three now fold numerator, divisor and extrema from one predicate —
the space's recorded `kind == SpaceKind::Function`, read once in the
walk's `compute_minmax` and handed to each metric — and merge the new
function-only accumulators up through containers. The published
all-space `sum` is unchanged (it is what MI and WMC read), and every
`sum` / `value` across the three corpora is byte-identical before and
after. A subtree with no function space reports `0.0 / 0 / 0`. The
cyclomatic divisor seed moves out of `FuncSpace::new` into the same
fold, so one site decides membership for all three statistics;
`compute_averages` no longer feeds `nom.total()` to cognitive / nexits.
The `Cognitive | Nexits => [Nom]` dependency is kept so a selection
naming either still emits the same blocks.

The book gains an "Aggregate population" section the cognitive,
cyclomatic and nexits chapters link to; the accessor docs, the
`average` helper's convention note, and the Python stub's dependency
text say which spaces the three fields read. Snapshots move on
`average` / `min` / `max` only: 117 in-tree, 1 636 in the integration
submodule (bumped to 234c55bd, pushed), three CSV rows, three web
fixtures; `.role-coverage-observed.txt` is refreshed for the gitlink.

`function_population_tests.rs` pins the issue's three reproducers and
the Python / Rust / C / Java / Kotlin / JavaScript fixtures where the old
divisor and the new population differ (spaceless lambdas, and
`Function` spaces `nom` never counted: `static {}`, accessors, `init`),
each with its value on `main` beside the derivation, plus an invariant
sweep over eleven languages re-deriving mean / min / max from the tree.
Every production line is verified by perturbation; `nargs`' two-channel
form of the same defect is #1809.

Fixes #1284
…break N

The Cognitive Complexity white paper (v1.7, "Ignore shorthand", p. 6)
ignores null-coalescing operators as a one-line spelling of
`if (x == null) …`. Cognitive now does too: `??` and `??=` in the JS
family, C# and PHP, Elvis `?:` in Kotlin and Groovy, and Perl's
defined-or `//` / `//=` no longer fold into the boolean sequence.
Cyclomatic keeps paying each as a decision (#230's choice stands
there), and `&&=` / `||=` keep scoring where a shared arm or
classifier spelled all three. Safe navigation (`?.`, `&.`, `?->`,
`??.`, `?[`) was never read by cognitive; one fixture per language now
pins that at 0, anchored on cyclomatic so a plain access cannot pass.

PHP's `break N` / `continue N` is B1's `break NUMBER` / `continue
NUMBER` and pays a flat +1 for any explicit argument — `break 1;`
included, as sonar-php increments on `tree.argument() != null` — in
place of the +0 #435 chose. The gate is a named, non-comment child of
the jump, not the `integer` kind, since the grammar admits any
expression there.

Every pinned test is re-derived with the paper section it follows and
reads cyclomatic as proof the ignored operator is still in its
fixture. The module header of `cognitive.rs` states the policy once;
the `NullSafe` row comments drop the consumer sentence that stated
the old one, per `.claude/rules/macro-comments.md`. The book's
cognitive chapter now says the operators are ignored, lists Ruby's
`redo` / `retry` under the deviations, and removes `break N` from
them.

32 integration snapshots move, cognitive fields only (submodule
d411e605); `.role-coverage-observed.txt` is refreshed for the gitlink.

Fixes #1800
Fixes #1765
The `DocTarget` rows in `roles/typescript.rs` and `roles/tsx.rs` own
the four parameter kinds through the shared `js_family_doc_targets!`
fragment but expose no parameter-only subset; tsc's after-code rule
applies to parameters and to nothing else in the row, so the Checker
in `checker/typescript.rs` and `checker/tsx.rs` carries that subset
under a `// role-bypass: allow(DocTarget)` exemption.

Decision (b): keep the exemption, add no `Parameter` role. One
consumer in two dialects does not justify a 30th role that reopens
all 29 other tables, mostly as `absent`. The two row comments now
state that in one sentence so the next reader does not re-ask, and
the two exemption reasons cite the decision instead of #1701.

Comment-only: `git diff -U0` carries no non-`//` hunk, the three role
gates pass with byte-identical baselines, and
`make self-scan-baseline-fresh` reports 0 added / 0 removed /
0 worsened / 0 improved.

Fixes #1796
…rds assert what they drop

The role tables pinned one of the two inputs a context-dropping
forward hands a row: `TEXT_GATED` for the bytes, nothing for the chain
(lesson 103, lesson 114). A gate marked `gated_by f no_chain` /
`text_gated_by f no_chain` / `opens_by f no_chain` now has the
signature `fn(&Node, &[u8])` and is called with two arguments, so the
chain is unobtainable by construction rather than by promise; each row
emits `CHAIN_GATED` (any owner gate or `opens_by` without the mark) and
`canonical()` carries both flags so the Python reader is held to both.
`callable_when`, `pays_itself_when` and a payer's gate reject the
modifier: no chain-less forward reads them, and the JS `FuncOpener`
rows carry a chain-reading `callable_when` beside an `opens_space`
fold that never calls it.

Forwards assert exactly what they drop: `impl_byte_gated_row_predicate!`
asserts `!CHAIN_GATED` on `DocComment` / `DocRunDirective` (17 uses);
the byte-less `is_func_space` / `get_space_kind` pair asserts
`!TEXT_GATED && !CHAIN_GATED` on `FuncOpener` and `Container` in 21
languages. Elixir overrides rather than forwards; Ruby's `FuncOpener`
is chain-gated by design and stays pinned by
`ruby_byte_less_spellings_stay_the_kind_table`. Only those two roles
may carry `opens` / `opens_by`, so an opener on a third role cannot
bypass the two-row assertion.

The signature proves "no chain parameter", not "no ancestry read":
`no_chain_rows_answer_alike_under_the_empty_chain` compares every
`!CHAIN_GATED` row under the real and the empty chain on every corpus
candidate, and holds the new `node_resolved_parent_lookups` counter
still, so a `Node::parent` climb is reported whatever it answers.

Migration: 90 references (55 `gated_by`, 34 `text_gated_by`, 1
`opens_by`) across 24 table files; 40 gate fns lose their chain
parameter. Zero drift: 0 of 46 606 outputs differ over 3 329 corpus
files in 25 languages; the three role baselines are byte-identical.
`.bca-baseline.toml` refreshed for `roles/mod.rs`'s `loc.*` rows.

Fixes #1793
Checkpoint review of waves 1-2 (astra-review) found three gaps.

The no_chain backstop bracketed owns_kind with the parent and sibling
climb counters but not the opens_space fold that follows, and
owns_kind never reaches an `opens_by` fn - so a Node::parent climb
added to Kotlin's `class_or_interface` escaped both halves (the
comparison half cannot see a climb that reads the same tree under
either chain). Bracket the fold too; verified with utils/perturb.py:
the same perturbation is UNCAUGHT before and caught after. Correct the
doc that claimed the comparison half catches a parent-kind read.

The book's aggregate-population section said every other metric's
average / min / max is a per-space average; NArgs keeps its two
function and closure channels divided by NOM's counts (#1809). Say so.

Five NullSafe row comments (csharp, groovy, kotlin, perl, php) still
explained which consumer scores which token; per macro-comments.md a
row states the grammar fact and the reading lives at the consumer,
where each abc/ and cyclomatic/ module already states it.

Refs #1793, #1284, #1800
`HoldsDocInBody` was a residual by name only: the row declares the
kinds beyond `FuncOpener` and `Closure` whose body a language's doc
tool reads a comment into, and `Checker::holds_doc_comment_in_body`
composes `is_func ∪ is_closure ∪ <row>` with its body-child test. The
name read as the full set. `DocBodyResidual` says what the row holds,
in the noun shape of its siblings (`DocTarget`, `DocRunOpener`,
`DocRunDirective`); the module doc now states the residual
definition and that a kind moving between `FuncOpener`/`Closure` and
this row changes nothing the Checker answers.

Rename only (maintainer decision D4): no adapter, gate or test
semantics change; `holds_doc_in_body` → `doc_body_residual` for the
projection module and `holds_doc_in_body_kind!` → `doc_body_residual_kind!`
for the Checker macro; every `absent` reason string is unchanged.
`utils/role_tables.py` derives the role set from `mod.rs` and needs
no edit. Zero drift: 0 of 46 606 outputs differ over 3 329 corpus
files in 25 languages; the three role baselines are byte-identical.
`.bca-baseline.toml` refreshed for `roles/mod.rs`'s `loc.sloc`.

Fixes #1797
The `exclude_tests` prune ended an outer-attribute run at the first
sibling that was not an `AttributeItem`, so a comment between
`#[cfg(test)]` and the item it decorates kept the item: `src/wire.rs`
carried 218 SLOC of `mod tests` in the gated self-scan. rustc reads a
`//` or `/* */` comment as no token, so the attribute still applies, and
reads an outer `///` as a `#[doc]` attribute of the same run.

Both production scans (`rust_attributed_item` forward,
`rust_outer_attr_marks_test` backward) and both test oracles now read
past a comment of either kind, through a shared `rust_attribute_run_member`
that takes the kinds from the `Comment` and `DocComment` rows. An outer
doc comment above the attribute opens the run the way an attribute does
(`rust_attribute_run_start`), so its row goes with the pruned item; a
plain comment above the first attribute, and a `//!` inner doc comment,
are not the item's and stay. A plain comment inside a run is answered by
the reach of the row that opened it, never read backward on its own, so
a long stretch of `//` rows stays linear; `nom/deep-doc-comment-run`
prices the doc-row form of the run (1.86 with the reach removed, 1.08
with it).

Fixes #1647
An attribute is public iff any of the accessors it generated is public
(#1399, maintainer decision D3). `attr_accessor :b` synthesises the
reader `b` and the writer `b=`, and `private :b` names the reader
alone, so the attribute stays public; `attr_reader :b; private :b`
leaves no accessor public and `class_npa` drops by one, the only value
that moves. `private :b=`, `private :b, :b=`, `public :b` promoting
back, `protected :b`, several symbols, and `attr_reader :initialize`
(auto-private reader, public writer) each follow from the rule, every
one measured on ruby 3.0.2.

`npa`'s consumer gains `leave_call` and keys a ledger by
`(name, RubyAccessor)`, and the mechanics `npm` already had — the
declaration slots, the by-name re-file covering the declarations so
far, the resolve at the end of the body, the hand-up of what a nested
visibility call returns, the auto-private name list — move to
`npa/ruby_ledger.rs` so the two consumers share one `RubyLedger<K>`
and one `ruby_leave_visibility_call`. `npm`'s observable behaviour is
unchanged and its tests are untouched. An `attr_*` macro now also hands
its accessor names up to an enclosing keyword, so `private public
attr_accessor :x` composes as `npm`'s `private public def x` does.

§3: `private "foo"` is `private :foo`. `ruby_symbol_name` becomes
`ruby_name_argument` and accepts a `string` whose whole content is one
`string_content` — no interpolation, no escape — for both consumers
through the shared `ruby_argument_names`, which also lets
`attr_reader "f"` declare. §2 (splat, bare identifier, nested call)
stays unmodelled by decision; `ruby_argument_names` answers nothing for
those shapes and the npa twin of npm's existing test pins it.

Perturbations of the fold, the re-file, the `:b=` split, both string
arms, the auto-private rule, the hand-up and the ledger's coverage are
each caught by the tests named on the issue, as is deleting the
visibility line from every fixture whose total the rule lets move.

Fixes #1399
phpDocumentor's `Define` factory (`Reflection/Php/Factory/Define.php`,
`matches`) turns an `Expression` holding a `FuncCall` whose `Name`
prints exactly `define` into a constant carrying the statement's
DocBlock. bca read every expression statement as taking none, so the
block above `define('X', 1);` was `cloc` only.

The `DocTarget` row of `roles/php.rs` now owns `expression_statement`
under a `no_chain` byte gate on the callee: a bare `define` or the
fully qualified `\define`, which PHP-Parser's `NameResolver` prints as
`define`; `DEFINE`, `defined`, a namespace-qualified `Foo\define`, a
`namespace\define` and an assigned `$x = define(...)` stay plain. The
checker's signature set reads the row's kind table less the statement,
since a DocBlock after a call's arguments binds forward like one after
any statement's expression; `a_docblock_inside_a_statement_is_in_no_signature`
pins it. The row's parity exception is recorded in
`doc_tests/parity.rs`, and `.role-coverage-baseline.txt` drops the
`expression_statement` entry the row now claims.

A `define()` inside a function body is a constant to the tool too
(`Function_` descends its statements), but bca's in-body policy
withholds every in-body DocBlock before the binding runs; the row in
`dloc.rs` records that divergence.

Refs #1646
…structural command

`doxygen_standalone` decides whether a C-family doc block carries a
command that makes it an entry of its own (`@file`, `@class X`, …).
It already read past the text Doxygen's scanner does not read for
commands — a fence, a backtick span, an HTML comment, a format block,
an escape — but not two more `commentscan.l` `<Comment>` rules: text
quoted with `"` and closed on the same line (`"\""[^"\n]*"\""`), and
a `<![CDATA[` section, which runs to `]]>` or the end of the block.
A `/** "@file" */` above `#include` therefore stood alone and counted
as `dloc` where Doxygen attaches it to nothing.

`literal_end` gains the two arms. An unclosed `"` is one character,
so the command after it is still read; the classifier rows pin both
directions and the `dloc.rs` table the four dialects share pins the
counts. Derived from the lexer rules (#1646 records the lines), not
from a run: the x86-64 Doxygen release does not run on this host.

Refs #1646
Update CHANGELOG.md with entries from all successfully merged issue
fixes in this batch: #1284, #1800, #1765, #1793, #1797, #1796 under
Changed; #1647, #1399, #1646 under Fixed.
Three read-only review passes (reuse, clarity, efficiency) over the
batch diff; the Improve findings applied as one commit.

Reuse. The byte-less `is_func_space` / `get_space_kind` forwards
carried the same four-term `const` assert in 42 per-language files;
`impl_byte_less_func_space!` and `impl_byte_less_space_kind!` emit it
once each, the crate's convention for the sibling forwards. The
function-space population #1284 added was folded in four copies across
cyclomatic (twice), cognitive and nexits; `FunctionPopulation<T>` in
`metrics/mod.rs` holds numerator, count and extrema and is what each
metric's `average` / `min` / `max` read, so the three cannot describe
different populations by construction. The `MAX` sentinel collapse the
accessors each repeated lives in its `min()`, which also let cognitive
and nexits derive `Default`.

Efficiency. `ruby_argument_names` allocated a `Vec` per call argument
on both Ruby walks where `main` had none; it answers an iterator.

Clarity. The `no_chain` backstop's narrative sits on the test it
describes, not on the probe struct, and no longer says "one language";
`class_or_interface_no_chain` sits beside its three-argument original;
`literal_end` asks `delimited_end` before the backtick span instead of
excluding the fence with a `.filter(|_| ..)`; `RubyAttributes::read`'s
comment says it records rather than counts; a `Range::clone` in
`tally` is a slice; a dead `enum_glob_use` allow goes.

No output changes: lib and integration suites green, no snapshot moved.
The `rust-optimize` analysis over the batch diff, with each macro
claim probed under rustc 2024 before applying.

`ruby_argument_names` answers `Option::into_iter().chain(..)` of the
one-symbol and `%i[..]` shapes instead of a hand-rolled three-variant
iterator; the same three shapes, no custom type, and the private enum
no longer shares a name with npm's `RubyArgumentNames` alias.
`ruby_name_argument` is private, its only callers being in its file.

The `text_gated_kind` / `chain_gated_kind` detector rules take an
optional literal `holds_payer` — a detector emits `true` and re-emits
nothing, so `$(holds_payer)?` is sound there where the folds, which
must re-emit the word, cannot use it; three rule pairs become three
rules and the DSL pins hold.

`FunctionPopulation` keeps `min` as `Option<T>` rather than a `MAX`
sentinel, so `PopulationValue` needs no `ZERO` / `MAX` and the struct
derives `Default`; an empty population still reports 0.

Test code: the four Ruby npa re-filing tests share `assert_class_npa`
rather than restating one loop; the prune-shape test compares the two
halves without an owned copy of the expected names.

No output changes.
Two audits over the batch's new and re-pinned tests, each finding
verified by utils/perturb.py before and after the fix.

The #1284 invariant sweep counted "spaces where the old and new
populations differ" from cyclomatic alone, and every non-function
space in its eleven fixtures scored 0 cognitive and 0 nexits — so for
those two metrics a numerator folding every space read the same as
the function-only one and the sweep passed under the perturbation.
The Python and JS fixtures now carry module-level flow, and the
counter is per metric with a floor the module-flow fixtures must meet.

Three re-pinned snapshots kept the derivation prose from the old
`nom.total()` divisor beside values the function-space population now
produces; each states the new population and the `main`-side value,
and the two Python tests gained an integer assert on `sum`.

The #1399 re-filing test had no fixture pairing an `attr_*` with a
later `private_class_method :b` / `public_class_method :b`, so
dropping the `targets_singleton` guard was uncaught across npa and
npm; two classes measured on ruby 3.0.2 pin it.

Test code only.
… findings

The whole-branch review pass (six readers over origin/main..HEAD).

The one bug: #1765's PHP `break N` fix was not swept across siblings,
and its resolution claimed no other grammar has a numeric-level jump.
Bash does (POSIX `break n`), parsed as a plain `command` with no jump
kind — grammar-dispatch §9 — so the cognitive arm reads the leading
word off the `name` field and a named level after it: +1 for any
written level, `break 1` included, +0 for the bare word, the reading
PHP took. `f() { for …; do for …; do break 2; done; done; … }` scored
5 on main and scores 7; cyclomatic is 6 either way and anchors the
fixture.

PHP `define()` (#1646) missed `(define('X', 1));` — PHP-Parser drops
grouping parentheses, so phpDocumentor attaches the DocBlock; the gate
now reads through them. An imported alias (`use function Vendor\make
as define;`) is NameResolver's and not this gate's: documented on the
gate and pinned as reading as written.

Docs. The book dated the #1284 change to 2.4, which is the release
that *has* the old behaviour; its deviations intro said PHP break N
was off the list while the list still carried it. Both say what they
mean, and the row covers Bash. The Python test docstring and a
spaces_tests comment still described the old divisor. Two NullSafe
row comments (Kotlin, C#) kept a consumer sentence the checkpoint
trim had missed. "What the mechanism cannot see" now names the
backstop's corpus bound: a `no_chain` owner no fixture spells is
neither compared nor counted. The average-population rule had seven
copies; `FunctionPopulation`'s doc is the one in-tree narrative, the
book the user-facing one, and the three accessor docs and two walk
comments link there. The nested-keyword `D x W` note on the Ruby
ledger says it is new to npa, not inherited: npa gathered nothing
before #1399.

Refs #1765, #1646, #1284, #1793, #1399
astra-review of the review-fix commit found two things in the new
Bash `break n` arm.

`break --` and `continue --` are the bare jumps with the option
terminator written, and scored +1 as if `--` were a level; the level
read now skips it, so `break --` is +0 and `break -- 2` is +1. Pinned
by two rows in `bash_jump_pays_for_any_explicit_level_1765` (sum 10,
cyclomatic 8 either way), verified by perturbing the read back.

A function the script defines under the builtin's name — `break() {
…; }`, legal outside POSIX mode — is read as the builtin, because the
walk resolves no names. The earlier commit's premise that the name is
impossible was wrong; the gap is a syntactic limit every leading-word
reading shares, stated on the helper and pinned by
`bash_jump_reading_is_syntactic_1765` rather than left to be found.

The three `*_average` accessor docs name the book's *Aggregate
population* section, reachable from the published docs, rather than a
private type.

Refs #1765, #1284
…the batch review

The lessons-learned pass over fix/batch-2026-11-04. No new numbered
entry: every candidate was a standing obligation, which is a rule's,
or an instance of a mechanism lesson 114 already names.

Lesson 114 gains the #1793 sub-example: the read counter its closing
sentence asked for exists now (`Node::parent` records
`node_resolved_parent_lookups`), the answer-agreeing perturbation it
was built to catch, and the second call site the first placement
missed — the `opens_space` fold an `opens_by … no_chain` fn is reached
through.

testing.md's "Seed the state you claim to assert on" gains the #1284
instance — a fold restricted to a sub-population reads the same as the
unrestricted one while every excluded member contributes zero — and
its Lesson one clause for it. grammar-dispatch.md's sibling sweep says
to dump the construct in each grammar rather than search for a kind
name, since a §9 construct has none to find (#1765's Bash `break n`).
AGENTS.md's issue-body guidance records that the host proxy has
rejected table-carrying comments of a few kilobytes and the gist route
that took them (#1399, #1646).

Refs #1793, #1284, #1765, #1399, #1646
@codecov

codecov Bot commented Nov 5, 2026 •

Copy link
Copy Markdown

Codecov Report

❌ Patch coverage is 99.27484% with 10 lines in your changes missing coverage. Please review.
✅ Project coverage is 98.38%. Comparing base (9b617b0) to head (40ed84e).
⚠️ Report is 17 commits behind head on main.

Files with missing lines Patch % Lines
big-code-analysis-ast/src/roles/mod.rs 96.96% 6 Missing ⚠️
big-code-analysis-ast/src/checker.rs 97.14% 2 Missing ⚠️
big-code-analysis-ast/src/roles/php.rs 94.73% 1 Missing ⚠️
src/metrics/cognitive/bash.rs 91.66% 1 Missing ⚠️
Additional details and impacted files

Impacted file tree graph

@@           Coverage Diff            @@
##             main    #1824    +/-   ##
========================================
  Coverage   98.37%   98.38%            
========================================
  Files         395      396     +1     
  Lines      118113   118832   +719     
  Branches   117678   118397   +719     
========================================
+ Hits       116199   116911   +712     
- Misses       1202     1211     +9     
+ Partials      712      710     -2     
Flag Coverage Δ
python 100.00% <ø> (ø)
rust 98.37% <99.27%> (+<0.01%) ⬆️

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

Files with missing lines Coverage Δ
big-code-analysis-ast/src/checker/bash.rs 71.42% <ø> (-5.05%) ⬇️
big-code-analysis-ast/src/checker/c.rs 100.00% <ø> (ø)
big-code-analysis-ast/src/checker/cpp.rs 100.00% <ø> (ø)
big-code-analysis-ast/src/checker/csharp.rs 100.00% <100.00%> (ø)
big-code-analysis-ast/src/checker/go.rs 81.25% <ø> (-2.97%) ⬇️
big-code-analysis-ast/src/checker/groovy.rs 100.00% <100.00%> (ø)
big-code-analysis-ast/src/checker/irules.rs 81.25% <ø> (-2.97%) ⬇️
big-code-analysis-ast/src/checker/java.rs 100.00% <100.00%> (ø)
big-code-analysis-ast/src/checker/javascript.rs 100.00% <ø> (ø)
big-code-analysis-ast/src/checker/kotlin.rs 100.00% <100.00%> (ø)
... and 80 more

... and 2 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
dekobon merged commit 40ed84e into main Nov 5, 2026
59 checks passed
@dekobon
dekobon deleted the fix/batch-2026-11-04 branch November 5, 2026 18:08

This branch was previously deployed

1 inactive deployment
github-pages — 40ed84e6 Deployed Nov 5, 2026 by dekobon via deploy to GitHub Pages #977
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

fix(metrics): average/min/max aggregate over different space populations

1 participant