Rust-like record syntax migration: bare { = block, records use #{ } (resolves #215 families C+D)

[hyperpolymath]

Decision

To eliminate the block-vs-record-literal parser ambiguity (families
C+D of #215) structurally rather than by a human-facing lookahead
heuristic, AffineScript moves to a Rust-like model:

• { in expression position is ALWAYS a block.
• Record/struct literals use the #{ … } sigil — both anonymous
  (#{ x: 1 }) and typed (Foo #{ x: 1 }). This also removes the
  Rust struct-literal-in-if/match-scrutinee hazard entirely.
• Record patterns (match x { Foo { a } => … }) are unaffected —
  pattern position has no block alternative, so no ambiguity there.

Owner-approved (2026-05-18). Supersedes the lookahead-heuristic option.

Status of the grammar change

Implemented and correct on branch stage-c/pc-brace-disambig:
HASH_LBRACE token (token.ml), #{ lexer rule (lexer.ml), both
ExprRecord productions rerouted (parser.mly). Conflicts dropped
72→68 S/R, 10→7 R/R, build clean. Not merged — breaking; needs the
migration to land atomically with it.

Scope (true cost, measured)

• ~60 of 353 .affine files in the affinescript repo use the old
  record syntax (test fixtures, golden oracles, examples, stdlib) —
  21 tests currently fail (expected, pre-migration).
• Wider estate .affine files on top of that.
• A residual reduce/reduce remains even after migration
  (state 401, LBRACE IF expr block option(else_part) — a distinct
  if-expr-as-statement ambiguity, family-D-residual) plus ~68 S/R;
  tracked as follow-on families, NOT blocking this migration.

Plan

1. Codemod (linchpin): instrument the origin/main parser (old
   grammar still parses old syntax) to emit each ExprRecord's
   LBRACE byte-offset per file; a script inserts # at those
   offsets (descending). Precise — only true record literals, never
   blocks/declarations/match/if. Validate on a sample.
2. Atomic affinescript PR: grammar/lexer/token change
   (stage-c/pc-brace-disambig) + codemod-migrated repo .affine
   (stdlib + tests + examples + golden) so the 257 gate goes green
   with the new syntax. Conflict delta reported.
3. Estate sweep: run the codemod across all estate .affine
   repos, one PR per repo (or batched), each gated.
4. Residual families (separate, after migration lands): state-401
   R/R + remaining S/R → continue Eliminate all Menhir parser conflicts (75 S/R + 10 R/R) — dedicated grammar-conflict workstream #215 family work.
5. Docs: update language reference / guides for #{.

Done when

#{ is the sole record-literal syntax estate-wide, affinescript 257
gate green, conflict count reported, residual families re-listed on
#215.

🤖 Generated with Claude Code

[hyperpolymath]

Status update (post-recovery + accurate scoping)

Env incident recovered: affinescript main clone vanished mid-work (WSL fs instability under /home/.../dev); re-cloned to /tmp/affinescript. Branches restored & pushed durable: stage-c/pc-brace-disambig (grammar, d22be56) + stage-c/codemod (tooling). Nothing merged was lost.

Parser bug fixed & merged — #219: Parse.parse_file had a non-exhaustive Token→Parser match missing EXTERN → runtime Match_failure on ALL extern code (every FFI stdlib file). Fixed; 257 green. This unblocked stdlib parsing.

Accurate scope (the feared estate migration is small):

• stdlib has ZERO record literals (the {recursive:} was a doc comment). Not affected.
• Codemod reliably finds typed Foo {…} records: 8 sites / 6 fixture files.
• Bare-anon {x: 42} records (e.g. tests/codegen/test_record_simple, tests/scratch/test_spread*, conformance/007_struct_def): the OLD grammar's block-vs-record ambiguity often parses these as blocks, so the AST codemod can't detect them — but the NEW grammar makes them unambiguously blocks (→ parse error). These ~tens of small test fixtures must be migrated via compiler-as-oracle: apply grammar change, run 257, each failure pinpoints a {→#{ site, fix, repeat.
• The codemod is parse-gated; the ~50 record-ish skipped files are mostly bare-anon fixtures handled by the oracle approach, not the codemod.

Revised plan: codemod does the typed-record bulk; compiler-oracle iteration does the bare-anon fixtures; combine with grammar branch → atomic PR → 257 green. Estate sweep (step 3) likely near-empty (stdlib clean; consumers rarely use bare-anon records — to be confirmed by an estate grep).

[hyperpolymath]

Step 2 DONE — PR #222 open (review-gated, breaking), 257/257 green.

Grammar (bare {=block, records #{}) + HASH_LBRACE token-bridge in both parse.ml & parse_driver.ml + all expression-position record literals migrated (compiler-as-oracle; 12 files incl stdlib/testing.affine — the one stdlib record the earlier parse-gated survey missed). Type-position/struct-decl/block/match-arm-block unchanged. Conflicts 72→68 S/R, 10→7 R/R.

Note: the AST codemod (step 1) proved unsound in ambiguous cases (mis-located braces onto fn-body { because it trusts the OLD grammar's broken disambiguation) — migration was done via compiler-as-oracle + hand verification instead. Codemod retained only as an artifact.

Remaining: #222 review/merge → estate .affine grep (step 3, likely tiny) → #215 residual families (state-401 R/R + ~68 S/R) + #{ docs (step 4-5).