@scriptc/compiler 0.0.5 → 0.0.7

package/dist/frontend/lowering/lower-exprs.js

@@ -1744,10 +1744,25 @@ export function lowerUnitComparison(L, left, right, negated, loc) {
     }
     if (other.type.kind === "union") {
         const tag = L.armTag(other.type.unionId, unit.type);
-        // A union without that unit arm cannot compare equal; tsc rejects
-        // no-overlap comparisons before lowering, so this is defensive.
-        if (tag < 0)
-            return null;
+        if (tag < 0) {
+            // A union WITHOUT that unit arm: legal TS (`miss === null` on a
+            // `number | undefined` — null/undefined guard comparisons are
+            // permitted against nullable-adjacent types), and === never
+            // coerces, so the answer is the constant `negated`. The literal
+            // must NOT flow into the union representation (the unionEq
+            // fallback would coerce it through the stranded-arm trap and
+            // throw where Node answers false). JS still evaluates the
+            // operand, so a non-droppable one (`xs.find(f) === null` — the
+            // callback's effects are observable) rides one throwaway tag
+            // test; droppable reads fold to the bare literal.
+            const answer = { kind: "boolLit", value: negated, type: BOOL, loc };
+            if (droppableStatic(other))
+                return answer;
+            const evalOnce = {
+                kind: "unionIsTag", unionId: other.type.unionId, tag: 0, negated: false, value: other, type: BOOL, loc,
+            };
+            return { kind: "logical", op: negated ? "||" : "&&", left: evalOnce, right: answer, type: BOOL, loc };
+        }
         return {
             kind: "unionIsTag",
             unionId: other.type.unionId,