@scriptc/compiler 0.0.32 → 0.0.34

package/dist/frontend/lowering/lower-calls.d.ts

@@ -428,6 +428,7 @@ export declare function spreadNeedsRuntimeArity(shapes: readonly ParamShape[], a
  * is-not-a-function where the kind's prototype lacks the name, and
  * fences LOUDLY on real-but-unimplemented pairs. */
 export declare const DYN_DISPATCH_METHODS: Set<string>;
+export declare function lowerDynDispatchMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr, arrayReceiver: boolean): IrExpr | null;
 /** Radix-free `.toString()` on a PRIMITIVE receiver: numbers take the
    * STATIC JS-exact number formatter — the same `toString` node templates
    * and String(n) lower to (Number::toString with radix 10 IS that

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

@@ -4,7 +4,7 @@
  * generic instantiation (bounded by MAX_GENERIC_INSTANCES). */
 import * as ts from "../ts7/adapter.js";
 import { lowerGenMethodCall } from "./lower-generators.js";
-import { BOOL, CAUGHT, DYN, F64, JSVAL, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, canMarshalTypedFuncIntoIsland, ffiClassType, ffiSourceParamTypes, funcOf, isFfiCallbackParam, isFfiContextParam, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/nodes.js";
+import { BOOL, CAUGHT, DYN, F64, JSVAL, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, canMarshalTypedFuncIntoIsland, ffiClassType, ffiSourceParamTypes, funcOf, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/nodes.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { isGenericCallableMemberType, typeKey } from "../types.js";
 import { PoisonError, dynFallbackType, dynUndefinedExpr, importCallHandleType, jsFuncNameOf, newFnCtx, nodeThrowExpr } from "./lowerer.js";
@@ -931,6 +931,7 @@ export function internGenericInstance(L, blame, info, params, returnType, makeBi
         info.instances.set(key, inst);
         L.instantiationQueue.push({ info, inst });
     }
+    L.noteGenericInstanceDemand(inst);
     return inst;
 }
 /** The type parameters of `info` declared with a `keyof` CONSTRAINT
@@ -2276,7 +2277,11 @@ function ffiSourceParams(binding) {
     return binding.params.filter((param) => !isFfiContextParam(param));
 }
 function ffiParamDisplay(param) {
-    return isFfiCallbackParam(param) ? `callback '${param.callback.id}'` : `class '${param}'`;
+    return isFfiCallbackParam(param)
+        ? `callback '${param.callback.id}'`
+        : isFfiReleaseParam(param)
+            ? `release callback '${param.callback.release}'`
+            : `class '${param}'`;
 }
 /** Callback arguments flow from native code into TypeScript. Their source
  * declarations therefore need to cover the whole scalar domain represented
@@ -2302,12 +2307,23 @@ function ffiCallbackInputDiagnostic(L, descriptor, callbackType) {
             !typeEquals(mapped, ffiClassType(nativeClass))) {
             continue;
         }
-        const domain = nativeClass === "bool" ? "boolean" : "number";
+        if (nativeClass === "bytes")
+            continue;
+        const domain = nativeClass === "bool"
+            ? "boolean"
+            : nativeClass === "cstring" || nativeClass === "string"
+                ? "string"
+                : "number";
         const coversDomain = nativeClass === "bool"
             ? (paramType.flags & ts.TypeFlags.Boolean) !== 0
-            : (paramType.flags & ts.TypeFlags.Number) !== 0;
+            : nativeClass === "cstring" || nativeClass === "string"
+                ? (paramType.flags & ts.TypeFlags.String) !== 0
+                : (paramType.flags & ts.TypeFlags.Number) !== 0;
         if (!coversDomain) {
-            return (`callback '${descriptor.callback.id}' parameter ${i + 1} is '${L.checker.typeToString(paramType)}', ` +
+            const descriptorName = isFfiCallbackParam(descriptor)
+                ? descriptor.callback.id
+                : descriptor.callback.release;
+            return (`callback '${descriptorName}' parameter ${i + 1} is '${L.checker.typeToString(paramType)}', ` +
                 `but native class '${nativeClass}' may supply any ${domain}; declare it as '${domain}'`);
         }
     }
@@ -2379,7 +2395,7 @@ function ffiDeclarationDiagnostic(L, binding, symbol, loc) {
         if ((paramType.flags & ts.TypeFlags.Never) !== 0) {
             return signatureDiag(binding.name, `parameter ${i + 1} is 'never', an uninhabited TypeScript type that cannot describe a native ABI parameter`, loc);
         }
-        if (isFfiCallbackParam(sourceParam)) {
+        if (isFfiCallbackParam(sourceParam) || isFfiReleaseParam(sourceParam)) {
             const callbackDiagnostic = ffiCallbackInputDiagnostic(L, sourceParam, paramType);
             if (callbackDiagnostic !== null) {
                 return signatureDiag(binding.name, callbackDiagnostic, loc);
@@ -2602,7 +2618,45 @@ export function lowerFfiCall(L, expr) {
         signatureError(`this call passes ${expr.arguments.length} argument(s), but the native binding requires exactly ${expectedParams.length}`);
     }
     const expectedReturn = ffiClassType(binding.returns);
-    const args = expr.arguments.map((arg, i) => L.lowerExprExpecting(arg, expectedParams[i]));
+    const sourceParams = ffiSourceParams(binding);
+    const args = expr.arguments.map((arg, i) => {
+        const sourceParam = sourceParams[i];
+        const expected = expectedParams[i];
+        const lowered = L.lowerExprExpecting(arg, expected);
+        // Retained identity is the runtime closure pointer. A coercion adapter
+        // would be freshly allocated at registration and release sites, so an
+        // assignable-but-different function shape (notably `() => number` into
+        // `() => void`) cannot honestly participate in explicit release. The
+        // adapter set comes from the mint sites themselves (Lowerer's
+        // freshClosureAdapters), not name-prefix matching, so a new coercion
+        // helper cannot silently slip past this guard.
+        if (isFfiReleaseParam(sourceParam) ||
+            (isFfiCallbackParam(sourceParam) && sourceParam.callback.lifetime === "retained")) {
+            if (lowered.kind === "dynCheck" ||
+                (lowered.kind === "call" && L.freshClosureAdapters.has(lowered.callee))) {
+                signatureError(`retained callback argument ${i + 1} must have the exact manifest function type; ` +
+                    `an implicit function adapter would change its release identity`);
+            }
+            // An inline function value at a RELEASE site can never match:
+            // lifted lambdas always carry a captures list (even an empty one),
+            // so both backends mint a fresh closure per evaluation of the
+            // expression — the release argument is a pointer no registration
+            // holds, a guaranteed runtime trap. Declared functions stay valid
+            // here — their value is the interned immortal closure (captures
+            // undefined), one pointer for every mention. Registration sites
+            // still accept literals: an unnameable registration is simply
+            // permanent, released by the exit teardown (the live-at-exit
+            // fixture shape), and hides no matching failure.
+            if (isFfiReleaseParam(sourceParam) &&
+                lowered.kind === "closure" &&
+                L.liftedFns.some((f) => f.name === lowered.fnName && f.captures !== undefined)) {
+                signatureError(`retained callback argument ${i + 1} cannot be an inline function value; ` +
+                    `each evaluation creates a fresh closure no registration holds — ` +
+                    `pass the same named value used to register`);
+            }
+        }
+        return lowered;
+    });
     return {
         kind: "ffiCall",
         import: binding.name,
@@ -4155,7 +4209,8 @@ function lowerDynReceiverMethodCall(L, call, access) {
     // take the ordinary typed paths, but there is no static home for an
     // any-elemented array). Typed receivers keep their own lowerings.
     const recvTs = L.typeOf(access.expression);
-    const anyArray = L.checker.isArrayType(recvTs) &&
+    const arrayReceiver = L.checker.isArrayType(recvTs);
+    const anyArray = arrayReceiver &&
         ((L.checker.getTypeArguments(recvTs)[0]?.flags ?? 0) &
             (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
     let recv;
@@ -4234,21 +4289,9 @@ function lowerDynReceiverMethodCall(L, call, access) {
     // unimplemented methods throw a LOUD not-supported Error; names the
     // kind's prototype lacks throw Node's "x.y is not a function"; OBJ
     // receivers call the own member.
-    if (DYN_DISPATCH_METHODS.has(access.name.text) && !call.questionDotToken && !access.questionDotToken) {
-        if (call.arguments.some((a) => ts.isSpreadElement(a))) {
-            L.unsupported("SC1090", call, "spread arguments in calls through 'unknown' values");
-        }
-        const args = call.arguments.map((a) => L.lowerExprExpecting(a, DYN));
-        return {
-            kind: "dynInvoke",
-            recv,
-            method: access.name.text,
-            calleeName: access.getText(),
-            args,
-            type: DYN,
-            loc: locOf(call),
-        };
-    }
+    const dispatched = lowerDynDispatchMethodCall(L, call, access, recv, arrayReceiver);
+    if (dispatched)
+        return dispatched;
     // Names NO dyn-representable prototype declares: the member can only
     // be an OWN property, so "read the member, call it" IS Node's
     // semantics for every possible dyn value — `handlers.onDone(x)` on a
@@ -4359,6 +4402,30 @@ export const DYN_DISPATCH_METHODS = new Set([
     "request", "sendTrailers", "priority", "settings", "goaway", "ping",
     "additionalHeaders", "altsvc", "origin",
 ]);
+export function lowerDynDispatchMethodCall(L, call, access, recv, arrayReceiver) {
+    const method = access.name.text;
+    if (!DYN_DISPATCH_METHODS.has(method) || call.questionDotToken || access.questionDotToken)
+        return null;
+    if (call.arguments.some((arg) => ts.isSpreadElement(arg))) {
+        L.unsupported("SC1090", call, "spread arguments in calls through 'unknown' values");
+    }
+    const predicate = method === "filter" && call.arguments[0]
+        ? L.lowerExpr(call.arguments[0])
+        : null;
+    if (arrayReceiver && predicate?.type.kind === "func" && predicate.type.ret.kind === "void") {
+        L.unsupported("SC1090", call.arguments[0], "'.filter()' with a void-returning predicate (the callback return value is erased before its truthiness can be tested)");
+    }
+    const args = call.arguments.map((arg, i) => i === 0 && predicate ? L.coerceInto(arg, predicate, DYN) : L.lowerExprExpecting(arg, DYN));
+    return {
+        kind: "dynInvoke",
+        recv,
+        method,
+        calleeName: access.getText(),
+        args,
+        type: DYN,
+        loc: locOf(call),
+    };
+}
 /** STR_METHODS ∪ the regex-form names, MINUS everything Array (or any
  * other dyn kind's prototype) also declares. */
 const DYN_STRING_ONLY_METHODS = new Set([
@@ -6343,48 +6410,8 @@ export function recordKeysArrayCall(L, receiver, argIr, shape, loc) {
         helper = `%obj.keys.${L.arrHofHelpers.size}`;
         const ref = { kind: "varRef", localId: "r.0", type: argIr, loc };
         const outRef = { kind: "varRef", localId: "out.0", type: resultT, loc };
-        const body = [
-            { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
-        ];
-        const order = shape.declaredOrder ?? shape.fields.map((f) => f.name);
-        for (const name of order) {
-            const f = shape.fields.find((x) => x.name === name);
-            const pushStmt = {
-                kind: "exprStmt",
-                expr: {
-                    kind: "arrIntrinsic",
-                    method: "push",
-                    receiver: outRef,
-                    args: [{ kind: "strLit", value: f.name, type: STRING, loc }],
-                    type: F64,
-                    loc,
-                },
-                loc,
-            };
-            // Undefined-armed fields: the push is guarded by a tag test (the
-            // key exists exactly when the arm is not undefined).
-            const utag = f.type.kind === "union" ? L.armTag(f.type.unionId, UNDEFINED_T) : -1;
-            body.push(utag >= 0 && f.type.kind === "union"
-                ? {
-                    kind: "if",
-                    cond: {
-                        kind: "unionIsTag",
-                        unionId: f.type.unionId,
-                        tag: utag,
-                        negated: true,
-                        value: { kind: "recordGet", obj: ref, shapeId: argIr.shapeId, field: f.name, type: f.type, loc },
-                        type: BOOL,
-                        loc,
-                    },
-                    then: [pushStmt],
-                    else_: null,
-                    loc,
-                }
-                : pushStmt);
-        }
-        body.push({ kind: "return", value: outRef, loc });
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push({
+        const fn = {
             name: helper,
             params: [{ localId: "r.0", name: "r", type: argIr }],
             returnType: resultT,
@@ -6392,9 +6419,56 @@ export function recordKeysArrayCall(L, receiver, argIr, shape, loc) {
                 { id: "r.0", name: "r", type: argIr, mutable: true },
                 { id: "out.0", name: "out", type: resultT, mutable: false },
             ],
-            body,
+            body: [],
             loc,
-        });
+        };
+        const finalize = () => {
+            const current = L.shapes.get(argIr.shapeId) ?? shape;
+            const body = [
+                { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
+            ];
+            const order = current.declaredOrder ?? current.fields.map((f) => f.name);
+            for (const name of order) {
+                const f = current.fields.find((x) => x.name === name);
+                const pushStmt = {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "arrIntrinsic",
+                        method: "push",
+                        receiver: outRef,
+                        args: [{ kind: "strLit", value: f.name, type: STRING, loc }],
+                        type: F64,
+                        loc,
+                    },
+                    loc,
+                };
+                // Undefined-armed fields: the push is guarded by a tag test (the
+                // key exists exactly when Object.keys would list it).
+                const utag = f.type.kind === "union" ? L.armTag(f.type.unionId, UNDEFINED_T) : -1;
+                body.push(utag >= 0 && f.type.kind === "union"
+                    ? {
+                        kind: "if",
+                        cond: {
+                            kind: "unionIsTag",
+                            unionId: f.type.unionId,
+                            tag: utag,
+                            negated: true,
+                            value: { kind: "recordGet", obj: ref, shapeId: argIr.shapeId, field: f.name, type: f.type, loc },
+                            type: BOOL,
+                            loc,
+                        },
+                        then: [pushStmt],
+                        else_: null,
+                        loc,
+                    }
+                    : pushStmt);
+            }
+            body.push({ kind: "return", value: outRef, loc });
+            fn.body = body;
+        };
+        finalize();
+        L.shapeOrderHelperFinalizers.push(finalize);
+        L.liftedFns.push(fn);
     }
     return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
 }
@@ -7104,109 +7178,15 @@ function lowerObjectStaticCall(L, call, access) {
             L.badType(call, L.typeOf(call));
         valueT = tupleShape.fields.find((f) => f.name === "1").type;
     }
-    const order = shape.declaredOrder ?? shape.fields.map((f) => f.name);
     const key = `obj.${member}:${argIr.shapeId}:${typeKey(resultT)}`;
     let helper = L.arrHofHelpers.get(key);
     if (!helper) {
         helper = `%obj.${member}.${L.arrHofHelpers.size}`;
         const recT = argIr;
         const ref = { kind: "varRef", localId: "r.0", type: recT, loc };
-        const body = [
-            { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
-        ];
         const outRef = { kind: "varRef", localId: "out.0", type: resultT, loc };
-        for (const name of order) {
-            const f = shape.fields.find((x) => x.name === name);
-            const raw = { kind: "recordGet", obj: ref, shapeId: argIr.shapeId, field: f.name, type: f.type, loc };
-            // The pushed element per member; null when the field's value
-            // cannot flow into the result element type.
-            const elemOf = (value, vt) => {
-                if (!valueT)
-                    return null;
-                if (typeEquals(vt, valueT))
-                    return value;
-                if (valueT.kind === "union" && vt.kind !== "union") {
-                    const tag = L.armTag(valueT.unionId, vt);
-                    if (tag >= 0) {
-                        return { kind: "unionWrap", unionId: valueT.unionId, tag, value, type: valueT, loc };
-                    }
-                }
-                return null;
-            };
-            // Undefined-armed fields: the push is guarded by a tag test, and
-            // the pushed value is the narrowed non-undefined arm.
-            let guardUndefTag = null;
-            let value = raw;
-            let vt = f.type;
-            if (f.type.kind === "union") {
-                const undefTag = L.armTag(f.type.unionId, UNDEFINED_T);
-                if (undefTag >= 0) {
-                    guardUndefTag = undefTag;
-                    const arms = L.unions.get(f.type.unionId)?.arms ?? [];
-                    const others = arms.filter((a) => a.kind !== "undefinedT");
-                    if (typeEquals(f.type, valueT ?? f.type)) {
-                        // The field union IS the result union (single-field shapes):
-                        // push the raw box — but then the undefined skip must NOT
-                        // narrow. Handled below via vt === valueT.
-                        value = raw;
-                        vt = f.type;
-                    }
-                    else if (others.length === 1) {
-                        vt = others[0];
-                        // A UNIT other arm (`null | undefined` fields — the mixed-
-                        // defaults spread idiom; undefined was filtered above, so
-                        // the unit is null): units carry no payload, so the guarded
-                        // push writes the unit LITERAL — unionNarrow to a unit arm
-                        // (and unionWrap of a narrowed unit) is malformed IR; the
-                        // literal is the one legal unit spelling.
-                        value = isUnitType(vt)
-                            ? { kind: "unitLit", unit: "null", type: vt, loc }
-                            : { kind: "unionNarrow", unionId: f.type.unionId, tag: L.armTag(f.type.unionId, vt), value: raw, type: vt, loc };
-                    }
-                    else {
-                        L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' is a multi-arm union that ` +
-                            "cannot re-tag into the result element type — read the fields directly)");
-                    }
-                }
-                else if (!typeEquals(f.type, valueT ?? f.type)) {
-                    L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' is a union that cannot ` +
-                        "re-tag into the result element type — read the fields directly)");
-                }
-            }
-            const coerced = elemOf(value, vt);
-            if (!coerced) {
-                L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' of type '${L.fmt(f.type)}' ` +
-                    `cannot flow into the '${L.fmt(valueT)}' result element — read the fields directly)`);
-            }
-            const pushed = member === "values"
-                ? coerced
-                : {
-                    kind: "recordLit",
-                    fields: [
-                        { name: "0", value: { kind: "strLit", value: f.name, type: STRING, loc } },
-                        { name: "1", value: coerced },
-                    ],
-                    type: tupleT,
-                    loc,
-                };
-            const pushStmt = {
-                kind: "exprStmt",
-                expr: { kind: "arrIntrinsic", method: "push", receiver: outRef, args: [pushed], type: F64, loc },
-                loc,
-            };
-            body.push(guardUndefTag !== null && f.type.kind === "union"
-                ? {
-                    kind: "if",
-                    cond: { kind: "unionIsTag", unionId: f.type.unionId, tag: guardUndefTag, negated: true, value: raw, type: BOOL, loc },
-                    then: [pushStmt],
-                    else_: null,
-                    loc,
-                }
-                : pushStmt);
-        }
-        body.push({ kind: "return", value: outRef, loc });
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push({
+        const fn = {
             name: helper,
             params: [{ localId: "r.0", name: "r", type: recT }],
             returnType: resultT,
@@ -7214,9 +7194,110 @@ function lowerObjectStaticCall(L, call, access) {
                 { id: "r.0", name: "r", type: recT, mutable: true },
                 { id: "out.0", name: "out", type: resultT, mutable: false },
             ],
-            body,
+            body: [],
             loc,
-        });
+        };
+        const finalize = () => {
+            const current = L.shapes.get(argIr.shapeId) ?? shape;
+            const body = [
+                { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
+            ];
+            const order = current.declaredOrder ?? current.fields.map((f) => f.name);
+            for (const name of order) {
+                const f = current.fields.find((x) => x.name === name);
+                const raw = { kind: "recordGet", obj: ref, shapeId: argIr.shapeId, field: f.name, type: f.type, loc };
+                // The pushed element per member; null when the field's value
+                // cannot flow into the result element type.
+                const elemOf = (value, vt) => {
+                    if (!valueT)
+                        return null;
+                    if (typeEquals(vt, valueT))
+                        return value;
+                    if (valueT.kind === "union" && vt.kind !== "union") {
+                        const tag = L.armTag(valueT.unionId, vt);
+                        if (tag >= 0) {
+                            return { kind: "unionWrap", unionId: valueT.unionId, tag, value, type: valueT, loc };
+                        }
+                    }
+                    return null;
+                };
+                // Undefined-armed fields: the push is guarded by a tag test, and
+                // the pushed value is the narrowed non-undefined arm.
+                let guardUndefTag = null;
+                let value = raw;
+                let vt = f.type;
+                if (f.type.kind === "union") {
+                    const undefTag = L.armTag(f.type.unionId, UNDEFINED_T);
+                    if (undefTag >= 0) {
+                        guardUndefTag = undefTag;
+                        const arms = L.unions.get(f.type.unionId)?.arms ?? [];
+                        const others = arms.filter((a) => a.kind !== "undefinedT");
+                        if (typeEquals(f.type, valueT ?? f.type)) {
+                            // The field union IS the result union (single-field shapes):
+                            // push the raw box — but then the undefined skip must NOT
+                            // narrow. Handled below via vt === valueT.
+                            value = raw;
+                            vt = f.type;
+                        }
+                        else if (others.length === 1) {
+                            vt = others[0];
+                            // A UNIT other arm (`null | undefined` fields — the mixed-
+                            // defaults spread idiom; undefined was filtered above, so
+                            // the unit is null): units carry no payload, so the guarded
+                            // push writes the unit LITERAL — unionNarrow to a unit arm
+                            // (and unionWrap of a narrowed unit) is malformed IR; the
+                            // literal is the one legal unit spelling.
+                            value = isUnitType(vt)
+                                ? { kind: "unitLit", unit: "null", type: vt, loc }
+                                : { kind: "unionNarrow", unionId: f.type.unionId, tag: L.armTag(f.type.unionId, vt), value: raw, type: vt, loc };
+                        }
+                        else {
+                            L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' is a multi-arm union that ` +
+                                "cannot re-tag into the result element type — read the fields directly)");
+                        }
+                    }
+                    else if (!typeEquals(f.type, valueT ?? f.type)) {
+                        L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' is a union that cannot ` +
+                            "re-tag into the result element type — read the fields directly)");
+                    }
+                }
+                const coerced = elemOf(value, vt);
+                if (!coerced) {
+                    L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' of type '${L.fmt(f.type)}' ` +
+                        `cannot flow into the '${L.fmt(valueT)}' result element — read the fields directly)`);
+                }
+                const pushed = member === "values"
+                    ? coerced
+                    : {
+                        kind: "recordLit",
+                        fields: [
+                            { name: "0", value: { kind: "strLit", value: f.name, type: STRING, loc } },
+                            { name: "1", value: coerced },
+                        ],
+                        type: tupleT,
+                        loc,
+                    };
+                const pushStmt = {
+                    kind: "exprStmt",
+                    expr: { kind: "arrIntrinsic", method: "push", receiver: outRef, args: [pushed], type: F64, loc },
+                    loc,
+                };
+                body.push(guardUndefTag !== null && f.type.kind === "union"
+                    ? {
+                        kind: "if",
+                        cond: { kind: "unionIsTag", unionId: f.type.unionId, tag: guardUndefTag, negated: true, value: raw, type: BOOL, loc },
+                        then: [pushStmt],
+                        else_: null,
+                        loc,
+                    }
+                    : pushStmt);
+            }
+            body.push({ kind: "return", value: outRef, loc });
+            fn.body = body;
+        };
+        finalize();
+        L.shapeOrderHelperFinalizers.push(finalize);
+        L.liftedFns.push(fn);
     }
     return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
 }