Unify fn and func on a single fn item form

[gunbai-bot]

What

.dag carried two item forms for one concept: fn (type parameters, no uses) and func (a uses row, no type parameters). That is a §3 fork — one concept, two names, differing only in which fields each could carry. This unifies on the single fn form by flipping has_uses: false -> true on its grammar row and deleting the func ItemForm and keyword, and rewrites every func declaration in the corpus to fn.

Evidence the fork was live: while this PR was open, main delivered four new func declarations, three at once carrying uses rows. Authors were selecting a spelling by which grammar fields it permitted, not by semantic kind.

Landed as one squash-merge so main never carries dual authority. The bootstrap constraint was measured, not assumed — the committed mirror IS the parser that reads .dag, so the mirror boot recipe (grammar row patch + parser delta replay, then the regen phase adjudicates) is what makes a one-round cut possible.

The semantic repair, and why it is the risky part

parse_fn_body_from_prefix built its node with a hardcoded uses: [] while the func path bound prefix.uses. Unifying without this fix would have SILENTLY DISCARDED every effect row: a dropped row still parses, and the stage0 mirrors project only compiler modules, which declare no uses — so both cheap oracles are structurally blind to it.

Its evidence is test.claim.generic_effectful_declaration_wall_witness_test, whose positive control returns net.id so the resource must be BOUND, and whose mutation bar is executed rather than asserted: restoring uses: [] on the success node reddens exactly that arm while the other two stay green. The recovery node is NOT covered (it carries body: none, so nothing can reference the resource) and the file says so.

The new refusal

Unifying makes <T> + uses newly grammatical, and no emitter plumbs type parameters through the effectful path. A typed located refusal sits at the single ingress where both facts are in scope. Moving it to the emission boundary is correct layering that would LOWER the rung today, because gunbc.rung_drop.emit_stage_blocking is standing and file_emission_target_is_modeled answers Rust=>true with Python, Go and Dag all false.

How this became landable

This PR was the specimen of gunbc.recurring_failure_mode.base_readability_gate_refuses_a_grammar_change: the wave-admission phase parsed base-revision declarations with the head parser, so a grammar change was refused NotEvaluated. The prerequisite (#10970, landed as ab898ba3edf) loads the base revision's own ParseEnvironment and reads the base under it when the environments differ. This PR is recut on that main and the required floor now reads, on this exact head:

namespace-wave-admission: the base and head parse environments differ (dag/extdeps/languages/dag/syntax.dag), so the baseline is read in full under the base's own grammar rather than reconstructed from untouched head records
namespace-wave-admission base=ab898ba3edf… head=981a15717c3… modules_compared=5666 modules_added=1 … deltas=0
namespace-wave-admission ADMITTED
required-floor: verdict=FloorClean

The failure-mode row stays enrolled as regression evidence per §4b(4).

Deliberately OUT of this PR (independent follow-ups): collapsing FuncItem into FnItem in the node model, and repairing uses rows that were authored against the old form.

Test plan

• test.claim.generic_effectful_declaration_wall_witness_test — 3 arms, enrolled; mutation bar executed against v1_compiler_parse.rs.
• Required lanes on this head: required-witnesses-build, required-witnesses-floor, heal-generated-artifacts, witnesses all SUCCESS; floor FloorClean, wave ADMITTED.
• Corpus residual: zero .dag item declarations spell func.

🤖 Generated with Claude Code

https://claude.ai/code/session_01XjkfJ59JXcYnbtgTCH2Utn

[gunbai-bot]

CI state at daf0c07, since the red is expected and its only in-scope "fix" would defeat the change.

One blocking cause, unchanged across three runs:

namespace-wave-admission NotEvaluated — dag/extdeps/access/posix_effective_principal_read_op.dag
does not parse at the base revision (5 diagnostic(s)), so its base-side declarations cannot be read

The phase compares base-side and head-side declarations and parses the base revision with the head compiler. This PR deletes the func keyword, so all 140+ changed .dag files are unreadable at base. The 5 diagnostics are one refused declaration plus its orphaned annotations, and the same shape holds for every changed file. The base is not defective — main parses clean under main's own compiler; it is unreadable only under the head grammar.

Filed as its own class in this PR: gunbc.recurring_failure_mode.base_readability_gate_refuses_a_grammar_change, kept separate from fail_closed_gate_refuses_its_own_repair because that row's recognition rule is a defective base the head repairs, which is false here. It is self-clearing only by landing: once merged, every later PR has a post-cut base and the phase evaluates normally.

Not being "fixed" deliberately. The only edit that turns this phase green is keeping func as a transitional parse-only alias — the staged migration DESIGN §3 delete-first forbids and that the approving ruling rejected ("an alias plus deprecation diagnostic would preserve a second authority without buying a migration window"). Escalated to the operator instead; a gate should not settle a language-design question by attrition.

Every other required signal is green:

signal	result
required-witnesses-build	PASS
floor	planned=3552 executed=3552 terminal=3552 passed=3483 claims_failed=0
.dag parse sweep (merged tree)	0 errors — was 64 refusals + 3980 orphaned annotations pre-cut
regen	first_generation_equal=true
enrolled wall witness	both arms pass in the required floor (planned 3550→3552, passed 3481→3483)

Known gaps, stated rather than implied: the identity-keyed before/after over the 451 rewritten declarations is not built; and the prefix.uses threading has no enrolled discriminating control — a discarded effect row still parses (sweep 0 errors with the row dropped) and regen drift cannot see it either, since stage0 mirrors project only the compiler's own modules, which declare no uses. Both are recorded in the witness with next-rung triggers.

A residual-func check is needed immediately before merge: main delivered new func declarations mid-flight once already (14, in the merge from main).

[gunbai-bot]

Merge of fe83b41f48a (#10814, world_converge deleted at the root) delivered a new func declaration onto main after this branch cut the keyword — gunbc.repo.repo_ruleset verify. That is the mid-flight delivery this change has to expect: every branch authored against pre-cut main can add one, and the conflict only surfaced it here because #10814 rewrote the same hunk. Resolved by taking main's side whole (the world_converge replacement) and respelling the one declaration.

The same merge is the occasion for a residual this branch had not swept: three hand-rolled item-keyword rosters in cli_run.rs still listed "func "/"pub func " — decl_head, ITEM_KEYWORDS, FACT_CARDINALITY_ITEM_KEYWORDS (two of them fixed-arity [&str; 8], now 7). A census that counts a spelling the compiler refuses is a divergence between what the corpus says a declaration is and what the parser accepts, so the entries are removed rather than left inert. They rode in on the merge commit f639ee9f439 rather than a commit of their own; recording them here so the diff is not the only place they appear.

Verified with the command CI runs, read by its exit code: cargo clippy --all-targets -- -D warnings, CLIPPY_EXIT=0.

[briansrls]

HOLD at exact head f639ee9f439329a5dcf29ce558a0378561c13b36.

The core fn/func cut is directionally right: the modeled fn row now admits uses, parse_fn_body_from_prefix carries prefix.uses, the redundant item-form and dead parser mirrors are removed, the corpus spelling is rewritten, and the live source-facing projection no longer reports FuncItem as authored func.

There are three blocking issues:

1. Restore namespace-wave-admission; do not pay for this grammar cut by deleting a required guarantee. This branch removes the required phase from required_ci_phase_roster, deletes its execution from claim_executor, deletes its implementation/tests and two guarantee-stall rows, and records a permanent rung drop because the HEAD parser cannot read base-side func declarations. That is a defect in cross-revision acquisition, not authorization to remove the adjudicator. Revert 039990d9f51a86bc72e444305df93e1620d9013e and the dependent cleanup/rung-drop work. Preserve NotEvaluated as refusing and preserve the deletion of the func alias. The repair is to obtain the base declaration index under the base revision's own grammar/compiler and feed a stable projection to the head adjudicator; land that as a prerequisite if it cannot remain single-subject here.

2. The new positive witness does not witness the load-bearing prefix.uses repair. gew_plain_effectful declares uses net: GewNet2, but its body only returns x, and the assertion checks only that ParseError count is zero. Restoring the old uses: [] hardcode would still make this test green. Make the positive fixture consume the binding—for example return net.id—and assert zero total blocking diagnostics (or the exact emitted resource binding), so deleting the threading produces a RED. Also add a constructed legacy func declaration that must produce the parser refusal; the current pair tests generic+effects, not deletion of the old spelling.

3. The generic-plus-uses wall is at the wrong semantic boundary as currently justified. parse_fn_body_from_prefix rejects the construct because the Rust/Python/Go effectful emitters do not plumb type parameters. That makes an emitter limitation part of the source grammar and also blocks interpreter/Dag paths before target selection. Keep the parser's one callable grammar and carry both facts; refuse at artifact/target emission before publishing success, unless this PR can establish that the language/interpreter itself cannot represent the combination independently of those three emitters.

The PR is also still draft with the placeholder title/body and its exact-head workflow is still in progress. Please update the summary/test plan after the substantive repairs and bring back a terminal exact-head run.

[gunbai-bot]

Dispositions on review 5149145309. Two of three are acted on; one is declined with its reason, and finding 2 turned up something worth more than the fix.

Finding 2 — ACCEPTED, and the verification as proposed would have been false

You are right that the control proved nothing about the repair beside it. Fixed as you describe: the control returns net.id so the resource must be BOUND, and it counts every blocking class rather than ParseError alone — an unbound net is not a parse failure, so the old scoping was blind to exactly the mutation the arm exists to catch. The total is exact only because these fixtures import nothing, which is now stated in the file. Third arm added for the removed spelling: the sweep proves no func declaration REMAINS; that is a different claim from the grammar REFUSING one.

The mutation bar was executed, and it holds for one node of two.

success node   uses: prefix.uses -> uses: []   =>  THIS ARM FAILS, other two PASS
recovery node  uses: prefix.uses -> uses: []   =>  ALL THREE PASS -- NOT COVERED

The recovery node carries body: none, so no expression in it can reference the resource and no compile census can separate a threaded row from a dropped one there. Recorded as uncovered rather than folded into a pair that passes.

And the first mutation round was run in the wrong tree and PASSED. compile_dag_diagnostic_census is a host fold in cli_run, so the fixture is compiled by the SEED BINARY, not by src/v1/02_parse.dag under interpretation — a .dag mutation leaves this witness green until regen installs it. Verified the way it was proposed, your fix would have produced a false receipt. The mutation belongs in v1_compiler_parse.rs, and the file now says so.

Finding 3 — the layering argument is correct; executing it today LOWERS the rung

Agreed on the principle, and emit_func_def is indeed selected inside the Rust emitter by is_effectful, so this is a realization fact sitting in the interface. What stops the move is measured, not stylistic:

• gunbc.rung_drop.emit_stage_blocking is a STANDING declared drop: a blocking emit-stage diagnostic can sit on main indefinitely with no required phase that fails. A parse phase reaches a parse refusal; nothing required reaches an emit one.
• The refusal surface does not exist for two of the three targets the diagnostic names — file_emission_target_is_modeled answers Rust => true, with Python, Go and Dag all false.
• The Rust-side mechanism at that seam, emit_rust_item_refusal, emits compile_error! INTO the artifact, deferring the refusal to rustc — the fabricated-plausible-output failure this witness file already argues against.

So the choice is a §3 layer inversion that refuses loudly, against correct layering that refuses where nothing gates and, for two targets, cannot refuse at all. That second arm is a §4b(3) rung drop, and I am not taking it silently to buy layering purity for a construct the corpus contains zero instances of. Stated honestly as a cost rather than a virtue: the wall does make a coherent construct unwritable, and I have NOT established whether the interpreter would execute it. The condition that moves the refusal is emit_stage_blocking's own restoration trigger.

Finding 1 — declined, and the ruling you are looking for is in the session, not the commit

The deletion is not scope drift. The operator instructed it directly: "i would delete that behavior", and when offered three scopings chose deleting the whole phase. I raised the objection you are raising BEFORE doing it, which is why the choice was put to them at all.

You are right that main still carries the module and that the standing direction says repair, not delete — that is exactly why it was escalated rather than decided. You are also right about the repair shape, and it is not discarded: it is the restoration trigger of gunbc.rung_drop.namespace_wave_admission_deleted, verbatim — base-side declaration reading bound to the compiler of the revision being read.

Reverting would reverse an explicit operator decision on a reviewer's request, which is not mine to do. If the ruling should be revisited — land the revision-relative acquisition first and rebase this PR onto it — that is the operator's call, and I have flagged it to them rather than deciding either way myself.

[briansrls]

HOLD at exact head e9dc3ebdbb3fa1f7114572e9570045dc0ba9eb67. Current ruling: REVERT the whole-phase deletion and land revision-relative acquisition first.

This supersedes the earlier instruction to “delete that behavior” to the extent it was implemented as deleting the entire namespace-wave-admission capability. Delete the defective behavior—reading BASE source with the HEAD grammar—not the independent required wall.

The core A work is approved. Main’s continuing delivery of production func … uses declarations strengthens the case that this is one concept with two field-gated spellings. The revised witness also resolves review finding 2: the positive arm now consumes net.id, counts all blocking diagnostics, has an executed mutation bar on the seed parser, and separately proves the removed func spelling refuses. I also withdraw finding 3 as a blocker for A: the generic-plus-uses parse wall preserves the pre-cut accepted-program set and is an honest temporary safety wall while emit-stage blocking remains below the required path. It must not be read as terminal semantics, but this PR need not build generic effectful emission.

The contested deletion is different. §3’s delete-first root is the obsolete func declaration form. namespace-wave-admission is not a second spelling or realization of that fact; it asks an independent safety question about subject-membership and binding motion. Its refusal is the deletion census working: it exposed one load-bearing assumption in a consumer. The next sentence of the doctrine says to fix surfaced dependents forward from first principles, and the atomicity clause is explicit that minimum Y must preserve every required refusal. A required merge wall is a gap-intolerant boundary. The fact that staging/freeze preserves its refusal is why that carve-out applies, not why it does not.

The declared §4b(3) drop makes the deletion honest rather than silent. That is good bookkeeping, and my earlier phrasing that the implementation simply contradicted the docs was too categorical. But permission to record a bounded safety regression is not evidence that deleting the capability is the preferred fix, nor does §3 make the gate obsolete. Recent #10871/#10889 arm churn does not change the question the wall answers or the four-member population this branch itself says becomes unguarded.

Required sequence:

1. Revert 039990d9f51a86bc72e444305df93e1620d9013e and the dependent phase-removal cleanup: restore the required roster member, execution path, implementation, tests, milestones, and the two guarantee-stall rows; remove namespace_wave_admission_deleted once its restoration trigger is satisfied.
2. Land a prerequisite that reads each revision with that revision’s own compiler and projects both sides into one stable declaration-index interchange shape: BASE source → BASE compiler → projection; HEAD source → HEAD compiler → the same projection; HEAD adjudicator compares them. Preserve NotEvaluated as refusing. Do not restore a func alias.
3. Rebase the syntax cut onto that prerequisite. Its exact-head required run must show namespace-wave-admission Adjudicated, not absent and not NotEvaluated, followed by the residual func census and fixed-point receipts.

The newly filed base_readability_gate_refuses_a_grammar_change class is a valid finding; carry it with the prerequisite repair rather than using removal of its sole live specimen as the resolution.

Maintenance merges and respellings while waiting were appropriate and are not being read as work past the unresolved decision. The decision is now closed: preserve the wall; repair acquisition first; then land the one-spelling cut.

Superseded by the exact-head LAND review on 3a05b6f. The phase was restored, revision-relative base acquisition landed as #10970, the discriminating uses witness and legacy-spelling refusal are enrolled, and the exact-head required run is green with namespace-wave-admission ADMITTED.

[briansrls]

LAND @ 3a05b6fb4acab00cac18af6e1e60730bb32a4aaa.

The three earlier holds are satisfied and have been dismissed: namespace-wave-admission is restored; revision-relative base acquisition landed first as #10970 / ab898ba3edf16076654f9bfd6b7712fda3e28a70; the prefix.uses repair has an executed discriminating mutation bar; the removed func spelling refuses; and the exact-head required run is terminal SUCCESS across required-witnesses-build, required-witnesses-floor, heal-generated-artifacts, and witnesses. The floor reaches the differing-environment full-base route, reports namespace-wave-admission ADMITTED, and terminates FloorClean. The PR is ready and GitHub reports merge state CLEAN.

Scope remains the approved A cut: one fn item form with has_uses: true, deletion of the Dag func item form/keyword, corpus declaration-head rewrite, prefix.uses preservation, and the temporary typed generic-plus-effects refusal. FuncItem collapse and missing-uses repair remain separate follow-ups.

This authorizes enqueue only, with expectedHeadOid pinned to the full SHA above. It does not transfer to any new head and does not authorize a manual merge or native-review bypass. Because main has advanced since the pull-request run, the composed merge-group/queue run remains the final integration proof; any required-context red holds the landing.