[ASDAlexander77]

Fixes the open item from #424: { v?: string } lowered to plain string, so an absent field read as null (or 0) and === undefined was false.

type A = { v?: string, n?: number };
const a: A = {};
print(a.v === undefined, a.n === undefined, a.v, a.n);   // before: false false null 0   after: true true undefined undefined

Changes

• Type literals: a ? member is T | undefined (optional<T>); v?: any stays any. A cast fills a field the source lacks with undefined (absentFieldValue).
• {} given an interface or type-literal type built an undef tuple of every field. An interface's ? members are now left out (absent, so undefined). A type literal with such a field is built by the cast.
• Tuple with ? fields cast to an interface declaring them. Interface fields go through a vtable whose slot holds the field's offset, and the access site reads the interface's T. optional<T> lowers to {T, i1} with the value first, so the matcher accepts an optional<T> field for a ? member T, and the slot points at the value. Whether the value is there is only known at run time, so the cast copies the object into a block with one extra trailing field, .ivtbl. The vtable is patched there: the slot is set to -1 (absent) when the field has no value. The vtable is freed with the block the interface holds; 2,000,000 casts under rc peak at 4 MB.
• Spreading a ? field ({ ...desc.data }) spreads its value, or the type's defaults when absent, which is what it did while the field was a plain T. This fixes 00type_aliases_in_generics.ts, which this change broke at first.

Limitations

• Classes are not changed. class C { v?: string } still reads an unassigned field as null/0. Storing optional<string> there would stop class C implements I { v?: string } from compiling: class-to-interface matching has no patch step, and the vtable reads the storage as T. class C { v: string | undefined } cast to a v?: string interface already fails on main.
• Copy semantics. An object whose ? fields are held as optional<T> is copied when cast to such an interface, and the slot is decided at the cast. For a boxed object literal (one with methods), writes through the interface don't reach the original and later writes to the original aren't seen. On main this case (string | undefined field against a ? member) didn't compile.
• {} against a type literal with a required field is now a compile error ("field ... can't be found"), as in TypeScript; it used to build a silent undef tuple.
• any leniency: a tuple type can't mark a field as ?, so any any-typed field may be absent. type T = { a: any }; const t: T = {} compiles, where TypeScript errors.

Found, not fixed (exists on main)

• let n: number | undefined = undefined; print(n ?? -1) warns invalid cast from 'f64' to '!llvm.ptr'; the result is right.

Tests

• New 00optional_fields.ts (compile + jit): type literal, interface, {}, tuple to interface (present, absent, write, array of interfaces), extends, a literal with a method, spread.
• export_type_alias.ts / import_type_alias.ts get a ? alias across the module boundary (all 7 variants, incl. -shared, rc, none).
• Release suite: 3339/3339 passed.
• DefaultLib (main b67a213) rebuilt release/gc with this compiler: 158/158 compile, 158/158 jit.
• 00optional_fields.ts passes under gc, rc and none. -mm=own stops on own's existing "takes a second reference" limits, not on this change.
• Not run: Debug, x86.

🤖 Generated with Claude Code