Repository navigation
Three trees T6x-a: the statement stack on handles, cut after its probe - #344
Conversation
…over two runs What the statement stack on handles (three trees, T6x-a) lacks in the interface, found by its probe conversion. Before: a statement in flight could be read for its kind, its value and its location, not for its id, so a stack that owns handles turned each statement into a row and back to key its empty-block table or to give the top-level rows their ids. `norm::simplify_if_head` was called by the lowering directly, over an implementation of `norm::IfLists` by the statement stack that hands out rows. After: - `JsStmt::stmt_id(&self, a, &S) -> u32`: the id of the statement, read in place. O(1); on rows the row. - `JsStmt::if_head(a, runs, &mut test, &mut yes, &mut no)` with the trait `Runs<B>` (`trim`, `empty`, `last`, `only`, `release`, `take`) and the result `IfHead<S, Run>`: rules 0 to 6 of J-S3 over two runs the caller holds. On rows it is `norm::simplify_if_head`, the head `js3_simplify_if` runs over pool lists, reached through an adapter that gives the rule each function of `Runs`: the rules exist once. One step a call; the runs count what they release and take; a kept run is not scanned. Nothing in the lowering calls either yet: the build slices of T6x-a do. Tests (`--lib bir::lower::js_stmt`, 25 passed): - the id is what `owner`, `kind_of` and `block_ids` know the statement by, and reading it counts no step; - `if_head` and what follows it give the tree `js3_simplify_if` builds, for 11 tests and every pair of 10 branch shapes, empty blocks among them; - the steps of `if_head` at 1,000, 2,000 and 10,000 statements follow the run it consumes and are the same whatever the length of the run it keeps, which stays whole. Co-authored-by: Jaap Frolich <jfrolich@gmail.com> Session: https://os.submodule.nl/session/bks-f1c2bf71-2bd2-7807-9319-0fbabb12f9b7 Signed-off-by: open-session-submodule[bot] <341020755+open-session-submodule[bot]@users.noreply.github.com>
…loop function over a list Three additions under test modules; no production line of the lowering changes. - `rows_stmt::S::row` (`#[cfg(test)]`): the row of a statement on rows, for a test that reads the arena beside the handle. The statement stack's test-only reader of a run's rows is built on it when the stack holds handles, so the 23 tests that release a run row by row keep their text. - `out.rs`, `the_actions_of_ten_thousand_switches_leave_only_the_slots_of_their_runs`: the slot protocol the probe gave `untagged.rs` (the actions reserved above the clause runs, filled as each run is taken, taken as one list), run on today's stack. A switch leaves its statement and the slots its runs had, at 1,000 and at 10,000 switches; a read from the end of the run crosses the dead ranges of the last switch only. - `js_stmt_tests.rs`, `a_loop_function_over_a_list_is_the_one_over_a_block_in_fewer_steps`: the body of a tail-loop function kept as a list gives the same function as today's block, in `statements + 3` fewer steps (at 1,000 and 10,000). Co-authored-by: Jaap Frolich <jfrolich@gmail.com> Session: https://os.submodule.nl/session/bks-f1c2bf71-2bd2-7807-9319-0fbabb12f9b7 Signed-off-by: open-session-submodule[bot] <341020755+open-session-submodule[bot]@users.noreply.github.com>
…ur slices The probe of row T6x-a (the statement stack on handles) came to 1,093 changed lines against 500 estimated and left four questions open. This writes the answers into 11.4 and cuts the row. New subsection "T6x-a: the statement stack, after the probe": - what was added to the interface, with the probe site that calls each function, and how it was checked (the probe's code on this interface: 565 and 58 passed, clippy clean); - (a) the stack's reads return references, `take(slot)` for the seven sites that consumed a statement the stack still held, the list of the stack's functions with their costs, and `held` as a vector of options; - (b) six signatures change in T6x-a with all their callers, and the rule of the cut is rewritten for it; - (c) a switch's actions are staged on the stack and taken with `take_actions` (no close); `untagged.rs` reserves holes, and what the dead range costs; the alternative that was tried and fails five allocation tests; - (d) `loop_function_body` on lists saves n + 3 steps a function, and which slice deletes each function that loses its last caller; - (e) the changes to earlier sections; - the cut, measured on the probe's commits: a1 511, a2 154, a3 about 475, a4 about 210 changed lines, one after the other; - the counts of `scripts/count_lowering_ids.py` on trunk and after. "T6x: the cut": the row of T6x-a becomes four rows; T6x-d loses five rows of its table; T6x-f no longer deletes `function_of_block`; the figures of b, c3, c4, d and f are marked as estimates. "T6: the interface" (a): the read-back table names `kind_at`, which is what the trait has. Co-authored-by: Jaap Frolich <jfrolich@gmail.com> Session: https://os.submodule.nl/session/bks-f1c2bf71-2bd2-7807-9319-0fbabb12f9b7 Signed-off-by: open-session-submodule[bot] <341020755+open-session-submodule[bot]@users.noreply.github.com>
Section 11.9 gets a common block for the four slices of T6x-a and one verbatim prompt each. A prompt names the trunk it starts from, its first edit, its commits in order, the end state as searches, the tests it may touch only to compile, the cost-note check (the reason the probe's `script-tests` job is red), its gates, and how the probe's code may be read. Also from the probe of the next slice: the read-back table says that a read by reference of a list's statement is open for the design turn of T6x-b, and the row of T6x-b is marked to be re-cut by that turn (838 changed lines measured against about 450 estimated). Co-authored-by: Jaap Frolich <jfrolich@gmail.com> Session: https://os.submodule.nl/session/bks-f1c2bf71-2bd2-7807-9319-0fbabb12f9b7 Signed-off-by: open-session-submodule[bot] <341020755+open-session-submodule[bot]@users.noreply.github.com>
Owed by the review of the previous design turn: `block_ids` is a loop over the statements of a block and had no test at size. At 1,000 and at 10,000 statements it gives one id per statement, in order, and leaves `steps` where it was. Co-authored-by: Jaap Frolich <jfrolich@gmail.com> Session: https://os.submodule.nl/session/bks-f1c2bf71-2bd2-7807-9319-0fbabb12f9b7 Signed-off-by: open-session-submodule[bot] <341020755+open-session-submodule[bot]@users.noreply.github.com>
|
First-pass checklist review at 51066a4 (a checklist for the final reviewer, not an approval). Done on the host with git and gh only: 1. Scope
PASS 2. Default pathNot applicable: design pull request. No changed function runs in an ordinary build:
PASS 3. Engineering standardAll greps run over the added lines of pr.diff, from line 982 on (the code files).
4. Tests and oracles
PASS 5. New scripts and fixturesNot applicable: no script, fixture or workflow was added. PASS 6. PrivacyThe grep 7. Changelog
PASS 8. Numbers
UNCLEAR (a3, a4 and the alternative's failures cannot be checked) 9. Focused testsNot run (host review). CI 10. Where to look hardest
11. Files
Every file is under compiler-rust/src/bir, compiler-rust/docs or changes/.
PASS 12.
|
| IfLists | Runs |
|---|---|
| trim | runs.trim(rows, b, run) |
| empty | runs.empty() (the pools are ignored) |
| last | runs.last(run).map(|s| s.0) |
| only | runs.only(run).map(|s| s.0) |
| release | runs.release(rows, b, run) |
| take | runs.take(rows, b, run) |
simplify_if_head asks of the retained tail last, only and trim (norm.rs:722-723 trims both runs before the loop). The doc's "at most Runs::last and Runs::only are asked" of a kept run is therefore inexact. trim is bounded by the noted empty blocks, so this is not a scan, but it does release the tail's empty blocks.
(d) Steps are counted in two places: rows if_head adds 1, and the Runs implementation counts its release and take. The trait doc's "plus one per negation stripped" has no counter anywhere (section 10.2). FAIL (doc and code disagree)
(e) Per call nothing allocates a Vec, collects or clones. The rule's own b.lists.push(&[ret]) and b.lists.push(&[]) in rule 5 (norm.rs) are pool growth and existed before. No test measures allocations of if_head.
FAIL (on d), the rest PASS.
14. Tests of if_head
if_head_over_two_runs_is_rules_0_to_6_of_j_s3 runs 11 VALUES × 10 HEAD_SHAPES × 10 HEAD_SHAPES. Rules exercised:
| Rule | Exercised by |
|---|---|
| 0 (empty blocks) | the shapes containing St::Empty ([Empty], [Empty, Return], [Call, Empty], [Empty, Call, Empty, Break, Empty]) |
| 1 (boolean test) | True, False |
2 (!c, else not empty) |
NotX |
| 3 (then empty) | [] against [], with a pure test (X, Int) and an impure one (Call, CallThenCall, …); and [] against a non-empty else |
| 4 (two lone returns) | [Return], and [Empty, Return] after trim |
| 5 (lone return in else) | [Return] as else against [Call] and others |
| 6 (then ends in a jump) | then ending in Return, Break or Throw |
- Not exercised:
continuein rule 6, sinceSthas noContinuevariant. - What it is compared against:
shapeof the in-place result againstshapeofnorm::js3_simplify_ifon pool lists, built in the same arena. Both sides run the samesimplify_if_head, so this checks the adapter and the stack protocol, not the rules themselves. - It also asserts
heads > 600 && heads < 1210.
if_head_costs_what_it_consumes_and_does_not_read_the_tail uses the sizes [1_000, 2_000, 10_000] and asserts:
- Guard:
guard[2].0 - guard[0].0 == 9 * (guard[1].0 - guard[0].0)andguard[1].0 - guard[0].0 == 1_000. - Tail:
assert_eq!((cost.0, cost.1), (tail[0].0, tail[0].1))for every tail size,cost.2 == size, andtail[0].1 < 16. - The same constant-cost form for rule 5 (
lone) and forkept;droppedis linear.
"Tail unread" is shown by touched, the statements handed out, staying constant.
The test double can hide faults the real stack would show:
Slots::lastscans withiter().rev().find_mapand counts only 1 touch.onlyiterates withflatten.trimscans every noted empty block linearly, not with a binary search.
So a scanning last or only on the real stack would not be caught. The real stack's costs are only tested once a3 implements Runs. Also, steps here counts Rows' steps, which do not include the stack's scanned.
UNCLEAR (the oracle is the same rule code; rule 6 continue is not covered)
15. Decision tests
out.rs:668 asserts:
assert_eq!((thousand, ten_thousand), (1_000 * per_switch, 10_000 * per_switch));
assert_eq!(scanned, scanned_thousand);
assert_eq!(scanned, ((clauses + 1) * width) as usize);Inside the helper, per switch: assert_eq!(stack.mark().start, before + 1 + (clauses + 1) * width);. At the end: stack.mark() == Span::default().
How it compares with the probe (untagged.rs:900-990 on bir-lower-js-interface-2):
- The probe reserves
action_countholes above the clause runs (lines 932-936). - It fills clause
i(line 966), then the default (take_listofdefault.run, thenfill). - It takes
since(actions)and fills the switch atstart.start, a slot reserved before the runs.
The test models the same layout: head reserved, default run first, clause runs, holes, clauses filled first and the default last. It does not model has_default == false (the probe kills the default run instead), nor the single-case typeof path.
The bound is exact: 1 + (n+1)·w slots per switch (9 here), 90,000 at 10,000 switches, all popped by the enclosing take.
js_stmt_tests.rs:1068 asserts:
assert_eq!(loop_function(3, true).1, loop_function(3, false).1);
assert_eq!(ten_thousand - thousand, 9_000, ...);
assert_eq!(thousand, 1_000 + 3);The tree equality is checked at n = 3 only.
js_stmt_tests.rs:1197 asserts:
r.steps() == beforeafterblock_ids.- The ids are strictly increasing, and each has
kind_of == Kind::Exp. (given(1_000), given(10_000)) == (1_000, 10_000).
Existing tests: see section 4. Two gained an unreachable match arm, sizes gained one assertion, and no expected value changed.
PASS
16. The document
Each of the body's twelve decisions is in the subsection:
- The
stmt_idtable row. - The adapter paragraph after the table.
- Paragraph (a), first sentence.
- "Sizes", where
heldisVec<Option<B::S>>at 8 bytes, accepted. - Table (b).
single_assignment"(no caller reads the value)".- (c), with "Not chosen".
- "Gone: …
peek, which T6x-a1 adds and T6x-a3 deletes". - The deletion table.
- "a1 is accepted at about 550 lines".
- The test-only
statementsrow and the 23 tests. - (e), last bullet.
The rewritten rule (4445-4450):
a function that takes or returns a statement or a statement list changes its signature in the slice of T6x-a that changes what the stack gives or takes there, together with all its callers; a function of the callers' table that takes or returns an expression keeps its signature until T6x-d, and a c slice wraps at those calls.
The T6x table rows are in pr.diff lines 34-75:
- a1: 511 / about 550.
- a2: 154 / about 200.
- a3 names
place,if_statement,unnest,single_assignmentandassignment_statement, with all callers. - a4: about 210.
- b: "to be re-cut by its own design turn (probe: pull request 345)".
- d: goes from 36 rows to 31. It loses
place,unnest,single_assignment,loop_function_bodyandlocate_switch_run, and keepsif_statement,assignment_statementandmerge_assignmentsfor their expression.
So place, unnest and single_assignment left T6x-d. if_statement and assignment_statement stay in T6x-d for their expression argument, and are also named in the a3 row for their statement result. locate_switch_run leaves d for a reason unrelated to T6x-a: its signature names a source node only.
The read-back table (line 3197) now reads kind_at(a, l, i) and adds "(a read by reference of a list's statement is open: the design turn of T6x-b)". row_at is still named at THREE_TREES.md:2570-2571 (Builder::row_at in the T6 design table) and at 3600 (an older correction). These are not the read-back table.
PASS
17. The four build prompts
a1
- (a) Starts from trunk with this PR merged. The precondition greps for
stmt_id,if_headandrow, and requires 568/58. - (b) The first edit is
enum Slot<S>andStatementStack<B: JsStmt>in out.rs. - (c) End state:
struct StatementStack<B: JsStmt>: 1 line.B::stmt_node(/stmt_from_node(above tests: 3 matches, all insidepeek.B::list_id(: 1 match, intake_list.(push|fill)\(B::stmt_node\(: empty.bir\.(view|release)\(in out.rs: empty.- The totals line
| total | 15647 | 213 | 108 | 621 | … |. - 568/58.
- (d) Commit 1 is the stack with all callers (it cannot be split), commit 2 the changes file. Commit 1 compiles alone.
a2
- (a) Starts after a1; the precondition is the
StatementStack<B: JsStmt>grep. - (b) The first edit is the field types of args, loops, try_, rec and tail.
- (c) End state:
function_of_blockgrep empty; the totals line15661 | 209 | …; 566/58. - (d) Commits in order: fields, hold,
loop_function_body, deletion offunction_of_block, changes file. Each compiles alone: the deletion follows the removal of its only caller (trunk expr.rs:297), and commit 1 keeps the loops.rs wrap forif_statement.
a3
-
(a) Starts after a2; the precondition is
held_markpresent andfunction_of_blockabsent. -
(b) The first edit is the reads by reference in out.rs.
-
(c) End state:
fn (peek|clear|statements_rev|terminal|only_row|last_row): empty.IfLists|simplify_if_headoutside tests: 1 line, in close.rs.stmt_node/stmt_from_node: none in out.rs, 2 test helpers in cond.rs.- The five signatures.
- 566/58.
-
(d) Commit 1 cannot compile alone. It deletes
peekand makeslast/onlyreturn&B::S, while the a1IfListsadapter in cond.rs, which returnsOption<NodeId>throughlast_row/only_row, survives until commit 2. The fix is for commits 1 and 2 to be one commit, or for commit 1 to keep the adapter's two rows.The five signatures are in one commit together with their callers in exit, loops, switch, untagged and variant. That is coherent:
if_statement -> B::Scannot give a row oncepeekis gone.
a4
- (a) Starts after a3; the precondition is the
impl … Runs<B> for StatementStack<B>grep. - (b) The first edit is
switch_output_nodes: Vec<Option<B::S>>andActionState<S>. - (c) End state:
lists\.(set|truncate|push_iter)\(in the four files: empty.take_actions\(: the definition, the call intake_list, and 4 calls.stmt_node/stmt_from_nodeoutside tests: cond.rs 2, export.rs 5, mod.rs 4.- The totals line
15689 | 191 | …; 566/58.
- (d) Commit 1 converts the fields and turns actions back with
B::stmt_nodewhere they enter the reserved pool list (exit.rs:428-444, switch.rs:801/820, untagged's set). It needsPool::get_ref, which is not on trunk (git grep -n 'fn get_ref' origin/ocaml-to-rust-rewrite -- compiler-rust/src/biris empty; the probe adds it at untagged.rs:114), andcopy_dispatch_outputon&B::S. Nothing found here forces a break, but it was not built alone: UNCLEAR.
(e) Deletions. Each was checked with git grep -n '\bNAME\b' origin/ocaml-to-rust-rewrite -- compiler-rust/src.
| Deleted | Callers on trunk | Covered by the prompt? |
|---|---|---|
function_of_block |
expr.rs:297 (a2's file); test js_stmt_tests.rs:1003; this PR's loop_function |
yes: both tests are deleted in a2's commit 4 |
clear (the stack's) |
cond.rs:519, 532, 821 only (a3's file); no test | yes |
statements_rev |
cond.rs:866 only | yes |
terminal |
cond.rs:664 only; no test | yes |
peek |
not on trunk (a1 adds it) | yes |
lowering's impl IfLists |
cond.rs:67/479; norm_tests.rs:2084 reads only the text of norm.rs; oracle_tests.rs:1044 names simplify_if_head only in a test name and a comment |
yes |
production statements |
4 production callers (cond.rs:395, cond.rs:848, export.rs:350, mod.rs:772), all in a3's files; 23 test calls in 19 files (args, call ×2, exit, expr, external, import, jsx, konst ×2, label, loops, oracle_tests, prim ×2, prim_block, rec, record, switch, tail, untagged ×2, variant) | yes: they are kept by the #[cfg(test)] statements on StatementStack<Rows>; 23 and 19 match the doc |
No deletion leaves an uncovered caller.
- (f) Targets and counts. The targets are only the standing gates: Instruction count +0.02% and check mode +0.1% (reported, not steered). The count_lowering_ids lines are pasted and explained, not targets. The counts add up:
- 568 = 562 + 6 (this PR).
- 566 = 568 − 2 (a2 commit 4 deletes
a_function_over_a_block_is_the_function_over_its_listanda_loop_function_over_a_list_is_the_one_over_a_block_in_fewer_steps). - a3 and a4 delete no test: 566.
- The doc's "562 passed after each" (4326) is for the probe compositions, which do not have this PR's tests or the a2 deletion (the probe keeps
function_of_block).
- (g) The common block names
check_lowering_cost_docs.py, clippy-D warnings,cargo docwith-D warnings, Backend bridge coverage and the allocation counts 86/103/86/156. All four prompts include it ("with both common blocks"). - (h) The probe may be read with
git show origin/bir-lower-js-interface-2:…/FILE. "Merge nothing and cherry-pick nothing from that branch." - (i) a2 requires Backend bridge coverage at zero, read in CI before the PR is marked ready. a4 requires bridge coverage plus the JavaScript, standard-library and genType parity suites, read in CI before ready, and to stop on the first difference.
FAIL (a3 commit 1 does not compile as ordered; a4 commit 1 is unverified)
18. The cut's numbers
-
The document says only "each slice is the probe's commits of its files applied on the slice before, and for a3 and a4 the copy with the gaps closed". It names no commit SHAs and gives no shortstat command.
-
a1 and a2 reproduce from the probe's commits (section 8). a3 and a4 do not: the copy was never pushed.
-
The probe total, 1,093, checks.
-
Files per slice are as listed in the 11.4 table.
-
Functions edited by two slices:
- out.rs
take_list: a1 and a4. - out.rs
drop_empty_blocks,take_runand the reads (first,last,only): a1 and a3. - exit.rs
exit_dispatch: a3 (if_statement, trunk exit.rs:422) and a4 (the actions, 428-444). - untagged.rs
untagged_clause: a3 (thestatements.lastread at trunk untagged.rs:842) and a4 (the return type becomesB::S). - The cond.rs wraps of a1 are rewritten in a3; the document notes that 39 of 80 wraps cancel.
The slices are sequential, so there is no conflict, but the reviewer should expect rework of the same lines.
- out.rs
UNCLEAR
19. CI
gh pr checks 344 -R jfrolich/rescript-rust: 23 pass, 0 fail. These include script-tests, Backend bridge coverage, the parity suites, compiler-tests and the base/head/compare jobs.
The Instruction count run is 44173718910 at head 51066a4; its compare job is 134363517474:
| base | 4,135,388,542 | ... | 788 |
| head | 4,135,121,500 | ... | 788 |
| change | -267,042 (-0.006%) | | |
script-tests (job 134359518820) ran check_lowering_cost_docs.py --self-test and printed cost docs: production functions=536; changed/new=0; missing/generic=0; removed=0.
The earlier runs at dffe63e, 490075c and 152498d were cancelled when newer commits were pushed.
PASS
20. Privacy and hygiene
Same as sections 6 and 3h over the whole diff: no hits, no unsafe or allow(, and CHANGELOG.md is untouched. The PR body names "draft pull request 336" and "pull request 345" (repository-internal) and the attribution footer only. PASS
…he commit order of T6x-a3 The cost sentence of JsStmt::if_head named a step per negation stripped that nothing counts, and said a kept run is asked last and only alone, where the rule also drops the empty blocks the run noted. The prompt of T6x-a3 had the reads by reference and if_head as two commits: the first deletes what the adapter of the second's file reads, so they are one. The prompt of T6x-a4 says what to do if its first commit does not compile on its own. Co-authored-by: Jaap Frolich <jfrolich@gmail.com> Session: https://os.submodule.nl/session/os-01a1c9fa-0c5d-7912-a93b-3e7f38e53547 Signed-off-by: open-session-submodule[bot] <341020755+open-session-submodule[bot]@users.noreply.github.com>
|
Coordinator review, final, at c1b7779 (the author did not write this review). I read the first-pass checklist above whole, every changed line of Verdict: merge, with one reviewer commit (c1b7779) for the two findings below. What it adds. The two findings of the first pass, both upheld and corrected in c1b7779.
The twelve decisions.
On the tests of The cut. a1 511 and a2 154 reproduce from the probe's commits; a3 (about 475) and a4 (about 210) were measured on a copy that was not pushed and are estimates until their builders report. The slices are sequential, each from a trunk with the one before it merged. Not run by me: the tests (CI: 23 of 23 on the designer's head, and on this head; Privacy grep 0. |
Design turn 6 of slice T6 of the backend rewrite (
compiler-rust/docs/THREE_TREES.md, 11.4 and 11.9): the first slice of T6x, in which the statement stack of the lowering holds statement handles. It adds what the conversion lacks in the interface, writes the decisions into the document, and cuts the row into four build slices with their prompts. It converts nothing: no signature of the lowering changes here, and the default build runs none of this code.What it adds
JsStmt::stmt_id(&self, a, &S) -> u32, O(1)out.rsnote_empty_blockanddrop_empty_blocks;export.rs::build_rowsa_statement_in_hand_gives_the_id_its_readers_know_it_byJsStmt::if_headwith the traitRunsandIfHead: rules 0 to 6 of J-S3 over two runs of the caller's stack; one step, plus what the runs release and take; a kept run is not scannednorm::simplify_if_headthrough a 16-byte adapter; the rules exist oncecond.rs::if_in_placeif_head_over_two_runs_is_rules_0_to_6_of_j_s3,if_head_costs_what_it_consumes_and_does_not_read_the_tail(1,000, 2,000, 10,000)rows_stmt::S::row,#[cfg(test)], not in the traitstatements, called by 23 testsstmt_idtestTests for the decisions:
the_actions_of_ten_thousand_switches_leave_only_the_slots_of_their_runs(out.rs),a_loop_function_over_a_list_is_the_one_over_a_block_in_fewer_stepsandthe_ids_of_ten_thousand_statements_of_a_block_cost_no_step(js_stmt_tests.rs).The probe check
The probe's code (draft pull request 336) was put on this interface in a working copy that was not pushed, and its two gaps were closed with the functions above:
Each of the four slices was also composed from the probe's commits and run alone on the slice before it: 562 passed after a1, a2 and a3; a4 is the probe's head.
The probe's
script-testsjob is red because ofscripts/check_lowering_cost_docs.py(27 changed functions without a cost note, most of them the stack's, whoseimplheader changes). Every prompt names that script.The cut of T6x-a (measured on the probe's commits)
StatementStack<B>ownsB::S; every caller wraps at the call; the reads still give rowsloop_function_bodyon lists;function_of_blockdeletedtake(slot),Runsandif_head, the five signatures ofcond.rswith all callerstake_actions);switch_output_nodesandActionState::cachedon handlesOne after the other:
out.rsormod.rsis in every one.Decisions for the review to confirm
stmt_idas proposed by the probe; on the builder it is thenode_idof the owned node.if_headtakes the stack throughRuns, and its body on rows callsnorm::simplify_if_headthrough an adapter instead of moving the rules:js3_simplify_ifruns the same head, soIfListsandsimplify_if_headstay innorm.rsuntil T6s; T6x-a3 deletes the lowering's implementation ofIfLists.heldisVec<Option<B::S>>, 8 bytes an entry on rows: accepted. The size on the builder was not measured.loop_function_bodyin a2); the rule of the cut is rewritten and T6x-d loses five rows.single_assignmentreturns the slot only: no caller reads the value (checked on the copy).take_actions(no close: an action is a block).untagged.rsreserves holes, which leaves the last clause run as a dead range. Staging inswitch_output_nodeswas tried and fails five allocation tests.peek(three transition calls in the stack) and T6x-a3 deletes it.function_of_blockis deleted by T6x-a2, not T6x-f;clear,statements_revandterminalby T6x-a3;norm::jm14_push_effect_expressiongets#[cfg(test)]in T6x-f.statementsonStatementStack<Rows>.St::Emptywas added to a test helper enum; two existing tests gained a match arm, no expected value changed.Gates on this branch
size_of::<Rows>()stays 416; the allocation counts ofunit.rsare untouched (86, 103, 86, 156).Not run, not done
Backend bridge coverage,Instruction count, check mode on the application.--self-testforscripts/count_lowering_ids.py, and the count of merged guards in the guard-chain test oftail.rs.Started by Jaap Frolich in this Assistant session