[sema] auto-enforce native compiler pitfall rules

[cs01]

Problem

CLAUDE.md lists ~15 "patterns that crash native code" as prose rules. Every contributor must memorize them. Two have been converted to enforced sema passes (or-fallback-checker, type-assertion-checker), but the rest are honor-system.

Rules to enforce

High priority (proven crash classes)

1. alloca for collection structs in class fields — detect alloca %Set, %Map, etc. stored into class fields. Should use GC_malloc. Sema pass or codegen-time check.
2. ObjectArray element access loses type info — arr[i] returns i8*; accessing fields without as NamedType reads garbage. Could warn when fields are accessed on untyped ObjectArray elements.
3. Inline `as { ... }` on opaque source — type-assertion-checker handles named-to-named casts, but `object as { field: string }` bypasses it. Sema pass pending.

Medium priority

4. Arrow functions can't capture `this` — detect arrow functions that reference `this` and emit error
5. Map<object, V> unsupported — detect Map instantiation with non-primitive key types
6. Interface method dispatch broken — warn when calling methods on interface-typed fields (as opposed to class-typed)

Lower priority (rare triggers)

7. Bulk class method additions — detect classes exceeding ~25 methods and warn
8. Missing returns false positive — improve exhaustive switch detection in checkMissingReturns

Approach

Each rule = one sema pass file in src/semantic/, one error fixture in tests/fixtures/errors/. Ship incrementally, one per PR.

Success criteria

Every prose rule in CLAUDE.md "Patterns That Crash" either has an enforced sema pass or is marked as not-yet-reproducible.

[cs01]

Two more sema passes shipped:

• PR [sema] reject arrow functions that capture this #734: Arrow functions can't capture this (item 4) — checkArrowThisCapture in arrow-this-checker.ts
• PR [sema] reject Map<object, V> key type #735: Map<object, V> unsupported (item 5) — extended map-key-checker.ts to reject object key type

Remaining from the list: items 1 (alloca for collections), 2 (ObjectArray element access), 3 (inline as {...} on opaque), 6 (interface method dispatch), 7 (bulk class methods), 8 (missing returns false positive).

[cs01]

Item 1 (alloca for collections in class fields): Already safe. Investigation confirms emitFieldInit() in class.ts uses GC_malloc for all collection struct allocation. The alloca calls in array-allocator/variable-allocator/function-generator are for pointer holders, not structs. No sema pass needed.

[cs01]

Status audit of the rules listed here:

Already enforced (no action needed)

• Site and build fixes #4 Arrow functions can't capture this — arrow-this-checker.ts already catches this
• Add cross compilation support #5 Map<object, V> unsupported — map-key-checker.ts already catches this
• installer updates #1 alloca for collection structs in class fields — codegen already uses GC_malloc for Set/Map/etc. in class fields; verified with synthetic fixture

Still to investigate

• add --target-cpu flag and use x86-64 in ci to fix sigill on runners #2 ObjectArray element access loses type info — needs investigation
• improve install scripts #3 Inline as { ... } on opaque source — type-assertion-checker handles named-to-named; opaque→struct bypass needs investigation
• add subcommand support to argparse and migrate chad-native.ts #6 Interface method dispatch broken — needs investigation
• implement try/catch/finally via setjmp/longjmp #7 Bulk class method additions — rare, low priority
• Add file embedding and multi-column SQLite support #8 Missing returns false positive — rare, low priority

Also merged PR #737 (IIFE/unsupported module check extraction to sema pass) which was part of this effort.

[cs01]

Item #3 (inline as { ... } on opaque source) addressed in PR #747.

Item #6 (interface method dispatch broken): investigated with 3 synthetic fixtures — class field typed as interface, constructor-injected interface, and function parameter typed as interface. All compiled and ran correctly. This appears to be fixed by previous vtable dispatch improvements. No sema pass needed.

Remaining un-enforced items: #2 (ObjectArray element access), #7 (bulk class methods), #8 (missing returns false positive). All are lower priority / rare triggers.

[cs01]

PR #748 merged — item #3 (inline as { ... } on opaque source) is now enforced.

Updated status:

• Done: installer updates #1 (safe by design), improve install scripts #3 (PR [sema] reject inline as { ... } on opaque source types #748), Site and build fixes #4 (arrow-this), Add cross compilation support #5 (map-key), add subcommand support to argparse and migrate chad-native.ts #6 (works, no pass needed)
• Remaining: add --target-cpu flag and use x86-64 in ci to fix sigill on runners #2 (ObjectArray access), implement try/catch/finally via setjmp/longjmp #7 (bulk methods), Add file embedding and multi-column SQLite support #8 (missing returns) — all low priority/rare

[cs01]

Status update: items #3 (opaque inline cast - PR #748), #4 (arrow-this capture), #5 (Map<object,V> key check) are all implemented and enforced via sema passes. Item #6 (interface method dispatch) was investigated and works correctly - not a bug.

Remaining: #1 (alloca for collection structs - codegen already uses GC_malloc per issue comment), #2 (ObjectArray element access), #7 (bulk class methods), #8 (missing returns). All lower priority.

[cs01]

superseded by v2 rewrite — new HIR-based architecture with hybrid unboxed/NaN-boxed types, SWC parser, and LLVM C API codegen