Skip to content

fix: batch 2026-11-05 (6 issues + the find elision limit and a unittest sweep runner) - #1835

Merged
dekobon merged 25 commits into
mainfrom
fix/batch-2026-11-05
Nov 7, 2026
Merged

dekobon merged 25 commits into
mainfrom
fix/batch-2026-11-05

Conversation

@dekobon

@dekobon dekobon commented Nov 7, 2026 •

Copy link
Copy Markdown
Owner

Batch of six issues on one integration branch, in two halves. The first six (#1823, #1786, #1809, #1795, #1794, #1416) landed as the branch's first 17 commits and were reviewed, simplified and test-audited there. A second session then took the handoff's three open decisions, implemented the one that changed code, and put the whole branch through simplify-rust → rust-optimize → audit-tests, six parallel reviews (review, code-review --effort max, performance, under-reviewed areas, astra-review, architecture), five more reviews of the parts the first six had not reached (role-table parent lists, Doxygen by kind id, the deny script and workflows, prose, a second performance pass) and five astra re-reviews of the fixes. The resulting 22 commits were rebased into seven with an identical tree; the first-session commits are untouched. An eighth commit then clears the four actix advisories that had the deny job red on main.

Commits

Issue Commit(s) Change
#1823 fix(ci): audit all eight lockfiles with cargo-deny + 2 utils/check-deny-manifests.sh runs cargo-deny --locked --workspace once per tracked Cargo.lock (root plus the seven [workspace].exclude crates), called by the deny job in ci.yml and by deny-advisories.yml; a 0.20 version floor; check-excluded-manifests.py fails an excluded crate with no tracked lockfile.
#1786 docs(ast): bound the attribute-value reach gap Comment-only correction in checker.rs, verified against rustc 1.99.0.
#1809 docs(nargs): name the average-below-min exception + 1, test(nargs) closure_args_average can fall below closure_args_min (extrema fold every space, averages divide by nom's count); documented on Stats, in the book and the Python page, and now pinned by a test on the book's pick fixture. The definition is unchanged; #1827 tracks loc.
#1795 perf(ast): read Doxygen conditionals by kind id + 1 The C-family Doxygen binding reads preprocessor conditionals through is_preproc_conditional_kind by id, each child classified once. A constant-factor win (6–17% CPU on conditional-heavy files); output byte-identical to main on 1,319 DeepSpeech C-family files.
#1794 refactor(roles): add owner under / not_under lists + 2, fix(roles) A role_table! owner may carry K(under [P, ..]) / K(not_under [P, ..]), read from the walk's ancestor chain (chain.last(), no climb); five parent-only gate fns moved onto rows, each pinned. The review found a fragment could splice an empty payer under [] past the macro; the row body now requires a named kind.
#1416 fix(find): render nested matches in linear time, fix(find): print nested matches whole to 64 levels bca find rendered each match with a Node::parent climb (98% of 397 ms on 4,000 nested braces) and printed each nested match's text at every level (16 MB for 8 KB). The first commit made the render one linear pass; it also elided every nested match, which changed ordinary output (Some(parse(s)) → Some(…)). The second prints whole spans through 64 levels of single-row nesting and elides past that: byte-identical to before per file on serde, pdf.js and DeepSpeech (deepest same-row nesting 42), 751 KB at depth 4,000, ×2 per doubling. Two scaling probes, depth and width.
— fix(perturb): read cargo failures from each target's list #1831: doctest names with spaces; names read from cargo's failures: list (the progress line's - should panic suffix matches no expect); a test's captured section is bounded whole, so a doctest's own compile error is not a build error and a printed header or ---- line cannot hide or invent one (the old pattern was quadratic).
— feat(perturb): add a unittest runner "runner": "unittest" for the Python gates under utils/. The runner never reads unittest's printed report — three text parsers each opened a new case, the last certifying a passing test as the one that failed — and instead runs -m perturb_unittest_recorder, unittest's own main recording each outcome by TestCase.id() after the run returns. Refuses fail-fast in any spelling, -E/-I/-X pycache_prefix, a red preflight, a stopped or signalled run, a partial record and a non-unittest exit status; isolates bytecode per run (#1562). Checked on Python 3.10–3.14.
— fix(deny): ban h2 below 0.4.16, which --workspace makes a live guard deny.toml said no ban on h2 <0.4.16 could fire because krates filters the crate; the diagnosis was wrong — CI rooted the graph at the root package, which does not depend on actix. With #1823's --workspace the ban fires on the pre-fix lockfile (confirmed by two reviewers on 0.19.4 and 0.20.2) and passes today; lockfile_tests.rs and lessons_learned.md corrected.
— docs: fixes from the batch's prose and performance reviews benchmarking.md's probe table and readings, AGENTS.md's utils/ inventory, mutation_testing.md's gate count, nodes.md, grammar-dispatch.md §4.
— fix(security): bump actix-http and actix-web past four RUSTSEC advisories RUSTSEC-2026-0446/0447/0448/0455 were red under cargo-deny check advisories on main and here alike (actix-http 3.19.0, actix-web 4.18.1). cargo update moves them to 3.20.3 and 4.18.2, with brotli and brotli-decompressor in step and base64 leaving the lockfile; all eight manifests now pass all four deny checks.

Decisions from the handoff

  • bca find elision: option (c), a 64-level limit, over keep / revert / flag / cap. The time cost was the connector climb, fixed independently; bca dump prints far more on the same input, so unconditional elision bought bounded output at the price of ordinary output. Recorded on perf(find): bca find is quadratic in nesting depth when matches nest #1416.
  • Commit subjects: left. No 50-character rule exists in the repository's conventions and 187 of the last 300 subjects on main exceed it; the previous batch fast-forwarded.
  • Scratch perturbation drivers: the originals were lost with their host. The one reusable capability, a unittest sweep, is the runner above; the manifest generators were anchored to lines that no longer exist.
  • The h2 note was initially declined as "stale, not wrong"; the deny review and an astra second opinion reversed that with a positive control on the pre-fix lockfile.

Validation (tip f6e0ccf3)

  • make pre-commit: BCA_GATE: pass.
  • make check-test-lang-gates-compare COMPARE_REF=origin/main: no test lost a build.
  • make self-scan-baseline-fresh: 0 added / 0 removed / 0 worsened / 0 improved.
  • make bench-scaling: 119/119 within bound (find/tcl-nested-braces 1.01, 1.80 with the limit removed; find/tcl-wide-braces-past-the-limit 1.01, 1.81 under a sibling-rescan mutant; loc/c-nested-conditional-docs 0.92, 1.95 with the memo bypassed).
  • make chain-audit and make role-coverage passed on the first session's tip; the second session changed no walk bookkeeping.
  • Each rebased commit passes its own tests. No integration snapshot moved; the output submodule gitlink is unchanged.
  • perturb-test.py (58 tests) passes on Python 3.10, 3.11, 3.12, 3.13 and 3.14.

Known gaps

Fixes #1823
Fixes #1786
Fixes #1809
Fixes #1795
Fixes #1794
Fixes #1416
Fixes #1831

The comment on rust_attribute_run_verdict's reach said rustc accepts
an item-nesting attribute `value` "only for a proc macro to consume".
rustc 1.99.1 also compiles one on an item a false `cfg` strips, since
the literal check (Reference `attributes.meta.literal-expr`) never
runs there, and rejects one on a derive helper, which stays on its
item. Name both routes, cite the rule, and record that neither occurs
in this repository or the serde corpus, which is why the gap stays
documented rather than closed.

Reworded within the same 15 lines: checker.rs sits at its baselined
loc.sloc.

Fixes #1786
Both cargo-deny jobs ran from the repository root and so read only the
root Cargo.lock. The seven [workspace].exclude crates (enums, fuzz and
the five tree-sitter-* grammars) each resolve a graph of their own, and
only Scorecard read those, on main, after merge: RUSTSEC-2026-0374 sat
in enums/Cargo.lock that way until #1822.

utils/check-deny-manifests.sh runs cargo-deny once per tracked
Cargo.lock against the root deny.toml, with --locked, and fails when
the tracked count is not eight, so a ninth excluded crate cannot enter
unaudited. The ci.yml deny job and deny-advisories.yml both call it,
installing cargo-deny 0.20.2 (what cargo-deny-action v2.1.1 shipped)
through the SHA-pinned taiki-e/install-action, which checks the
tarball's sha256. 0.20 moved --config to the top level and rejects
`check --config`, so the script refuses an older cargo-deny.

Running all four checks over the new graphs found three failures,
each fixed at its narrowest point:
- enums was unlicensed: its manifest now states the repository's
  MPL-2.0. licenses.private.ignore would also have stopped checking
  the licence of big-code-analysis-py, which ships to PyPI.
- fuzz's libfuzzer-sys carries LLVM's NCSA: a crate-scoped exception.
- fuzz's version-less path dependency read as a wildcard:
  allow-wildcard-paths, which exempts only publish = false crates.

utils/check-deny-manifests-test.py, wired into make pre-commit, make
ci, pre-commit and the lint job, drives the script against a stubbed
cargo-deny in a scratch repository and against the live tree.

Fixes #1823
allow-wildcard-paths exempts path or git dependencies of a private
crate, and path or git dev-dependencies of any crate, per the
cargo-deny 0.20 book; the comment named path dependencies only. Note
that a git source still has to pass the [sources] gate.

Refs #1823
NArgs' extrema fold every space's own count on each channel, the
file unit and containers included, while its averages divide by the
functions and closures nom counts. A lambda that opens no space adds
its parameters to the enclosing function's own closure_args (one
extrema member) yet is one closure of the divisor, so
closure_args_average can fall below closure_args_min; and file-level
function_args_min is always 0.

Document both in the Stats type docs, a new NArgs subsection in the
book (#nargs-aggregates), the cyclomatic aggregate-population
passage, and the Python Dependencies paragraph. The definition stays
as it is; changing it moves integration snapshots.

The loc sibling is #1827.

Fixes #1809
`preproc_conditional` compared five `kind()` strings, and
`conditional_declares` asked it up to three times of each
non-conditional child: in the push filter, in the expansion and
inside `doxygen_entry`.

Each C-family dialect now has `is_preproc_conditional_kind` beside
its table: the `DocTarget` row's conditional owners as a kind test,
which `doc_target::lists_kind` cannot give, as the row also lists the
entries. `DoxygenRow::conditional_kind` binds it per dialect, and
`preproc_conditional`, `doxygen_container` and
`doxygen_binds_forward` take the dialect. The two kind lists sit
beside the two conditional fragments rather than being shared through
a callback the `role_tables.py` fragment reader cannot follow, so the
role-table gates read the rows exactly as before; a per-dialect test
holds each list to the old conditional names over every runtime id.

`conditional_declares` now classifies each child once, when its
conditional is read: a nested conditional is queued or answered from
the memo, any other child is asked the entry question there, and each
nested answer is folded into its parent's. A new test pins the fold on
shapes that tell it from an overwrite, which no existing test did.

Fixes #1795
Name Mozcpp among the grammars c_family_conditional_kinds! serves,
state the kind lists' reason from the row's side rather than the
consumer's call sites, and narrow the fold test's doc to the shape
that tells a fold from an overwrite.

Refs #1795
An owner whose membership is a test of its parent's kind spelled it
as a named gate fn, which the role reader could not see. Owners now
take the payer's parent test as an attribute, in both directions:
`under [K, ..]` and `not_under [K, ..]`. A list fills the owner's one
gate slot, so it is exclusive with gated_by, text_gated_by and
holds_payer. It is bracketed and non-empty, reads the walk's chain
(Ancestors::parent) and so sets CHAIN_GATED, and names kinds that are
tests, not claims: OWNERS and the three role baselines are unchanged.
The payer `under` clause now renders through the same @gate arm.

Four gate fns move onto their rows: Python's under_case_clause, the
TS family's under_enum_body (in the shared fragment and both
dialects' String rows), Groovy's not_in_an_import and Java's
not_a_class_literal. The other 11 pure parent gates (the ElseIf
emitters, Go, PHP) stay named fns, and the TS/TSX export/ambient
veto stays a Checker composition; the issue records why.

role_tables.py reads both lists, tokenising a bracketed list as one
attribute word, counts them in chain_gated, and parses owner and
payer lists with one function. A proof table in roles/mod.rs reaches
every terminal a list can reach, each list its row's only chain
reader; the doctests pin exclusivity and the empty list.

Zero drift, base 67d03ae1 against head: drift-oracle over the three
corpora, the control-flow fixtures and two probe roots for python,
javascript, typescript, tsx, groovy and java, 7,028 outputs in 14
views including verbatim, 0 differing.

Mutation coverage: cargo-mutants never visits a macro token tree, so
the three gates that were plain fns (python, groovy, java) are no
longer mutated; under_enum_body already sat inside a macro.
utils/perturb.py flipped and dropped each moved list over the ast
and root lib tests, and every case failed a named test:

- python: guard_owns_the_case_guard_and_not_a_comprehension_filter
  (both), and the three ABC case-guard tests on the flip;
- java: java_class_literal_bills_its_parts_1566 and
  java_declaration_keywords_are_operators_1552 (both);
- groovy: groovy_modifiers_are_operators_1565 (both);
- ts/tsx: doc_tests' rows_answer_the_table for each of the four
  owners, and the dloc binding test on the flip.

Each new macro arm, perturbed, fails the a_parent_list_gates_* test
for its projection (owns, the leaf, callables and opens_space); the
CHAIN_GATED arm and the reader's chain_gated term fail
python_reader_agrees_with_the_compiled_tables.

Fixes #1794
The macro's owner parent-list rejections were pinned only on the
Python reader's side, so a reordering of the @scan arms could accept
one with no Rust test failing. roles/parent_list_doctests.rs, a
cfg(doctest) module, now holds one compile_fail doctest per rejected
shape beside a control that compiles: a list after or before
gated_by, before text_gated_by, before or after holds_payer, two
lists on one owner, and an empty list. The two parent-list doctests
that sat on the macro move there, which keeps them out of
roles/mod.rs; the module declaration costs that file two code lines
(loc.ploc 954 -> 956, loc.sloc 2321 -> 2304, baseline refreshed).

The Python Guard row comment drops the consumers' reading, which
src/metrics/abc/python.rs and the row's excludes reason already
carry, and keeps the grammar fact.

Refs #1794
`bca find` rendered each match with its own `dump_node_with_color`
call at depth 1. Each call chose the match's connector by asking
`Node::parent`, which climbs from the root: O(depth) per match, 98%
of the 397 ms it took on 4 000 nested Tcl braces. Each single-row
match also printed its whole span, so a match nested k deep had its
bytes printed k times: 16 MB of output for an 8 KB file.

The CLI now renders a file's matches in one pass through the hidden
`dump_found_with_color`. A match is flush-left iff it is the tree
root, decided by node id, and a match nested in a single-row match
is printed as `…` in the outer line, its own text following on its
own line. Unnested matches print byte-identically to before, colour
included. Depth 4 000 now takes 5.8 ms against `count`'s 4.9 ms, and
prints 243 KB.

`Workload::Find` and the `find/tcl-nested-braces` probe, with its
`count` control, price the render on a 4 000 / 8 000 / 16 000 ladder.
Reinstating the climb fits 2.00 and the whole-span text 1.84, against
0.99 clean.

Fixes #1416
- role_table!: every owner gate slot goes to `@gate` whole, and an
  empty slot renders as `true`. That drops the seven parent-list
  terminal arms #1794 added beside their generic twins, and the six
  ungated clause forwarders left without callers.
- dump: `render_found` writes each line through `write_node_line`,
  which now takes the snippet as byte pieces and owns the single-row
  rule, so `write_node_snippet` folds away. `own_text`'s two loop
  exits are one filter.
- doxygen: `Visit` has named fields; `children_declare` calls
  `preproc_conditional`; the no-bytes paragraph moves onto
  `non_conditional_entry`, which makes the call, and the binding's
  assert names it.
- Baseline: `render_found`'s nexits entry retires; roles/mod.rs loc
  drops.

Refs #1794
Refs #1795
Refs #1416
Three #1416 tests passed with the renderer wrong, each shown by a
utils/perturb.py run over the root lib, the CLI lib and its
output/cli_ux/check/discovery targets, and the bench lib:

- found_render_matches_the_per_match_dump_when_no_match_nests claims
  colour identity with the pre-fix path, but its oracle is rebuilt on
  the writers render_found shares. Painting the snippet separator cyan,
  or writing the elided `…` without its colour switch, failed nothing
  anywhere. found_render_colours_as_the_pre_fix_binary_did now holds
  the escapes to bytes captured from a pre-#1416 `bca find --color
  always` (0215026), plus the documented colour of `…`.
- found_render_decides_utf8_on_the_printed_pieces only placed the
  non-UTF-8 piece first, so deciding the trailing space on the first
  piece alone passed. A line whose last piece is non-UTF-8 catches it.
- found_render_prints_each_byte_of_one_row_once summed own_text's
  piece lengths and never rendered, so a render printing every whole
  span passed it. It now reads the rendered lines and compares the
  printed bytes, as a multiset, with the source.

Refs #1416
Three perturbations of check-deny-manifests.sh and its workflows passed
the self-test:

- `-lt` -> `-ne` in the minor comparison refuses every 0.x above 0.20,
  CI's next pin, but every test ran 0.20.2 (the floor's own minor) or
  1.0.0. A 0.21.0 stub now has to be accepted.
- Deleting the unreadable-version refusal lets `[ x -eq 0 ]` error
  inside the `if`, which bash reads as false, so the gate ran an
  unknown cargo-deny. No test gave it an unreadable version.
- Commenting out either workflow's `run:` step still passed, because
  the wiring test was a substring match on the YAML. It now matches a
  step's `run:` line.

Each case was run with the scratch driver before and after the fix: all
three were uncaught before and are caught after. The other 22 cases
(count, pathspec, --config order and path, --locked, failure
collection, usage, pin drift) were caught before as well.

Refs #1823
`role_table!`'s parent-list gate documents that a node with no parent
is under nothing, so `under` rejects it and `not_under` admits it. No
test asked a list with no parent: flipping `is_some_and` to
`is_none_or` in the `@gate under` arm (which `not_under` negates)
failed none of the 6,946 tests of the ast, root, cli, web and bench
crates (`utils/perturb.py`, `--lib --tests --no-fail-fast`), because
every owner of the `dsl_parent_gates` fixture has a parent.

`a_parent_list_reads_a_parentless_node_as_under_nothing` asks the
fixture's `under` and `not_under` owners under an empty known chain,
the walk's record of the root, and counts the nodes it asked.

Refs #1794
cargo-deny (#1823): read the root graph with --workspace (without it
155 of 374 crates went unread), refuse a lower major version as well
as a lower minor, and list tracked lockfiles with --deduplicate.
check-excluded-manifests.py now fails an excluded crate that tracks
no Cargo.lock, the direction the count cannot see. The self-test
drops every inherited GIT_* variable, which under a hook pointed its
scratch git calls at the real repository's index, and pins each
workflow's exact check set. The pre-commit hook matches any
Cargo.lock, and AGENTS.md names both counts a ninth lockfile raises.

role_table! (#1794): a payer's parent list names at least one kind,
pinned by a compile_fail doctest, and the token-form @clause shims
are gone. Java's directive `static` reads not_under
[ImportDeclaration, RequiresModifier], as Groovy's does, in place of
the not_in_a_directive gate fn.

Doxygen (#1795): each path to the DocTarget row tests for a
conditional on its own; the docs said either guard covered both.
doxygen_entry_never_reenters_the_conditional_walk adds a nest that
declares nothing, the only shape on which children_declare asking
the row first shows (4,095 reads against 12). The C-family
is_preproc_conditional_kind is pub(crate) and named in the roles
module's consumer conventions.

find (#1416): an I/O-error sweep over the renderer. The book's find
output section, STABILITY.md on the hidden find renderers, and the
mutation-testing note on parent lists are corrected.

Refs #1823 #1794 #1795 #1416
Fixed: the find renderer's linear time (#1416) and the deny jobs over
all eight lockfiles (#1823), with the #1815 entry corrected to match.
Changed: find's elided nested text and its hidden re-exports (#1416),
owner parent lists (#1794) and the NArgs aggregate exception (#1809).
Performance: Doxygen conditionals by kind id (#1795).

Refs #1416 #1794 #1795 #1809 #1823
#1416's renderer elided every match nested in a single-row match, so
ordinary output changed: `Some(parse(s))` printed `Some(…)`, a method
chain lost its receiver, and `-t all` printed a declaration as
`… ……`, while the time cost it was fixing was the parent climb.

A match now prints its whole span up to 64 levels of single-row
matches nested in one another (`FULL_LEVELS`), and elides past that.
The level counts single-row matches only — `prints_snippet` decides
both whether a line ends with its text and which matches count, so
the two cannot drift — read from the same stack pass as next_outside
(`nesting`, folding the two walks the first cut had into one), so the
render stays linear and climbs to no parent. Output on the serde,
pdf.js and DeepSpeech corpora is byte-identical to main per file
under `-t all` and `-t call_expression`; the deepest same-row
nesting there is 42. 4,000 nested braces print 751 KB, and twice the
depth prints twice the output.

Probes: find/tcl-nested-braces fits 1.01, and 1.80 with the limit at
usize::MAX. A new width probe, find/tcl-wide-braces-past-the-limit
(4,000–16,000 sibling words inside 66 braces, so the level eliding
them is past the limit), prices the step from one elided match to the
next through next_outside: re-walking the siblings for each fits 1.81
against 1.01 while the depth probe, a chain with one match per level,
stays at 1.02 under that mutant.

The book, the CHANGELOG's Fixed and Changed entries, the renderer's
rustdoc and dispatch_find's comment describe the 64-level rule; `…`
is not escaped, which the docs say.

Refs #1416
A doctest's name holds spaces (`src/lib.rs - one (line 7)`), and the
failure patterns took the name as `\S+`, so every red `--doc` run
parsed no failure and read as HARNESS-ERROR against its exit status.

Failures are now read from each target's `failures:` list, the names
`cargo test -- --list` and `--exact` use: the progress line adds
` - should panic` / ` - compile fail`, which no `expect` spells, and
`-q` / `--format terse` print no progress lines at all. A test's
captured section is bounded by whole `---- name stdout ----` headers
on one line and by cargo's list up to its `test result:`, so a
doctest's own compile error inside its section is a failing test, not
a build that never reached the tests; a header pattern free to cross
lines was quadratic (8 000 `---- ` lines took 4.7 s), joined a stray
line to a later header and hid a real `error[` between them, and
ended a section at a printed `---- ` line. A printed `test x ...
FAILED` line no longer replaces the failure list. A test that prints
a whole target report, list and `test result:` both, is cargo's shape
exactly, and the docstring says no line parser can tell the two apart.

The fixture is real `cargo test` output: a crate with one passing,
one panicking, one uncompilable and one wrongly-compiling doctest, and
a unit target with a `#[should_panic]` test and a test printing
cargo-shaped lines. A perturbation sweep against that crate reports
`caught`.

Fixes #1831
perturb.py drove `cargo test` only, so the Python gates under utils/
had no sweep driver with its safety rules. A manifest may now name
`"runner": "unittest"` with its argv under `"command"`; a `"cargo"`
manifest means what it always did. Runners are a dataclass carrying
their argv check, refusal text, preflight and `run`, so sweep() names
none of them.

The runner never reads unittest's printed report. A test can print
anything — a ruled `FAIL:` header, a whole nested unittest report, a
line shaped like a progress verdict — to either stream, `-b` copies
it into the report, and no reading of the text can tell that from
unittest's own: three attempts at a text parser each opened a new
case, the last one certifying a passing test as the one that failed.
Instead it runs `-m perturb_unittest_recorder` in place of
`-m unittest`: the same unittest.main, with its own argument parsing,
output and exit status, whose result class records each outcome by
TestCase.id() — failures and errors with subtests under their test,
unexpected successes, loader failures, class and module fixture
failures — and writes the record as JSON after run() returns, so an
exception escaping a test (a KeyboardInterrupt) leaves no record.
Each run's record lives in its own temporary directory.

classify_unittest reads that record and refuses, as HARNESS-ERROR: no
record; one that is not JSON or not the recorder's shape (a run killed
mid-write, a module shadowing the recorder); a loader failure; a run
that was stopped early (`-c` and SIGINT, `result.stop()`) or killed by
a signal, whose failures are a partial set; 0 tests run; and an exit
status other than unittest's own 1-with-a-failure / 0-without, which
an atexit hook or thread calling os._exit leaves. An unexpected
success counts as a failure, since unittest exits 1 on one.

The argv is parsed as unittest parses it, mirroring unittest/main.py's
main and discovery parsers: fail-fast in any spelling (`-f`, `-vf`,
`--failfast`, the abbreviation `--fail`) is refused, since it hides
every guard after the first failure; so are `-E`, `-I` and
`-X pycache_prefix`, each of which undoes the isolation below. Before
3.12 argparse exits on an unrecognized argument even with
exit_on_error=False, which is a refusal, not a SystemExit. The suite
is run once unperturbed and a red one refused.

Each run gets an empty PYTHONPYCACHEPREFIX with writes off, so a
`.pyc` left by a same-length mutant cannot be loaded for the next one
(#1562): `-B` alone still loads a `.pyc` whose recorded size and
mtime match. Every run recompiles what it imports, the interpreter's
own start-up included — ~0.13 s against 0.05 s warm, the price of the
guarantee. Colour is off (3.14 colours its report under FORCE_COLOR);
the record's dedup is a set, where a list scan was quadratic past
~10 000 failures.

Self-tests run real `python -m unittest` subprocesses on a scratch
repository: the named test caught; a subtest failure under its test;
skips and expected failures not counted; several unexpected
successes; a failing test printing a header that names a passing
test, under -b, -v and neither; a 2 000-prefix progress-shaped stderr
line; a failing test followed by a KeyboardInterrupt, by SIGINT under
-c, and by a tearDownClass that exits 7, with a test after each never
run; a dying run after a recorded catch; a stale `.pyc` seeded with
the committed source's stamp; a sweep without -B over two same-length
mutants in one second; colour on a 3.14 interpreter when one is on
PATH; argv refusals through sweep(); a corrupt or odd-shaped record.
setUp clears the variables the runner sets, which an outer sweep of
this file would otherwise hand every inner sweep. Each guard was
swept with the unittest runner over this file; the one mutant that
stops the record being written perturbs the sweep's own recorder too,
so it was checked from a git archive copy. perturb-test.py passes on
Python 3.10 through 3.14; the validator agrees with each
interpreter's own unittest parsers on 20 argvs (`--durations`, a 3.12
option, is the one 3.10/3.11 then refuse at the preflight).
testing.md points Python sweeps at the runner; the pre-commit hook
triggers on the recorder.
deny.toml said no `deny` entry for h2 <0.4.16 (RUSTSEC-2026-0258)
could work because cargo-deny's graph builder filters the crate out
before any check runs; lockfile_tests.rs and lessons_learned.md said
the same. The observation was right and the diagnosis wrong: CI ran
cargo-deny from the root with no --workspace, and the root manifest is
also the big-code-analysis package, which does not depend on actix, so
the web crate's closure was never visited and `filtered h2 0.3.27`
meant unreachable from the roots, not invisible to cargo-deny. #1823's
script passes --workspace, and on the pre-fix lockfile (3df3b2c^) the
same ban then fires: `error[banned]: crate 'h2 = 0.3.27'`, on 0.19.4
and 0.20.2 alike; without --workspace it stays silent. On today's
lockfile the entry passes, and on a graph with no h2 at all
(tree-sitter-ccomment) it adds no warning. Confirmed independently by
two reviewers against both cargo-deny versions.

The ban is added as a second guard beside the lockfile test, which
holds whatever roots a future invocation selects, and the three texts
say what the filter line means.

The script fetches the advisory database once per lockfile, ~0.4 s
each. --offline on the later runs was measured at 0.1 s each and
rejected: it also stops the crate-index fetch, and on a cold cache a
later manifest's crate the earlier runs did not pull fails
resolution. The script's comment records the measurement.
The #1809 docs say closure_args_average can fall below
closure_args_min, on the book's pick fixture, and nothing held them.
A test asserts min 4, max 4, sum 4 and average 1.0 there, so the
three docs are known to need an edit the day the definition changes.
The #1809 CHANGELOG entry goes, being docs-only; the #1416 entry
names pdf.js as the corpus with the deepest nesting.
The #1794 review of the role-table parent lists:

- A row's own `pays [K under []]` was refused at the entry scan, but
  a `..fragment!()` splices straight into the row body, whose payer
  pattern took the list as `*`: `EQEQ under [],` from a fragment
  compiled and rendered a payer that never pays, the shape the new
  doctest says is rejected. The body now takes `+` as the scan does;
  the fragment form fails with `no rules expected ']'` and a named
  list still compiles. No production fragment spelled it.
- Java's Modifier row comment carried the Halstead consumer's reading
  of directive words, which macro-comments.md puts at the consumer;
  it now states the grammar fact and points at the consumer's test.
- grammar-dispatch.md §4 says a parent-only gate is a row list, not a
  fn, and why the ElseIf family keeps its emitters.
- Objective-C's conditional list is 19 where the other three dialects
  have 20: its grammar mints one preproc_ifdef alias fewer and one
  more each of preproc_else and preproc_elif, so the count is the
  grammar's, not a slip; the per-dialect oracle holds each list to
  its enum, and the list's doc now says so.
benchmarking.md gains the width probe added in 82c7d33f and the 1.80
and 1.81 readings; loc/c-nested-conditional-docs' rationale records
that bypassing the memo fits 1.95 against 0.92, as testing.md asks of
a probe; AGENTS.md's utils inventory names the unittest recorder;
mutation_testing.md says why it lists four moved gates where the
CHANGELOG counts five; nodes.md describes the position pairs and the
trailing space and names pdf.js; a pronoun slip in
grammar-dispatch.md.
@codecov

codecov Bot commented Nov 7, 2026 •

Copy link
Copy Markdown

Codecov Report

❌ Patch coverage is 99.86772% with 1 line in your changes missing coverage. Please review.
✅ Project coverage is 98.40%. Comparing base (590a645) to head (f6e0ccf).
⚠️ Report is 25 commits behind head on main.

Files with missing lines Patch % Lines
big-code-analysis-cli/src/dispatch.rs 80.00% 0 Missing and 1 partial ⚠️
Additional details and impacted files

Impacted file tree graph

@@            Coverage Diff             @@
##             main    #1835      +/-   ##
==========================================
+ Coverage   98.39%   98.40%   +0.01%     
==========================================
  Files         396      396              
  Lines      120193   120845     +652     
  Branches   119758   120410     +652     
==========================================
+ Hits       118258   118914     +656     
+ Misses       1222     1217       -5     
- Partials      713      714       +1     
Flag Coverage Δ
python 100.00% <ø> (ø)
rust 98.39% <99.86%> (+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.rs 96.79% <ø> (ø)
...de-analysis-ast/src/checker/doxygen_doc_binding.rs 100.00% <100.00%> (ø)
...-code-analysis-ast/src/lang_helpers/doc_comment.rs 99.24% <100.00%> (ø)
big-code-analysis-ast/src/lang_helpers/doxygen.rs 99.74% <100.00%> (+0.36%) ⬆️
big-code-analysis-ast/src/roles/c_family.rs 100.00% <100.00%> (ø)
...g-code-analysis-ast/src/roles/doc_tests/doxygen.rs 98.20% <100.00%> (+0.08%) ⬆️
big-code-analysis-ast/src/roles/groovy.rs 100.00% <ø> (ø)
big-code-analysis-ast/src/roles/java.rs 100.00% <ø> (ø)
big-code-analysis-ast/src/roles/js_family.rs 99.48% <ø> (-0.02%) ⬇️
big-code-analysis-ast/src/roles/mod.rs 97.43% <100.00%> (+0.62%) ⬆️
... and 5 more
🚀 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.

…ries

cargo-deny check advisories was red on main and on this branch alike:
RUSTSEC-2026-0446, -0448 and -0455 against actix-http 3.19.0 (request
smuggling through malformed chunked trailers; unbounded decompression
exhausting memory and CPU; large-window Brotli bodies bypassing the
decompression limits) and RUSTSEC-2026-0447 against actix-web 4.18.1
(compressed request bodies exhausting memory before extractor limits
apply). `cargo update -p actix-http -p actix-web` moves them to 3.20.3
and 4.18.2; brotli 9.0.0 → 9.1.1 and brotli-decompressor 6.0.1 → 6.3.0
move with them and base64 0.22.1 leaves the lockfile. No other
package version or checksum changes.

utils/check-deny-manifests.sh advisories bans licenses sources, with
cargo-deny 0.20.2: all eight manifests ok. The web crate's 184 tests
and its lockfile test pass; check-excluded-manifests is OK.
@dekobon
dekobon merged commit f6e0ccf into main Nov 7, 2026
59 checks passed
@dekobon
dekobon deleted the fix/batch-2026-11-05 branch November 7, 2026 02:34

This branch was previously deployed

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