Type-checking gaps (segfault/corruption → compile errors):
- 0197: reject a store into an annotated slot whose value has no modeled
coercion AND a different byte width (a 16-byte string into a 4-byte i32
overran the slot and segfaulted). New checkAssignable / noneReinterpretIsUnsafe
(coerce.zig, width via the LLVM-accurate typeSizeBytes) wired into every store
site: var/const-decl, single + multi assignment (identifier/field/index/
element/deref), named-return defaults. Same-width reinterpretations (*T→[*]T,
i64→isize, fn-ref) and explicit xx/cast stay allowed; cascades suppressed via
externalErrorsExist. Examples 1205, 1206.
- 0198: an implicit `Any → T` unbox is now a compile error (it blindly
reinterpreted the boxed payload — silent garbage for a wrong scalar, a segfault
for an aggregate). xx and compiler-generated match/pack unboxes are unaffected.
Example 1207.
- 0199: `Any == <concrete>` (one operand Any) aborted the LLVM verifier — the
comparison arm now fires when either operand is Any, boxing the concrete side
first. Example 0654.
Multi-return deferrals (PLAN-MULTIRET #6 + named-order + D3 + generic):
- Reorder named return elements by name instead of requiring slot order; error on
unknown/duplicate/missing (value-only AND full-failable-tuple forms). Examples
0210, 0214.
- Reject a bare-paren (A, B) multi-return signature in generic-arg position
(return-position-only). Example 0215.
- Multi-return closure types / lambda literals work via the reused tuple
machinery (destructure, single-bind+field, lambda arg). Example 0216.
- Generic multi-return: positional works (0217); 0200: the named-slot
implicit-return form now works for generic free fns + struct methods —
monomorphizeFunction now calls bindNamedReturnSlots. Example 0218.
readme.md documents the annotated-store coercion rule; CHECKPOINT-MULTIRET.md
updated. Full corpus green (850/0).
A function may return multiple values via a bare-paren return signature:
`-> (A, B)` / `-> (x: A, y: B)` / `-> (A, B, !)` (error always the last slot),
and `-> ()` is `void`. This is DISTINCT from a `Tuple(…)` value — return-position
only (a dedicated `ReturnTypeExpr` AST node resolving to a reused `.tuple`
TypeId); a parameter / field / variable annotation `x: (A, B)` is rejected. A
single-value `-> (T, !)` stays a plain failable (= `-> T !`).
Returns use the bare comma form `return a, b` / `return x = a, y = b` (no `.( … )`
literal). Consume by destructuring (`a, b := f()`) or single-bind + field access
(`c := f(); c.sum`); a failable bound value holds only the value slots (the error
stays on the `!` channel).
Named return slots are in-scope assignable locals; with no explicit `return` the
implicit return is synthesized from them. Path-sensitive definite-assignment
enforces the must-set rule, and a slot may carry a default that exempts it.
Validation rejects arity mismatches, out-of-slot-order named elements, a
slot/parameter name collision, a comma list from a single-value function, and a
multi-return signature used as a value type.
Examples 0202-0213; readme + specs updated. issues/0197 files a pre-existing
annotated-assignment type-check gap (`x: i32 = "hi"` segfaults) surfaced by the
adversarial review.
