fix: three compiler fixes for explicit-return functions and Never type

1. unify.ml: add Never (bottom type) as universal unifier
   TCon "Never" unifies with any type, allowing functions whose all
   paths return via `return expr;` to pass the type checker.

2. typecheck.ml: block divergence propagation
   Add always_diverges / block_always_diverges helpers; synth_block
   returns ty_never (not ty_unit) when all block paths diverge.
   This makes `fn f() -> T { return x; }` typecheck correctly.

3. parser.mly: block_terminator rule for self-delimiting exprs
   Split the block rule to accept a `block_terminator` as a final
   expression: `if`/`match`/nested-`block` end with `}` and are
   LR(1)-distinguishable from statements without consuming a `;`.
   Simple literals/idents as block-final still need `return`.
   Parser conflicts: 1248 → 1245.

Together these allow real-world AffineScript source to compile:
airborne-submarine-squadron/src/main.as now produces a valid 8KB
WASM 1.0 binary.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

.machine_readable/6a2/STATE.a2ml

@@ -4,7 +4,7 @@
 [metadata]
 project = "affinescript"
 version = "0.1.0"
-last-updated = "2026-03-29"
+last-updated = "2026-04-03"
 status = "active"
 
 [project-context]
@@ -15,11 +15,11 @@ tagline = "Rust-inspired language with affine types, dependent types, row polymo
 
 [components]
 lexer = "complete"
-parser = "complete"
-type-checker = "98%"
+parser = "complete (1245 conflicts; block_terminator rule added for self-delimiting exprs)"
+type-checker = "99% (Never/bottom type handling fixed; block divergence propagation added)"
 borrow-checker = "95%"
 interpreter = "95%"
-wasm-codegen = "90%"
+wasm-codegen = "92% (real-world game compiles: airborne-submarine-squadron/src/main.as → 8KB WASM)"
 julia-codegen = "exists"
 lsp-phase-a = "complete"
 lsp-phase-b = "in-progress"

lib/parser.mly

@@ -602,9 +602,23 @@ unsafe_op:
 
 /* ========== Statements ========== */
 
+(* Self-delimiting expressions that can serve as the final expression in a
+   block without a trailing semicolon.  Because they all end with '}', the
+   LR(1) parser can distinguish "this was the last expression" (followed by
+   the outer '}') from "this was a statement" (which would need ';'). *)
+block_terminator:
+  | IF cond = expr then_blk = block else_part = else_part?
+    { ExprIf { ei_cond = cond; ei_then = ExprBlock then_blk; ei_else = else_part } }
+  | MATCH scrutinee = expr LBRACE arms = list(match_arm) RBRACE
+    { ExprMatch { em_scrutinee = scrutinee; em_arms = arms } }
+  | inner = block
+    { ExprBlock inner }
+
 block:
-  | LBRACE stmts = list(stmt) final = expr? RBRACE
-    { { blk_stmts = stmts; blk_expr = final } }
+  | LBRACE stmts = list(stmt) RBRACE
+    { { blk_stmts = stmts; blk_expr = None } }
+  | LBRACE stmts = list(stmt) final = block_terminator RBRACE
+    { { blk_stmts = stmts; blk_expr = Some final } }
 
 stmt:
   | LET mut_ = MUT? pat = pattern ty = type_annotation? EQ value = expr SEMICOLON

lib/typecheck.ml

@@ -830,6 +830,27 @@ and synth_list (ctx : context) (exprs : expr list) : (ty list) result =
 
 (** {1 Block and statement typing} *)
 
+(** Returns true if an expression always diverges — i.e., it never produces
+    a value in normal control flow. Used to give blocks a Never type when
+    all paths exit via return. *)
+and always_diverges (e : expr) : bool =
+  match e with
+  | ExprReturn _ -> true
+  | ExprBlock blk -> block_always_diverges blk
+  | ExprIf { ei_cond = _; ei_then; ei_else = Some else_e } ->
+    always_diverges ei_then && always_diverges else_e
+  | _ -> false
+
+(** Returns true if a block always diverges (all paths return). *)
+and block_always_diverges (blk : block) : bool =
+  match blk.blk_expr with
+  | Some e -> always_diverges e
+  | None ->
+    begin match List.rev blk.blk_stmts with
+    | StmtExpr e :: _ -> always_diverges e
+    | _ -> false
+    end
+
 and synth_block (ctx : context) (blk : block) : ty result =
   (* Type-check each statement for side effects *)
   let* () = List.fold_left (fun acc stmt ->
@@ -839,7 +860,14 @@ and synth_block (ctx : context) (blk : block) : ty result =
   (* The block's type is the type of the final expression, or Unit *)
   match blk.blk_expr with
   | Some e -> synth ctx e
-  | None -> Ok ty_unit
+  | None ->
+    (* When all paths through the block diverge (every code path ends with
+       return/break/etc.), the block has type Never rather than Unit. This
+       allows functions declared as returning T to have bodies that exclusively
+       use `return expr;` rather than a final expression. *)
+    if block_always_diverges blk
+    then Ok ty_never
+    else Ok ty_unit
 
 and check_stmt (ctx : context) (stmt : stmt) : unit result =
   match stmt with

lib/unify.ml

@@ -220,6 +220,9 @@ let rec unify (t1 : ty) (t2 : ty) : unit result =
     if nat_eq (normalize_nat n1) (normalize_nat n2) then Ok ()
     else Error (TypeMismatch (t1, t2))
 
+  (* Never (bottom type) unifies with anything — diverging paths are compatible with all types *)
+  | (TCon "Never", _) | (_, TCon "Never") -> Ok ()
+
   (* Mismatch *)
   | _ ->
     Error (TypeMismatch (t1, t2))