v2 grammar: offer binary_expr before match/if/loop (revives #11911) + the tree-shape control it left open

[gunbai-bot]

XL-2, per quiet-seal-543's ruling A on class E: revives #11911 with the control it left open.

Provenance

#11911 ("The expression choice offered binary_expr last, so a block heading a && chain could not parse") was closed unmerged by the operator account at exactly 2026-09-30 00:00. That timing looks like a bulk stale-PR sweep, not a rejection; no review or comment on the PR rejects the change. The grammar commit is cherry-picked unchanged. Its note on dag_grammar_expr_expr explains the ordering, what stays above binary_expr and why, and what was not established.

The defect, found independently

A v2 parse probe on main, one module per case:

case	result
a && b (same line)	parses
a then && b on the next line	parses
return a then && b	parses
match a {..} && b (same line)	refuses
match a {..} then && b	refuses
return match a {..} && b	refuses

The newline is irrelevant. dag_grammar_expr_expr is an ordered choice that offered match_expr / if_expr / loop_expr before binary_expr, so the choice commits to the bare block and && b is left over. v1 reads a match as a primary and continues the operator loop after it (v1 02_parse parse_primary), which is the reference. binary_expr already reaches match_expr / if_expr / loop_expr through primary_expr_core, so offering it first admits the form without a new production.

The control #11911 left open

#11911 asserted that a bare block still parses, not that it yields the same node. After the reorder a bare match / if is reached as binary_expr -> primary_expr_core -> match_expr, so its parse path changes by construction. What must not change is what it lowers to. Added:

• a_bare_match_still_lowers_to_the_match_itself_holds: the normalized arrow body is ComputationNode { behavior: Match }.
• a_bare_if_still_lowers_to_the_branch_itself_holds: the normalized arrow body is ComputationNode { behavior: Branch }.

Both pass on main and on this branch. They go red if routing a bare block through binary_expr ever wraps or retains it.

The file's parses are now nullary values enrolled warm in v2.workflow.floor_pure_producer_share, and each claim reads one, so each claim stays within the new-witness eval-step budget.

Evidence (claim_batch, 30 GB BuildBuddy runner)

v2.test.parse.block_expr_as_binary_operand_parse:

• main with only the test added: match_heading_a_binary_chain_parses_holds and if_heading_a_binary_chain_parses_holds FAIL; all 5 controls pass.
• this branch: all 7 pass.

Other suites on this branch:

• occurrence_role and expression_bodied_fn_decl_parse pass.
• reference_conservation's two refused-normalization reds are pre-existing on main and fixed by reference_conservation: refused-normalization controls use a service module (red on main since #12713) #12812.
• parse_test_fn_decl_return_clause exits 1 with no verdict output identically on main, so it is independent of this change.

Parse count (the two class-E files)

Both files also carry an admit_callers trailing comma, so #12796's grammar change was applied to both arms.

	main + #12796	this branch + #12796
test.claim.dispatch_preflight_witness_test	refuses @6880 (&& match)	parses
test.claim.approval_device_redemption_witness_test	refuses @31802 (&& code_of_..)	parses

#11911 measured the population wider: a whole-corpus census of 829 → 650 file refusals, 673 → 480 at parse, net −179. I have not re-derived that census at this head.

No emitted Rust changes: the v2 grammar has no stage0 mirror.

Land only via the merge queue.

🤖 Generated with Claude Code

[briansrls]

APPROVE-MERGE at exact head 9e0536d, merge queue only.

No findings. The ordered-choice repair exposes binary_expr before the match/if/loop prefixes it already contains through primary_expr_core, rather than adding a second syntax form. The two formerly denied chain forms are discriminating reds, and the added normalized-tree controls close #11911's open shape question by requiring bare match/if bodies to remain Match/Branch themselves. Warm enrollment and the unchanged ordinary/bare controls bound the reordering.

This approval requires the actual merge_group candidate to pass against then-current main; no direct merge or check bypass.