feat(grammar)!: Rust-like record syntax — bare { = block, records use #{ }

BREAKING — do NOT merge standalone; lands atomically with the codemod
migration of all .affine record literals (epic affinescript#218).

`{` in expression position is now ALWAYS a block. Record/struct
literals use the `#{ … }` sigil — both anonymous (`#{ x: 1 }`) and
typed (`Foo #{ x: 1 }`). Eliminates the block-vs-record-literal
ambiguity (#215 families C+D) structurally, plus the Rust
struct-literal-in-if/match-scrutinee hazard. Record patterns
unaffected (no block alternative in pattern position).

HASH_LBRACE token (token.ml) + `#{` lexer rule (lexer.ml, sedlex
multi-char, ordered) + both ExprRecord productions rerouted
(parser.mly). Conflicts 72→68 S/R, 10→7 R/R; build clean.

Refs #218 #215

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

lib/lexer.ml

@@ -165,6 +165,9 @@ let rec token state buf =
   | "->" -> ARROW
   | "=>" -> FAT_ARROW
   | "::" -> COLONCOLON
+  (* Record-literal opener (affinescript#215): `#{` is the unambiguous
+     record/struct-literal sigil; bare `{` is always a block. *)
+  | "#{" -> HASH_LBRACE
   (* Row variable "..name" — must come before ".." so sedlex prefers the longer match *)
   | "..", lower_ident ->
     let s = Sedlexing.Utf8.lexeme buf in

lib/parser.mly

@@ -66,6 +66,7 @@ let rec effect_union_of_list = function
 
 /* Punctuation */
 %token LPAREN RPAREN LBRACE RBRACE LBRACKET RBRACKET
+%token HASH_LBRACE   /* `#{` record-literal opener (affinescript#215) */
 %token COMMA SEMICOLON COLON COLONCOLON DOT DOTDOT
 %token ARROW FAT_ARROW PIPE AT UNDERSCORE BACKSLASH QUESTION
 
@@ -768,10 +769,11 @@ expr_primary:
      ordinary parameter binding named "self". */
   | SELF_KW { ExprVar (mk_ident "self" $startpos $endpos) }
   | name = lower_ident { ExprVar (mk_ident name $startpos $endpos) }
-  /* Struct literal: `Point { x: v, y: w }`.  Must come before the plain
-     upper_ident production so Menhir shifts LBRACE rather than reducing
-     upper_ident to ExprVar when the next token is LBRACE. */
-  | _ty = upper_ident LBRACE b = expr_record_body RBRACE
+  /* Struct literal: `Point #{ x: v, y: w }` (affinescript#215). The `#{`
+     sigil makes this unambiguous against a bare block and removes the
+     Rust-style struct-literal-in-`if`/`match`-scrutinee hazard entirely;
+     no production-ordering hack needed any more. */
+  | _ty = upper_ident HASH_LBRACE b = expr_record_body RBRACE
     { ExprRecord { er_fields = fst b; er_spread = snd b } }
   | name = upper_ident { ExprVar (mk_ident name $startpos $endpos) }
   | ty = upper_ident COLONCOLON variant = upper_ident
@@ -787,11 +789,12 @@ expr_primary:
   /* Arrays */
   | LBRACKET es = separated_list(COMMA, expr) RBRACKET { ExprArray es }
 
-  /* Records — use a recursive rule (expr_record_body / expr_record_rest) to
-     avoid the LALR(1) greedy-separator conflict that arises when a ROW_VAR
-     spread like `..record` follows a COMMA that `separated_list` has already
-     consumed expecting another record_field. */
-  | LBRACE b = expr_record_body RBRACE
+  /* Anonymous record `#{ f: v, ..spread }` (affinescript#215). The `#{`
+     sigil removes the entire block-vs-record-literal ambiguity (family
+     C+D) by construction — bare `{` is now unconditionally a block.
+     expr_record_body / expr_record_rest stay recursive to avoid the
+     ROW_VAR greedy-separator conflict on `..spread` after a COMMA. */
+  | HASH_LBRACE b = expr_record_body RBRACE
     { ExprRecord { er_fields = fst b; er_spread = snd b } }
 
   /* Block */

lib/token.ml

@@ -73,6 +73,7 @@ type t =
   | RPAREN
   | LBRACE
   | RBRACE
+  | HASH_LBRACE   (** #{ — record-literal opener (affinescript#215) *)
   | LBRACKET
   | RBRACKET
   | COMMA
@@ -187,6 +188,7 @@ let to_string = function
   | RPAREN -> ")"
   | LBRACE -> "{"
   | RBRACE -> "}"
+  | HASH_LBRACE -> "#{"
   | LBRACKET -> "["
   | RBRACKET -> "]"
   | COMMA -> ","