@scriptc/compiler 0.2.6 → 0.2.8

package/dist/backend/llvm/expr-dynamic.js

@@ -1,12 +1,14 @@
 import { classMembershipIntervals } from "./classes.js";
-import { emitBorrowedInput, emitBorrowedInputs } from "./borrowed-inputs.js";
+import { borrowableInputs, emitBorrowedInput, emitBorrowedInputs } from "./borrowed-inputs.js";
 import { preservesDynTest } from "./checked-value-lifetimes.js";
 import { typedRefConstructor } from "./shapes.js";
 /* Focused LLVM expression emission extracted from emitter.ts. */
 import { InternalCompilerError } from "../../errors.js";
+import { emitNullableIsTag, emitNullablePresent } from "./union-repr.js";
+import { isObjectArm } from "./nullable-unions.js";
 import { streamTypedRefEligible } from "../../ir/analysis.js";
 import { DYN, isDynTypedRefType, isRefCounted, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
-import { BYTES_ELEM_NUM } from "./common.js";
+import { BYTES_ELEM_NUM, closureIdentityEqual } from "./common.js";
 import { DYN_KIND } from "./dyn.js";
 import { elemAccess, vAdapters } from "./shapes.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
@@ -248,24 +250,24 @@ export function emitDynamicExpr(host, e) {
             const v = host.emitExpr(e.value);
             if (isRefCounted(arm))
                 host.moveTemp(v);
-            return host.own({ name: host.unionNewOwned(e.tag, v), type: e.type });
+            return host.own({ name: host.unionNewOwned(e.unionId, e.tag, v), type: e.type });
         }
         case "unionNarrow": {
             // Tag-UNCHECKED payload extraction: the frontend emits this only
             // where tsc's control-flow narrowing proved the tag. Ref payloads
             // come out +1. The receiver is consumed before any later expression.
-            const u = host.emitReadReceiver(e.value);
+            const u = host.emitUnionProjection(e.value);
             const arm = e.type;
             if (isUnitType(arm))
                 throw new InternalCompilerError(`llvm emitter bug: unionNarrow to unit arm ${arm.kind}`);
-            const v = host.unionExtract(u.name, arm);
+            const v = host.unionExtract(u.name, e.unionId, arm);
             return host.own({ name: v, type: arm });
         }
         case "unionDisc": {
             // Shared-field read `r.kind`: switch on the runtime tag and read
             // the (same-typed) field from the concretely-typed payload.
             // Ref-counted results come out retained (+1), owned by this frame.
-            const u = host.emitReadReceiver(e.value);
+            const u = host.emitUnionProjection(e.value);
             const def = host.unionsById.get(e.unionId);
             if (!def)
                 throw new InternalCompilerError(`llvm emitter bug: unionDisc of unknown union ${e.unionId}`);
@@ -277,12 +279,21 @@ export function emitDynamicExpr(host, e) {
                 if (arm.kind !== "record" && arm.kind !== "object") {
                     throw new LlvmUnsupportedError(`unionDisc:${arm.kind}`, e.loc);
                 }
-                const payload = host.unionPeek(u.name);
+                const payload = host.unionPeek(u.name, def.id);
                 const { ptr, type } = arm.kind === "object"
                     ? host.classFieldPtr(payload, arm.className, e.field)
                     : host.recordFieldPtr(payload, arm.shapeId, e.field);
-                const v = host.loadField(ptr, type);
-                const value = isRefCounted(e.type) ? host.retainValue(v, e.type) : v;
+                const nullable = arm.kind === "object" ? host.nullableFields.get(arm.className, e.field) : null;
+                const v = arm.kind === "object"
+                    ? host.int32Slots.isField(arm.className, e.field)
+                        ? host.loadInt32Field(ptr, e.type).name
+                        : host.loadField(ptr, type)
+                    : host.loadRecordField(ptr, type);
+                const value = nullable
+                    ? host.nullableToOwnedUnion(v, nullable)
+                    : isRefCounted(e.type)
+                        ? host.retainValue(v, e.type)
+                        : v;
                 B.line(`store ${ty} ${value}, ptr ${slot}`);
                 B.br(join);
             }, host.unionFieldGroups(def, e.field));
@@ -337,7 +348,7 @@ export function emitDynamicExpr(host, e) {
                     // runtime getter answers owned (+1 for ref elements); invalid
                     // indices trap. The result wraps into the join when unit arms
                     // widened it.
-                    const payload = host.unionPeek(u.name);
+                    const payload = host.unionPeek(u.name, def.id);
                     const acc = elemAccess(arm.elem);
                     const accTy = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
                     host.declare(`declare ${acc === "bool" ? "zeroext i1" : accTy} @scr_arr_get_${acc}(ptr, double)`);
@@ -360,18 +371,18 @@ export function emitDynamicExpr(host, e) {
                     }
                     // The element read is already owned (+1) — ownership MOVES
                     // into the union box, no extra retain.
-                    B.line(`store ptr ${host.unionNewOwned(tag, { name: v, type: arm.elem })}, ptr ${slot}`);
+                    B.line(`store ptr ${host.unionNewOwned(e.type.unionId, tag, { name: v, type: arm.elem })}, ptr ${slot}`);
                     B.br(join);
                     return;
                 }
                 if (arm.kind !== "record")
                     throw new LlvmUnsupportedError(`unionKeyGet:${arm.kind}`, e.loc);
                 const shape = host.recordShape(arm.shapeId);
-                const payload = host.unionPeek(u.name);
+                const payload = host.unionPeek(u.name, def.id);
                 const declared = literal !== null ? shape.fields.find((f) => f.name === literal) : undefined;
                 if (declared) {
                     const { ptr, type: ft } = host.recordFieldPtr(payload, arm.shapeId, declared.name);
-                    const v = host.loadField(ptr, ft);
+                    const v = host.loadRecordField(ptr, ft);
                     if (typeEquals(ft, e.type)) {
                         B.line(`store ${ty} ${isRefCounted(ft) ? host.retainValue(v, ft) : v}, ptr ${slot}`);
                         B.br(join);
@@ -388,8 +399,11 @@ export function emitDynamicExpr(host, e) {
                         throw new InternalCompilerError(`llvm emitter bug: unionKeyGet arm answer ${ft.kind} outside the join`);
                     }
                     const wrapped = ft.kind === "f64" || ft.kind === "bool"
-                        ? host.unionNewOwned(tag, { name: v, type: ft })
-                        : host.unionNewOwned(tag, { name: host.retainValue(v, ft), type: ft });
+                        ? host.unionNewOwned(e.type.unionId, tag, { name: v, type: ft })
+                        : host.unionNewOwned(e.type.unionId, tag, {
+                            name: host.retainValue(v, ft),
+                            type: ft,
+                        });
                     B.line(`store ptr ${wrapped}, ptr ${slot}`);
                     B.br(join);
                     return;
@@ -406,9 +420,12 @@ export function emitDynamicExpr(host, e) {
         }
         case "unionIsTag": {
             // A pure tag compare — the box is borrowed, no payload is touched.
-            const u = host.emitReadReceiver(e.value);
-            const tag = host.unionTag(u.name);
+            const u = host.emitUnionProjection(e.value);
+            const nullable = host.nullableUnions.get(e.unionId);
             const t = B.tmp();
+            if (nullable)
+                return { name: emitNullableIsTag(B, nullable, u.name, e.tag, e.negated), type: e.type };
+            const tag = host.unionTag(u.name, e.unionId);
             B.line(`${t} = icmp ${e.negated ? "ne" : "eq"} i32 ${tag}, ${e.tag}`);
             return { name: t, type: e.type };
         }
@@ -477,7 +494,7 @@ export function emitDynamicExpr(host, e) {
                     B.line(`${pv} = getelementptr inbounds i8, ptr ${d.name}, i64 16 ; ->v.str`);
                     const sv = B.tmp();
                     B.line(`${sv} = load ptr, ptr ${pv}`);
-                    B.line(`${eq} = call zeroext i1 @scr_str_eq(ptr ${sv}, ptr ${s.name})`);
+                    B.line(`${eq} = call zeroext i1 @sc_str_eq(ptr ${sv}, ptr ${s.name})`);
                 }
                 else if (st.kind === "f64") {
                     B.line(`${pv} = getelementptr inbounds i8, ptr ${d.name}, i64 16 ; ->v.num`);
@@ -650,19 +667,74 @@ export function emitDynamicExpr(host, e) {
             return { name: neg, type: e.type };
         }
         case "unionEq": {
+            const direct = emitUnionEqWrappedScalar(host, e);
+            if (direct)
+                return direct;
             // Strict equality of the ARM values (tag compare + per-arm payload
             // compare — the C per-union helper, inlined). Both boxes borrowed.
-            const inputs = emitBorrowedInputs(host, [e.left, e.right]);
+            // Stack-representable operands (wrapped literals, optional array
+            // reads, Map.get results) and stack-boxed locals never allocate: the
+            // compare only reads tags and payloads, and each payload has its own
+            // owner, so later operands cannot invalidate an earlier stack box.
+            // A borrowed nullable-pointer field read projects its pointer the
+            // same way; borrowableInputs already proved later operands cannot
+            // replace the field.
+            const operands = [e.left, e.right];
+            const borrowed = borrowableInputs(host, operands);
+            const inputs = operands.map((value, index) => borrowed[index] ||
+                host.isStackUnionSource(value) ||
+                (value.kind === "varRef" && host.isStackUnionLocal(value.localId))
+                ? host.emitUnionProjection(value)
+                : host.emitExpr(value));
             const l = inputs[0], r = inputs[1];
             const def = host.unionsById.get(e.unionId);
             if (!def)
                 throw new InternalCompilerError(`llvm emitter bug: equality of unknown union ${e.unionId}`);
+            const nullable = host.nullableUnions.get(def.id);
+            if (nullable && isObjectArm(nullable)) {
+                // Object identity, and NULL === NULL for the unit arm: one compare.
+                const eq = B.tmp();
+                B.line(`${eq} = icmp ${e.negated ? "ne" : "eq"} ptr ${l.name}, ${r.name}`);
+                return { name: eq, type: e.type };
+            }
+            if (nullable) {
+                // String arm: identical pointers are equal (the same string or the
+                // same unit encoding); otherwise equal only when both hold strings
+                // with the same bytes.
+                const slot = B.slot();
+                B.entryAllocas.push(`${slot} = alloca i1`);
+                const same = B.tmp(), present = B.tmp();
+                B.line(`${same} = icmp eq ptr ${l.name}, ${r.name}`);
+                const lPresent = emitNullablePresent(B, nullable, l.name);
+                const rPresent = emitNullablePresent(B, nullable, r.name);
+                B.line(`${present} = and i1 ${lPresent}, ${rPresent}`);
+                B.line(`store i1 ${same}, ptr ${slot}`);
+                const bytes = B.newLabel("ues.b"), join = B.newLabel("ues.j");
+                const notSame = B.tmp(), go = B.tmp();
+                B.line(`${notSame} = xor i1 ${same}, true`);
+                B.line(`${go} = and i1 ${notSame}, ${present}`);
+                B.condBr(go, bytes, join);
+                B.startBlock(bytes);
+                host.declare(`declare zeroext i1 @scr_str_eq(ptr, ptr)`);
+                const eqBytes = B.tmp();
+                B.line(`${eqBytes} = call zeroext i1 @sc_str_eq(ptr ${l.name}, ptr ${r.name})`);
+                B.line(`store i1 ${eqBytes}, ptr ${slot}`);
+                B.br(join);
+                B.startBlock(join);
+                const eq = B.tmp();
+                B.line(`${eq} = load i1, ptr ${slot}`);
+                if (!e.negated)
+                    return { name: eq, type: e.type };
+                const ne = B.tmp();
+                B.line(`${ne} = xor i1 ${eq}, true`);
+                return { name: ne, type: e.type };
+            }
             const slot = B.slot();
             B.entryAllocas.push(`${slot} = alloca i1`);
             const join = B.newLabel("ue.j");
             const same = B.newLabel("ue.s");
-            const ltag = host.unionTag(l.name);
-            const rtag = host.unionTag(r.name);
+            const ltag = host.unionTag(l.name, def.id);
+            const rtag = host.unionTag(r.name, def.id);
             const tagEq = B.tmp();
             B.line(`${tagEq} = icmp eq i32 ${ltag}, ${rtag}`);
             B.line(`store i1 false, ptr ${slot}`);
@@ -675,12 +747,9 @@ export function emitDynamicExpr(host, e) {
                         B.line(`store i1 true, ptr ${slot}`);
                         break;
                     case "f64": {
-                        host.declare(`declare double @scr_union_get_f64(ptr)`);
-                        const a = B.tmp();
-                        const b = B.tmp();
+                        const a = host.unionGetF64(l.name);
+                        const b = host.unionGetF64(r.name);
                         const t = B.tmp();
-                        B.line(`${a} = call double @scr_union_get_f64(ptr ${l.name})`);
-                        B.line(`${b} = call double @scr_union_get_f64(ptr ${r.name})`);
                         if (e.sameValue) {
                             // Object.is's f64 compare: NaN equals NaN, +0 differs
                             // from -0 — the runtime SameValue.
@@ -694,29 +763,26 @@ export function emitDynamicExpr(host, e) {
                         break;
                     }
                     case "bool": {
-                        host.declare(`declare zeroext i1 @scr_union_get_bool(ptr)`);
-                        const a = B.tmp();
-                        const b = B.tmp();
+                        const a = host.unionGetBool(l.name);
+                        const b = host.unionGetBool(r.name);
                         const t = B.tmp();
-                        B.line(`${a} = call zeroext i1 @scr_union_get_bool(ptr ${l.name})`);
-                        B.line(`${b} = call zeroext i1 @scr_union_get_bool(ptr ${r.name})`);
                         B.line(`${t} = icmp eq i1 ${a}, ${b}`);
                         B.line(`store i1 ${t}, ptr ${slot}`);
                         break;
                     }
                     case "string": {
                         host.declare(`declare zeroext i1 @scr_str_eq(ptr, ptr)`);
-                        const a = host.unionPeek(l.name);
-                        const b = host.unionPeek(r.name);
+                        const a = host.unionPeek(l.name, def.id);
+                        const b = host.unionPeek(r.name, def.id);
                         const t = B.tmp();
-                        B.line(`${t} = call zeroext i1 @scr_str_eq(ptr ${a}, ptr ${b})`);
+                        B.line(`${t} = call zeroext i1 @sc_str_eq(ptr ${a}, ptr ${b})`);
                         B.line(`store i1 ${t}, ptr ${slot}`);
                         break;
                     }
                     case "bigint": {
                         host.declare(`declare zeroext i1 @scr_bigint_eq(ptr, ptr)`);
-                        const a = host.unionPeek(l.name);
-                        const b = host.unionPeek(r.name);
+                        const a = host.unionPeek(l.name, def.id);
+                        const b = host.unionPeek(r.name, def.id);
                         const t = B.tmp();
                         B.line(`${t} = call zeroext i1 @scr_bigint_eq(ptr ${a}, ptr ${b})`);
                         B.line(`store i1 ${t}, ptr ${slot}`);
@@ -724,10 +790,14 @@ export function emitDynamicExpr(host, e) {
                     }
                     default: {
                         // Ref arms: pointer identity, exactly JS object equality.
-                        const a = host.unionPeek(l.name);
-                        const b = host.unionPeek(r.name);
+                        // Function arms compare identity roots (adapters included).
+                        const a = host.unionPeek(l.name, def.id);
+                        const b = host.unionPeek(r.name, def.id);
                         const t = B.tmp();
-                        B.line(`${t} = icmp eq ptr ${a}, ${b} ; ${arm.kind}`);
+                        if (arm.kind === "func")
+                            B.line(`${t} = ${closureIdentityEqual(host, a, b)}`);
+                        else
+                            B.line(`${t} = icmp eq ptr ${a}, ${b} ; ${arm.kind}`);
                         B.line(`store i1 ${t}, ptr ${slot}`);
                         break;
                     }
@@ -746,14 +816,26 @@ export function emitDynamicExpr(host, e) {
         case "unionFuncEq": {
             const inputs = emitBorrowedInputs(host, [e.union, e.func]);
             const u = inputs[0], f = inputs[1];
-            const tag = host.unionTag(u.name);
+            const tag = host.unionTag(u.name, e.unionId);
             const tagMatch = B.tmp();
             B.line(`${tagMatch} = icmp eq i32 ${tag}, ${e.tag}`);
-            const payload = host.unionPeek(u.name);
-            const ptrMatch = B.tmp();
-            B.line(`${ptrMatch} = icmp eq ptr ${payload}, ${f.name}`);
+            // The payload is a closure only under the function tag; another
+            // arm's payload must never be read as one.
+            const slot = B.slot();
+            B.entryAllocas.push(`${slot} = alloca i1`);
+            B.line(`store i1 false, ptr ${slot}`);
+            const check = B.newLabel("ufe.c");
+            const join = B.newLabel("ufe.j");
+            B.condBr(tagMatch, check, join);
+            B.startBlock(check);
+            const payload = host.unionPeek(u.name, e.unionId);
+            const identical = B.tmp();
+            B.line(`${identical} = ${closureIdentityEqual(host, payload, f.name)}`);
+            B.line(`store i1 ${identical}, ptr ${slot}`);
+            B.br(join);
+            B.startBlock(join);
             const result = B.tmp();
-            B.line(`${result} = and i1 ${tagMatch}, ${ptrMatch}`);
+            B.line(`${result} = load i1, ptr ${slot}`);
             if (!e.negated)
                 return host.own({ name: result, type: e.type });
             const negated = B.tmp();
@@ -768,6 +850,38 @@ export function emitDynamicExpr(host, e) {
             const c = host.emitReadReceiver(e.value);
             if (e.test === "instanceof") {
                 const target = host.classMetaOf(e.className);
+                if (!target.hierarchy) {
+                    // Standalone class payloads have no vtable word. Their retain
+                    // adapter identifies the exact native layout in the snapshot.
+                    const adapterSlot = B.tmp();
+                    const adapter = B.tmp();
+                    B.line(`${adapterSlot} = getelementptr inbounds %ScrCaught, ptr ${c.name}, i64 0, i32 5`);
+                    B.line(`${adapter} = load ptr, ptr ${adapterSlot}`);
+                    let result;
+                    const intervals = classMembershipIntervals(host.classMeta, target.def.name);
+                    for (const candidate of host.classMeta.values()) {
+                        if (candidate.hierarchy ||
+                            !intervals.some((range) => range.pre <= candidate.pre && candidate.pre <= range.post))
+                            continue;
+                        const rc = vAdapters(host.shapeHost, { kind: "object", className: candidate.def.name });
+                        const matches = B.tmp();
+                        B.line(`${matches} = icmp eq ptr ${adapter}, ${rc.retain}`);
+                        if (result === undefined)
+                            result = matches;
+                        else {
+                            const joined = B.tmp();
+                            B.line(`${joined} = or i1 ${result}, ${matches}`);
+                            result = joined;
+                        }
+                    }
+                    if (result === undefined)
+                        throw new InternalCompilerError("empty standalone class membership");
+                    if (e.negated !== true)
+                        return { name: result, type: e.type };
+                    const negated = B.tmp();
+                    B.line(`${negated} = xor i1 ${result}, true`);
+                    return { name: negated, type: e.type };
+                }
                 host.declare(`declare zeroext i1 @scr_caught_instanceof(ptr, ${host.sizeType}, ${host.sizeType})`);
                 let t;
                 for (const interval of classMembershipIntervals(host.classMeta, target.def.name)) {
@@ -901,4 +1015,90 @@ export function emitDynamicExpr(host, e) {
         }
     }
 }
+/** `u === v` where one side wraps a unit, bool, or number arm value
+ * (`o.flag === true`, `o.n === undefined`): compare the other union's tag
+ * and payload directly instead of boxing the plain side. Operands keep
+ * their left-to-right evaluation; the union stays borrowed. Null when
+ * neither side is such a wrap. */
+function emitUnionEqWrappedScalar(host, e) {
+    const B = host.B;
+    const def = host.unionsById.get(e.unionId);
+    if (!def)
+        return null;
+    const scalarWrap = (x) => {
+        if (x.kind !== "unionWrap" || x.unionId !== e.unionId)
+            return null;
+        const arm = def.arms[x.tag];
+        if (!arm)
+            return null;
+        if (isUnitType(arm))
+            return x;
+        // The plain value must not run code that could release the borrowed
+        // union: literals and local reads only.
+        const v = x.value;
+        const pure = v.kind === "boolLit" || v.kind === "numLit" || v.kind === "varRef";
+        return pure && (arm.kind === "f64" || arm.kind === "bool") ? x : null;
+    };
+    const rightWrap = scalarWrap(e.right);
+    const leftWrap = rightWrap ? null : scalarWrap(e.left);
+    const wrap = rightWrap ?? leftWrap;
+    if (!wrap)
+        return null;
+    const arm = def.arms[wrap.tag];
+    let union;
+    let plain = null;
+    const unionInput = (value) => host.canStackReceiver(value) ? host.emitReadReceiver(value) : emitBorrowedInput(host, value);
+    if (rightWrap) {
+        union = unionInput(e.left);
+        if (!isUnitType(arm))
+            plain = host.emitExpr(wrap.value);
+    }
+    else {
+        if (!isUnitType(arm))
+            plain = host.emitExpr(wrap.value);
+        union = unionInput(e.right);
+    }
+    const tag = host.unionTag(union.name, e.unionId);
+    const tagMatch = B.tmp();
+    B.line(`${tagMatch} = icmp eq i32 ${tag}, ${wrap.tag}`);
+    let result = tagMatch;
+    if (plain) {
+        const slot = B.slot();
+        B.entryAllocas.push(`${slot} = alloca i1`);
+        B.line(`store i1 false, ptr ${slot}`);
+        const same = B.newLabel("ueq.s");
+        const join = B.newLabel("ueq.j");
+        B.condBr(tagMatch, same, join);
+        B.startBlock(same);
+        const eq = B.tmp();
+        if (arm.kind === "f64") {
+            host.declare(`declare double @scr_union_get_f64(ptr)`);
+            const v = B.tmp();
+            B.line(`${v} = call double @scr_union_get_f64(ptr ${union.name})`);
+            if (e.sameValue) {
+                host.declare(`declare zeroext i1 @scr_num_same_value(double, double)`);
+                B.line(`${eq} = call zeroext i1 @scr_num_same_value(double ${v}, double ${plain.name})`);
+            }
+            else {
+                B.line(`${eq} = fcmp oeq double ${v}, ${plain.name}`);
+            }
+        }
+        else {
+            host.declare(`declare zeroext i1 @scr_union_get_bool(ptr)`);
+            const v = B.tmp();
+            B.line(`${v} = call zeroext i1 @scr_union_get_bool(ptr ${union.name})`);
+            B.line(`${eq} = icmp eq i1 ${v}, ${plain.name}`);
+        }
+        B.line(`store i1 ${eq}, ptr ${slot}`);
+        B.br(join);
+        B.startBlock(join);
+        result = B.tmp();
+        B.line(`${result} = load i1, ptr ${slot}`);
+    }
+    if (!e.negated)
+        return { name: result, type: e.type };
+    const negated = B.tmp();
+    B.line(`${negated} = xor i1 ${result}, true`);
+    return { name: negated, type: e.type };
+}
 //# sourceMappingURL=expr-dynamic.js.map