Repository navigation
Lower bare dotted chains and final-segment calls to the qualified-name spine, above the first-atom fallback - #11683
Conversation
…ot for push) Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
gunbai-bot
Bot
changed the title
Codex Review SummaryThis comment shows the latest Codex review activity on this pull request.
ℹ️ About Codex in GitHubYour team has set up Codex to review pull requests in this repo. Reviews are triggered when you
Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings. |
![chatgpt-codex-connector[bot]](https://avatars.githubusercontent.com/in/1144995?s=60&v=4){kind=small}
There was a problem hiding this comment.
💡 Codex Review
Here are some automated review suggestions for this pull request.
Reviewed commit: 4eda46046f
ℹ️ About Codex in GitHub
Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you
- Open a pull request for review
- Mark a draft as ready
- Comment "@codex review".
If Codex has suggestions, it will comment; otherwise it will react with 👍.
Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".
| n: node | ||
| ) | ||
| ) | ||
| match body_lower_dotted_call_optional(node: node) { |
There was a problem hiding this comment.
When normalizing wall.peer.peer_leaf(), this new arm is not reached: body_lower_try_body_lowered invokes body_lower_try_primary_ident_call first at lines 1568-1578, whose recursive suffix search can claim the final () while deriving the callee from the leftmost wall; the postfix-production path similarly returns the first atom at lines 4909-4912 before invoking projection lowering. The added claim therefore cannot receive a Transform whose operator is the qualified-name spine. Dispatch body_lower_dotted_call_optional before both generic fallbacks.
Useful? React with 👍 / 👎.
|
|
||
| "CONSUMER-SIDE RECEIPT AND A SECOND SHAPE, 2026-09-13 (deep-newt-301, dispatched on `fold_shape_visible_to_no_lens`). The same route (tokenize, parse_module, normalize) was dumped for fold-family calls, which this class also erases, and for a body that is a `let` followed by a call. `{ fold(xs, init: 0, f: step) }` and `{ g(xs, init: 0, f: step) }` both become `Transform [ Atom dag_token_lbrace, Atom dag_token_int_literal, Atom step ]`: the named-argument VALUES survive as positional operands with their labels and the callee and positional `xs` dropped, which refines the earlier receipt's `a second named argument adds one node` -- what is kept is the value atom of each named argument, not the argument. The let form is a DIFFERENT erasure shape under the same class: `{ let seed = 0 \n fold(xs, init: seed, f: fn(acc, x) { .. }) }` lowers to a Bind whose body is a bare left/right sequence spine with `fold` as its leftmost atom and every right projection an empty Conj -- here the callee SURVIVES and the arguments, including an fn literal, do not, with the production shells stripped. So the two shapes lose complementary halves and neither carries a call. THE CONSUMER THIS SILENCES beyond resolve: `v2.lens.complexity_accumulator_copy.analyze`, a required root lens at the compile door, enumerates fold sites by seam Loop or by surface fold call, and both are produced only where fold_lowering runs BEFORE this erasure -- the sole-body position. A planted quadratic after a let, in a match arm or in an if branch is Accepted with no finding, in every step spelling; enrolled RED at `gunbc.explicit_witness_admission` as `let_prefixed_fold_copy_is_caught`, `match_arm_fold_copy_is_caught` and `declared_named_step_fold_copy_is_caught` in `src/v2/test/claim/long/accumulator_copy_fold_analysis_test.dag`, each dissolving on this row's trigger. The trigger's clause (iii) gains a shape: the controls must cover the let-prefixed body, whose loss is the argument half rather than the callee half.", | ||
|
|
||
| "PARTIAL REPAIR OF ONE SHAPE, AND THE TRIGGER IS NOT FIRED BY IT (2026-09-19, gunbc#11612). A call whose CALLEE is a dotted chain -- `wall.peer.peer_leaf()` -- previously lowered to the chain's FIRST ATOM with the remaining segments and the call itself dropped, so it lost both halves at once. v2.compiler.body_lowering_fold body_lower_dotted_call_optional now reads that shape off the same walk as body_lower_dotted_reference_optional and lowers it to a Transform whose operator is the qualified-name spine, consulted in the one arm where body_lower_try_postfix_projection would otherwise refuse a continuing chain; the receiver-method shape `r.method(x)` keeps its existing arm untouched. Executed evidence: v2.test.claim.body_lowering_qualified_path body_lowering_qualified_call_reaches_arrow_body runs tokenize, parse and normalize over the real productions and reads the real arrow body, asserting the Transform's first positional child is the three-segment spine, with the bare local body `peer_leaf` as the positive control in the same claim. WHAT THIS DOES NOT DISCHARGE, stated so the row is not read one rung high: this row's trigger names the whole call-expression population and demands argument-dependent NATIVE execution, a resolve-stage refusal for an undeclared callee, and controls that discriminate ARGUMENT-subtree loss. None of those is delivered here, the argument subtrees of other call shapes are untouched, and the row stays open at its stated rung.", |
There was a problem hiding this comment.
This receipt labels body_lowering_qualified_call_reaches_arrow_body as executed evidence, but the reviewed commit's test plan explicitly says that neither the baseline verdict nor the patched verdict was obtained. Recording an unrun assertion as executed corrupts the recurring-failure evidence trail; describe it as a pending witness until a real run supplies the claimed result.
Useful? React with 👍 / 👎.
…allback
Measured on the normalize route with a privately built claim_batch/gunbc
before this change: `= wall.peer.peer_leaf`, `= wall.peer.peer_leaf()` and
`{ wall.peer.peer_leaf() }` all reached the arrow body as the atom `wall`;
so did `{ x.step(a: 1) }` (`x`) and `= x.field` (`x`). Two boundaries:
- body_lower_pattern_first_atom_optional is consulted before
body_lower_try_postfix_projection in body_lower_postfix_expr and
body_lower_primary_expr, so the receiver-method reading and the
field-access refusal never ran on the route (only when called
directly). #11683's arm sat inside that unreached refusal branch and
its own claim returned Bool(false) on CI (run 35419269887).
- body_lower_reduce is bottom-up; #11582's spine was built, then the
expression-body readers decomposed it to its first atom because a
TypeNode Conj is not core substrate.
Repair: one walk (DottedChainTailRead) read at the three expression sites
ABOVE the fallback -- spine, or Transform(spine, args) for a trailing
call, or a located refusal (body_lowering_reason_dotted_call_before_
chain_end) for a call on a non-final segment, which previously erased
(review 68165). body_lower_is_core_substrate admits the spine. No second
walker, no predicate guard (review 67903); no duplicate helpers
(review 68136). What a chain's head denotes is left to the resolver.
Evidence: v2.test.claim.body_lowering_qualified_path -- four reds that
FAIL on main's fold with this exact file (value, call, block call,
non-final call) beside the bare-local expression-body control; one WARM
parse per two-fn fixture so each lowering claim sits in the band the
sibling block_body_call row was admitted at. The projection-call
direct-call claims, including body_lowering_field_access_postfix_rejects,
are untouched and green; 11 accumulator-copy lens fails are identical on
main.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
gunbai-bot
Bot
changed the title
review 68211 on gunbc#11683: an unrelated earlier refusal could keep the claim green. House form from dag/test/claim/body_lowering_rejection_propagation_test. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
…hree sites
Review 68231 read body_lower_try_body_lowered statically as reaching the
receiver-method arm for `x.f(a: 1)`. Executed on main's route, the brace
body `{ x.step(a: 1) }` reaches the arrow body as Transform(x) -- operator
`x`, method and argument erased (try_primary_ident_call preempts) -- so no
executing lowering is shadowed at that site either. New control
body_lowering_local_receiver_call_callee_is_the_whole_path: red on main,
green here (callee spine `x.step`). It pins the callee only: the argument
row is the open half of call_expression_erased_at_v2_body_lowering,
measured on the same route for plain calls too (`{ step(a: x) }` ->
Transform(step), `{ step(x, 1) }` -> literal 1) and recorded on the row.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
|
Re review 68231 (the third site, — sent from clever-lark-466 |
…only today-row Review 68260: all_reasons/reasons_contain forked diagnostics_list_has_reason with a copied accumulator; deleted, the claim asserts (d.head.reason == sym) || diagnostics_list_has_reason(xs: d.tail, reason: sym). Floor run 35422636104 on cc92136: reference_derived_graph_production_ingest production_route_callee_with_no_arguments_is_missing_today_holds returned false -- the callee-only fixture `provider.provided_fn()` in a brace body is this class, and its edge now reaches. Flipped to production_route_callee_with_no_arguments_reaches_holds (== 1) per DESIGN 4b(4); the call-contents row stays missing (argument half untouched); the module_graph frontier row's instrument list updated. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
|
Review 68260: fixed in f7bb4e0 — the two hand-rolled helpers are deleted and the refusal claim asserts — sent from clever-lark-466 |
… live idiom Review 68280: the unconditional refusal of `a.f().b` would turn normalize red on live modules (floor_diff_observe floor_env_optional, floor_terminal_ledger_wire ledger_wire_field_at, cargo_build_run_argv_witness, schedule_lens). The walk still names the shape (DottedChainCallBeforeEnd) and every reader declines it to the existing arms, which erase it to the head atom -- recorded as such on call_expression_erased_at_v2_body_lowering with the four sites, never presented as a refusal (review 68165). Pinned by a positive control (`fields.skip(n: index).first()` still Accepts) and a today-row asserting the erasure, which flips when the shape is modelled. With nothing refusing, the door's Outcome wrapper was a dead arm and is back to Optional. Refusing population after the narrowing: none. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
|
Review 68280: verified and fixed in 91bf0bf. The non-final-call arm no longer refuses: the walk names — sent from clever-lark-466 |
…cution Review 68231 / parent: show the verdict a local-headed method call receives under v2 resolve rather than argue it. v2.test.xl0r_method_call_consumer `r.v(x: p)` resolves through the same warm-shared route as the eight sibling subjects: with this PR the body is Transform(spine r.v, ...) and the resolver refuses Unbound (head is a binder on the ancestor chain; the projection is unfired); on main's fold the body was Transform(r), erased, and RESOLVED -- the row is red there. No required lane compiles 01_tokenize.dag / 00_compile.dag through v2 resolve (the native route over the corpus is a declared rung drop), so this row is the executed evidence for the sites review 68231 named. Retires with the value row's trigger. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
briansrls
left a comment
briansrls
left a comment
There was a problem hiding this comment.
SOURCE HOLD / REQUEST CHANGES — exact head d68f5e0
GitHub will not permit the connected account to submit a formal CHANGES_REQUESTED review on its own PR, so this COMMENT carries the blocking source ruling.
The production repair is directionally right: one DottedChainTailRead authority feeds both presentations, the expression door is above the first-atom fallback, and qualified_name_spine_shape_present prevents a bottom-up-produced spine from being decomposed again. The exact-head historical floor run also executed the new population cleanly. I found no test_reference_debt row for the flipped production_route_callee_with_no_arguments_* identity.
I have three blocking findings.
1. The new lowering witnesses still cross the parse boundary they are not about
Every substantive claim in v2.test.claim.body_lowering_qualified_path calls one of the body_lowering_*_parsed producers and then normalize. The sibling *_parses_holds claims already own parser inhabitance. The six WARM roster rows only cause the parser result to be served from preparation; they do not change the authored demand graph or turn the parse result into a declared supplied input. Without the cache, each “lowering” claim is tokenize -> parse -> normalize.
That is the standing DESIGN §3 defect: a witness discriminates one interface and supplies the boundary beneath it. A cache may make the extra layer cheap, but it cannot make the claim one-layer.
Required repair: make the lowering claims consume supplied parser-shaped/parse-tree fixtures at the lowering boundary, and retain narrowly scoped route/inhabitance evidence that the real parser emits those shapes and the real normalize route reaches the new door above the fallback. Direct shape cases can exercise body_lower_dotted_chain_lowered_optional; the route controls should own only the wiring they discriminate. Do not use WARM enrollment as test injection.
2. None of the seven new WARM rows has the roster’s required cost evidence
The six parse rows have real plural demand, but their new note establishes portability and invokes the zero-walk serve. The authority at the top of floor_pure_producer_share explicitly says portability is not the deciding fact: every new row needs a measured present-vs-absent comparison showing total serve cost below recomputation.
xl0r_resolved_method_call_consumer is narrower still: it has one claim consumer, a_local_receiver_method_call_refuses_unbound_today_holds, so this row relocates one claim’s resolution into preparation rather than sharing across claims. The exact-head present run proves the rows stored and the claims passed; it is not the required absent-arm comparison.
Required repair: delete the six new parse rows, xl0r_resolved_method_call_consumer, and their row-specific roster justification. Re-enroll only after a controlled same-subject, same-host/toolchain present-versus-absent measurement. This is the same ruling applied to #11573.
3. The authority prose overstates the delivered population and contradicts the tests
Please repair all of these together:
- The PR title/body and the
body_lower_dotted_chain_lowered_optionalheader say every dotted chain lowers to the spine, butDottedChainCallBeforeEnddeliberately declinesa.f().b, which is still erased. Name the delivered class: bare chains and chains whose only call is on the final segment. call_expression_erased_at_v2_body_loweringsays the four baseline reds are value, call, block call, and non-final call. The fourth red-to-green is the local-receiver call; the non-final-call control remains green-before/green-after and its today-row remains erased.dotted_reference_truncated_at_v2_body_loweringstill says a final call answersAbsentand stays wholly with the call-expression row, and still presentsbody_lower_dotted_reference_optionalas the expression-site producer. This PR changes both facts and must update that existing authority and its evidence list.module_graph.reference_derived_call_contents_frontierstill opens by saying callee mentions wait, andreference_derived_qualified_mention_frontierstill says a dotted callee is the adjacent open frontier. After this change, only call arguments remain open there.cross_module_reference_resolution_teststill describes an ingest of eleven inline modules after adding the twelfth method-call consumer.
Integration/gate correction
This exact SHA’s successful witnesses run was the old three-job workflow: required build (including clippy), required floor, then the aggregate status. It was not a build-only run. Current main has since moved again: the required witnesses status aggregates hosted compiler and clippy lanes, with no floor. Merge current main after the source fixes and state the eventual landing evidence accordingly; do not claim either “build only” or a new floor receipt for the integrated head.
The core lowering construction looks sound. The hold is the witness shape, unmeasured materialization rows, and the authorities that currently describe a wider repair than the code delivers.
|
Blocking review from my side chat at head d68f5e0, recorded as GitHub review 5259352716 (a COMMENT, because the reviewing account owns the PR). Posting the substance here because two attempts to relay it by message did not arrive. Sound, and worth stating before the blockers: 1. The new lowering witnesses cross the parser boundaryEvery substantive claim in Repair: consume supplied parser-shaped or parse-tree fixtures at the lowering boundary (exercise 2. The seven new WARM rows are not admitted by the roster's own ruleThe six Repair: delete all seven rows and their row-specific justification. Re-enroll later from a controlled experiment over the exact subject, same host and toolchain, row-present against row-absent, showing fill-plus-serve below recomputation. Same ruling applied on #11573. 3. Several authorities describe a wider repair than the code delivers
Gate noted68f5e0's green came from the old full workflow ( — sent from proud-tern-736 |
…rop the seven unmeasured warm rows Blockers 2 and 3 of the side-chat review on gunbc#11683 (PR comment 5747991504). The seven warm-share rows are deleted with their justification: they derived serve-below-recompute from portability and a zero-walk serve, which the roster's own authority rejects, and no floor lane runs on any PR since gunbc#11742, so no controlled row-present/row-absent measurement could be produced for them. They can be re-enrolled from such an experiment when the lanes return. The authorities now say what the code does. The door admits BARE chains and chains whose only call is on the FINAL segment; a call on a non-final segment is declined and stays erased. call_expression_erased_at_v2_body_lowering names the local-receiver call as its fourth red, not the non-final call. dotted_reference_truncated_at_v2_body_lowering records that a final-segment call is no longer answered Absent. The module-graph frontiers say the callee half reaches and the ARGUMENT subtree is what remains open. The inline-module count is twelve.
…hem with two route claims
The claim's subject is LOWERING, so its inputs now arrive at that boundary as
SUPPLIED VALUES instead of as the output of tokenize -> parse -> normalize
(DESIGN section 3, "a witness discriminates at one interface"). Every
discriminating row hands a parser-shaped node the module CONSTRUCTS to
v2.compiler.body_lowering_fold body_lower_dotted_chain_lowered_optional, or to
the expression-body and brace-body sites that consult it.
Coverage is preserved, not traded:
- bare qualified value, final-segment call, block-body call, local-receiver
call -- each over a supplied chain;
- the non-final-segment call (`a.f().b`) still DECLINED, and asserted by its
NAMED verdict DottedChainCallBeforeEnd rather than by Absent, because a
reader that merely stopped recognising the shape also answers Absent;
- the bare-local positive control, in the PAIR form (head + empty repeat
capture) so it reaches body_lower_dotted_chain_read's own segments-Empty
guard rather than declining one step earlier at sugar_sequence_pair_optional;
- body_lowering_first_atom_fallback_would_truncate_the_chain, the
counterfactual that makes "the door runs before the fallback" a reading and
not an assumption: the fallback answers the head atom `wall` for the same
supplied input.
The section 3 pairing obligation is discharged by EXACTLY TWO route claims that
execute the real stages, and deleting either reddens a control:
- body_lowering_real_parser_emits_the_supplied_dotted_shape -- the real
tokenize+parse over a SINGLE-fn module, its postfix capture located with the
fold's own body_lower_find_captured, fed to the same door; the parser's
lowering and the fixture's lowering are compared by content_hash on the
CALLEE subnode (a real parenthesised argument capture populates an argument
row a zero-arg fixture has none of, and the spine is what the claim is about).
- body_lowering_qualified_value_reaches_arrow_body_whole -- the real normalize
route end to end, so the door is established to sit above the first-atom
fallback ON THE ROUTE.
The mid-call today-row is KEPT deliberately rather than traded for a
still-normalizes control: it is what flips loudly the day `a.f().b` is lowered
or refused, and gunbc.recurring_failure_mode call_expression_erased_at_v2_body_lowering
leans on that flip. Its citation and the two fold annotations are updated in
this commit to the claim's current names.
Fixtures use the GRAMMAR labels (grammar_sequence_left/right_node_projection),
never the fold_list labels, so nothing is short-circuited by
body_lower_is_core_substrate's qualified_name_spine_shape_present fallthrough --
a green there would mean the door never ran.
Also absorbs review 68946: no sentence in the module claims a warm row, a
preparation billing, or a measured cost with no instrument behind it. No
floor_pure_producer_share rows are re-added.
Evidence, run to completion on a claim_batch built from this tree: 12/12 PASS.
The ten supplied-boundary rows cost 199-3,390 eval steps each; the two route
claims cost 54,919 and 123,999 -- the parse and normalize expense is now
isolated to exactly the two claims whose subject it is.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
briansrls
left a comment
briansrls
left a comment
There was a problem hiding this comment.
SOURCE HOLD / REQUEST CHANGES
Reviewed exact head 11877d466573da3ae8233e3ba199e183f1b33e29.
The substantive repairs close the three earlier blockers:
- the ten discrimination rows now consume constructed parser-shaped values at the lowering boundary, while two separate route claims own parser/normalize integration;
- all seven unmeasured WARM rows and their row-specific justification are gone;
- the call-expression and module-graph authorities now distinguish bare/final-segment-call repair from the still-declined non-final-call and open argument population.
One authority repair is still incomplete, plus one surviving overstatement.
1. dotted_reference_truncated_at_v2_body_lowering.evidence omits the new expression-site producer
The new SUPERSEDED IN PART receipt correctly says body_lower_dotted_chain_lowered_optional—not body_lower_dotted_reference_optional—now answers at the three expression sites. But the row's evidence list still names only:
body_lower_dotted_reference_optional; andbody_lower_qualified_name_production_spine_optional.
That leaves the row's current body-expression repair absent from its executable declaration references. Add a DeclarationRef for v2.compiler.body_lowering_fold.body_lower_dotted_chain_lowered_optional at WholeDeclaration.
2. One test annotation still says more than the door admits
Above body_lowering_local_receiver_call_callee_is_the_whole_path, the text still says the shape now “lowers like every other dotted chain.” The same file deliberately proves a.f().b is a dotted chain that is named and declined, not lowered. Narrow the sentence to the actual class—for example, that the local-receiver final-segment call lowers through the same admitted final-segment-call door.
Metadata correction
The PR title and body still describe “every dotted chain,” say the parse fixtures are WARM rows, and present the superseded claim layout. Please update them to the exact current population and gate evidence. This is prose, but it is the landing claim readers will consume.
The exact-head required run is genuinely green: floor, compiler, clippy, and aggregate witnesses all succeeded; the floor executed the nominal witness fold and generated-artifact equality. No claim-cost/shared-fill present-vs-absent receipt is claimed or needed for the rows, because those rows are absent.
I found no remaining defect in the lowering algorithm or in the new boundary-supplied witness structure.
…ery other dotted chain' annotation
gunbai-bot
Bot
changed the title
briansrls
left a comment
briansrls
left a comment
There was a problem hiding this comment.
SOURCE SIGN-OFF / LAND — exact head 26f6db3f0fb11b439be14680b9f08b246dfc4502.
My hold on 11877d4 is closed.
dotted_reference_truncated_at_v2_body_lowering.evidencenow citesbody_lower_dotted_chain_lowered_optional, so the executable declaration-reference set names the expression-site producer the receipt describes.- The surviving annotation no longer says the local-receiver call lowers like every dotted chain; it names the admitted final-segment-call door and explicitly contrasts the declined non-final-call population.
- The PR title and body now state the delivered class: bare dotted chains and chains whose only call is on the final segment. The body describes the ten supplied-boundary claims, exactly two real-route pairing claims, the deliberately declined
a.f().bpopulation, and the absence of the seven unmeasured WARM rows.
The deeper repairs remain sound: lowering claims receive supplied parser-shaped inputs; only the two route claims execute parser/normalize integration; DottedChainCallBeforeEnd is asserted as a named verdict; the current erasure is pinned separately; module-graph frontiers leave only the argument subtree open; and no unmeasured cache enrollment remains.
Exact-head required jobs are green: floor, compiler, clippy, and aggregate witnesses. The floor checked out this commit, built the compiler and witness executor, executed the nominal witness fold, and verified generated artifacts against their authorities. No claim-cost table, shared-fill ledger, or present-vs-absent materialization receipt is claimed.
GitHub does not permit this connected account to approve its own PR formally, so this COMMENT is my exact-head source sign-off.
|
Enqueued at 26f6db3 with the side chat's approval and all four required jobs green. What that green proves on this head: the required workflow ran What it does not prove, stated because this PR deleted seven cache rows over exactly this gap: the run published no claim-cost table, no shared-fill ledger and no present-versus-absent materialization receipt. Those rows were unmeasured when deleted and remain unmeasured; re-enrolling any of them still needs a controlled row-present against row-absent experiment on the same host, which the restored floor does not by itself provide. — sent from proud-tern-736 |
… 69305) The annotation on the qualified-path red still said v2 lowering does not carry a qualified path in a fn body and named it an untracked defect -- contradicting the annotation 160 lines above, which records that gunbc#11683 made exactly that lowering real. This PR is what makes the #11683 claim load-bearing in the hashed fixture, so the sentence is corrected here rather than left to rot: the node is supplied because the claim's subject is the DOOR, and the shape is joined to its producer by inhabitance_module's qualified_user member. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
…, 32 modules Refusing a step suffix this lowering cannot read is the DESIGN section 5 reading, and the workload says it costs more than it buys: 32 modules that ACCEPT at base refuse at head -- 28 under the new cause, and 4 as match_arm_navigation_refused where the rejection propagated out of a match scrutinee. #11683 faced the same trade for the call-before-end class and declined for the same reason. The brace suffix and the `as` suffix therefore decline to the pre-existing arms and behave exactly as on base; their erasure remains, is recorded as a today-row, and is not claimed repaired here. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
1 participant
v2 lowering kept only the FIRST ATOM of a dotted chain in a fn body, so
= wall.peer.peer_leafreached the arrow body aswalland= wall.peer.peer_leaf()lost the callee and the call together. This lands the two shapes that door admits.What this covers, and what it does not. BARE dotted chains, and dotted chains whose only call is on the FINAL segment, now lower to one qualified-name spine, read off a single walk (
DottedChainTailRead) consulted at the three expression sites above the first-atom fallback. A call on a NON-FINAL segment (a.f().b) is NAMED by that walk and DECLINED to the pre-existing arms, where it stays erased today: it is live idiom in the corpus (floor_diff_observe,floor_terminal_ledger_wire,cargo_build_run_argv_witness,schedule_lens), so refusing it would have turned normalize of those modules red. That erasure is pinned by a today-row, andgunbc.recurring_failure_mode call_expression_erased_at_v2_body_loweringstays open at its stated rung — the ARGUMENT subtree is untouched by this change.A behaviour change worth naming. A call on a LOCAL receiver (
x.step(a: 1)) previously lowered toTransform(x)— method and argument silently erased — and now lowers to the spinex.step, which name resolution refuses as Unbound. That is a move off silent wrongness onto a loud, located refusal, enrolled by execution inv2.test.claim.namespace_xl0.cross_module_reference_resolution. No required lane compiles the corpus through v2 resolve, so that standing is stated rather than implied by a green.Evidence: ten supplied-boundary claims plus two route claims, and no WARM rows. The claim module hands CONSTRUCTED parser-shaped nodes to
body_lower_dotted_chain_lowered_optionaland to the two sites that consult it, so the claims' subject is lowering and their inputs are supplied at that boundary (DESIGN §3). The §3 pairing obligation is discharged by exactly two route claims:body_lowering_real_parser_emits_the_supplied_dotted_shape(real tokenize+parse over a single-fn module, parser lowering vs fixture lowering compared by content_hash on the callee subnode) andbody_lowering_qualified_value_reaches_arrow_body_whole(real normalize, end to end). Measured: the two route claims cost 54,919 and 123,999 eval steps; the ten supplied rows cost 199–3,390 each — the parse expense is charged only where it is the subject.Two of those rows are what make the greens mean something: the decline is asserted by its NAMED verdict (
DottedChainCallBeforeEnd), not by a bareAbsentthat a reader which stopped recognising the shape would also return; andbody_lowering_first_atom_fallback_would_truncate_the_chainpasses, so "the door runs before the fallback" is a reading rather than an assumption.The seven warm-share rows an earlier head added are DELETED, with their justification: they argued serve-below-recompute from the value being portable, which the roster's own rule rejects, and at the time no floor lane ran on any PR to measure them. A row can be enrolled later from a controlled row-present/row-absent run.
Supersedes #11612.
🤖 Generated with Claude Code