Repository navigation
fix: batch 2026-11-05 (6 issues + the find elision limit and a unittest sweep runner) - #1835
Merged
Merged
Conversation
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 Report❌ Patch coverage is
Additional details and impacted files@@ 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
Flags with carried forward coverage won't be shown. Click here to find out more.
🚀 New features to boost your workflow:
|
…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.
This branch was previously deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
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 thedenyjob red onmain.Commits
fix(ci): audit all eight lockfiles with cargo-deny+ 2utils/check-deny-manifests.shruns cargo-deny--locked --workspaceonce per trackedCargo.lock(root plus the seven[workspace].excludecrates), called by thedenyjob inci.ymland bydeny-advisories.yml; a 0.20 version floor;check-excluded-manifests.pyfails an excluded crate with no tracked lockfile.docs(ast): bound the attribute-value reach gapchecker.rs, verified against rustc 1.99.0.docs(nargs): name the average-below-min exception+ 1,test(nargs)closure_args_averagecan fall belowclosure_args_min(extrema fold every space, averages divide bynom's count); documented onStats, in the book and the Python page, and now pinned by a test on the book'spickfixture. The definition is unchanged; #1827 tracksloc.perf(ast): read Doxygen conditionals by kind id+ 1is_preproc_conditional_kindby id, each child classified once. A constant-factor win (6–17% CPU on conditional-heavy files); output byte-identical tomainon 1,319 DeepSpeech C-family files.refactor(roles): add owner under / not_under lists+ 2,fix(roles)role_table!owner may carryK(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 payerunder []past the macro; the row body now requires a named kind.fix(find): render nested matches in linear time,fix(find): print nested matches whole to 64 levelsbca findrendered each match with aNode::parentclimb (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 listfailures:list (the progress line's- should panicsuffix matches noexpect); 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 underutils/. 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 ownmainrecording each outcome byTestCase.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 guarddeny.tomlsaid no ban onh2 <0.4.16could 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--workspacethe ban fires on the pre-fix lockfile (confirmed by two reviewers on 0.19.4 and 0.20.2) and passes today;lockfile_tests.rsandlessons_learned.mdcorrected.docs: fixes from the batch's prose and performance reviewsutils/inventory, mutation_testing.md's gate count, nodes.md, grammar-dispatch.md §4.fix(security): bump actix-http and actix-web past four RUSTSEC advisoriescargo-deny check advisoriesonmainand here alike (actix-http 3.19.0,actix-web 4.18.1).cargo updatemoves 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 findelision: option (c), a 64-level limit, over keep / revert / flag / cap. The time cost was the connector climb, fixed independently;bca dumpprints 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.mainexceed it; the previous batch fast-forwarded.h2note 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-braces1.01, 1.80 with the limit removed;find/tcl-wide-braces-past-the-limit1.01, 1.81 under a sibling-rescan mutant;loc/c-nested-conditional-docs0.92, 1.95 with the memo bypassed).make chain-auditandmake role-coveragepassed on the first session's tip; the second session changed no walk bookkeeping.perturb-test.py(58 tests) passes on Python 3.10, 3.11, 3.12, 3.13 and 3.14.Known gaps
os.environ; a subject-root module namedperturb_unittest_recorder; a custom suite that returns without running its tests; an abnormal shutdown that happens to exit 1.Fixes #1823
Fixes #1786
Fixes #1809
Fixes #1795
Fixes #1794
Fixes #1416
Fixes #1831