[ASDAlexander77]

Summary

Fixes the five gaps listed at the end of #422, plus two narrowing bugs found along the way. One commit per fix; each test was seen failing first.

#	Bug	Before
A	n: number | null: n === 2, print(n), if (n)	compile errors (can't cast from 'null' to 's32' / 'string' / 'boolean')
B	p: number[] | null: any read of the array	cast from array type ... is not supported
C	p: { k: number } | null: if (p) p.k	Cast from {k:number} | null to boolean is not supported
D	v: C | number: v === 3	invalid cast from C to s32
E	an optional holding null: s == undefined	false (JS: true)

Changes

• E: loosely, an optional holding null equals undefined (OptionalLogicHelper). For == and !=, when the element type can hold null, a held value is compared with null as well. It is read only when there is one.
• B: the array is read out of a number[] | null (CastLogicHelper). This union has no tag; it is the array struct itself. The lowering's cast to an array went to castToArrayType before unwrapping the union to its base type, as it does for every other target type.
• A (cast) / C: a value type or null is tested for truth, narrowed and read as text (castFromNullableUnion, checkSafeCastBoolean):
  • A tagged union of one member and null is false when it holds null, and its text is "null".
  • if (x) now narrows such a union the way x !== null does. Only the truthy branch is narrowed: the other may hold 0 or "" as well as null.
  • An object literal whose field is s32 now goes into { k: number } | null, because it is cast to the one member.
  • n! reads the member.
• A (equality) / D: a union equals a value when the member it holds does (binaryOpLogicForUnionAndValue). When a union has a member that can't be compared with the value (null, or a class against a number), a generated helper compares the members that can, by typeof. The others count as not equal. A union whose members can all be compared keeps the existing cast path, so number | string === 2 is unchanged.

Found and fixed on the way

• Narrowing from a tagged union to an untagged one read garbage. With strict null checks, string | number | null narrowed by typeof u == "number" leaves string | null, which is the string's own pointer, not a tagged struct. addSafeCastStatement cast between them as if they had the same layout (invalid cast from '!llvm.struct<...>' to '!llvm.ptr'). The value is now read out of the tagged union. This bug predates the branch and affects user code:

  function f(u: string | number | null) { if (typeof u == "number") return 1; return u === "a"; }

• A value narrowed to null is null, also under --di. The else of if (p !== null) on a number[] | null read null out of the union: the array struct cast to a pointer. Only --di kept it alive, and it failed with LLVM Translation failed for operation: builtin.unrealized_conversion_cast. It also predates the branch.

Behaviour changes

• union === value with a member that can't be compared with the value is now false (or true for !==) at run time. It used to be a compile error.
• let x: number = n and n > 1 with n: number | null are still compile errors, as in TypeScript. n! now compiles.

Tests

• New: 00optional_loose_null.ts, 00union_nullable_array.ts, 00union_nullable_value.ts, 00union_value_equality.ts, each registered for compile and JIT.
• Changed: the lowering-error test's trigger moved a third time. number[] | null reads now compile, so it widens a number[] to an any[] parameter instead.
• Release: ctest -C Release 3331/3331.
• Debug (full suite, with --di): 3293/3331. The same 38 tests fail on main (812db3c2) in Debug, so none come from this branch. They fall into these groups:
  • throw/EH with f32 and bigint;
  • try-in-catch-with-finally;
  • the DialectInlinerInterface … promised by dialect 'llvm' but never implemented fatal error in the JIT with --opt;
  • test-bindgen-cli and debug-info-opt hanging on an assert dialog.

Found, not fixed

1. 1 !== true and "a" !== 1 print false. isDefinitelyMismatchedForStrictEquals sets left = (op == !==), right = true, and then runs the op, which computes true !== true.
2. function f(p: string | null) { if (p !== null) return p.length; return -1; } returns 4294967295 for null. The return-type merge picks an unsigned width over the -1 literal.

🤖 Generated with Claude Code