@scriptc/compiler 0.4.1 → 0.4.3

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

@@ -2,30 +2,34 @@
 import { arraySearchHelperName, arraySearchKind } from "./array-search.js";
 import { InternalCompilerError } from "../../errors.js";
 import { isStableReceiverOperand, undefinedArmTag } from "../../ir/analysis.js";
-import { isRefCounted, typeEquals, typeKey } from "../../ir/ir.js";
+import { F64, isRefCounted, typeEquals, typeKey } from "../../ir/ir.js";
 import { mangleResolveThunk } from "../mangle.js";
 import { arrOps, elemAccess, FN_ATTRS, mapKeyAccess, mapKeyKindNum, mapKeyParamType, mapValKindNum, traceArg, vAdapters, } from "./shapes.js";
 import { F64_INF, f64Lit, loadArrCount, sizeToDouble } from "./common.js";
 import { MUTATING_COLLECTION_METHODS } from "../publication.js";
 import { borrowsStringInputs, emitStringInputs } from "./string-lifetimes.js";
 import { emitMapLookupKey, borrowsMapReadInputs, borrowsMapMutationReceiver, inlineNumberKey, entryStringKey, } from "./map-read-lifetimes.js";
-import { emitMapIterCount, emitMapIterEntry, emitMapIterSlot, mapEntryLayout, emitMapIterStart, emitNumberMapGetRef, emitNumberMapGetScalar, emitNumberMapHas, emitNumberMapSetScalar, emitStringMapGetRef, emitStringMapGetScalar, emitStringMapHas, } from "./map-number-lookup.js";
+import { emitMapIterCount, emitMapIterEntry, emitMapIterSlot, compactMapValues, mapEntryLayout, emitMapIterStart, emitMapSize, emitNumberMapGetRef, emitNumberMapGetScalar, emitNumberMapHas, emitNumberMapSetScalar, emitStringMapGetRef, emitStringMapGetScalar, emitStringMapHas, } from "./map-number-lookup.js";
 import { emitBorrowedInput } from "./borrowed-inputs.js";
 import { emitFusedMapSet, rememberMapEntry } from "./map-entry-fusion.js";
 import { emitScratchStringSlice, emitStringSliceRead } from "./string-slices.js";
-import { STRING_CHAR_CODE_AT_DECL, STRING_CHAR_CODE_AT_INT_MARKER, STRING_UTF16_LEN_DECL, } from "./string-reads.js";
+import { STRING_CHAR_AT_DECL, STRING_CHAR_AT_INT_MARKER, STRING_CHAR_CODE_AT_DECL, STRING_CHAR_CODE_AT_INT_MARKER, emitAsciiChar, emitAsciiCharCode, STRING_UTF16_LEN_DECL, } from "./string-reads.js";
 import { exactInteger, widenInteger } from "./integer-values.js";
-import { emitDenseArrayNumber, emitDenseArrayPop, emitDenseArrayPush, } from "./dense-array-access.js";
+import { emitDenseArrayNumber, emitDenseArrayPop, emitDenseArrayPush, runtimeAccess, } from "./dense-array-access.js";
+import { INT32_ARRAY_METHODS } from "../../ir/int32-arrays.js";
 import { emitUnionWiden } from "./expr-records.js";
+import { registerReplay } from "./emit-journal.js";
 export function resolveThunkFor(host, inner) {
     const key = typeKey(inner);
     let sym = host.resolveThunks.get(key);
     if (!sym) {
         sym = mangleResolveThunk(host.resolveThunks.size);
         host.resolveThunks.set(key, sym);
+        host.journal?.allocated(sym, "resolveThunkFor", [inner]);
         const v = vAdapters(host.shapeHost, inner);
         host.declare(`declare void @scr_resolve_ref_impl(ptr, ptr, ptr, ptr, ptr)`);
         host.resolveThunkDefs.push(`define internal void @${sym}(ptr %self, ptr %v) ${FN_ATTRS} { ; resolve<${key}>`, `entry:`, `  call void @scr_resolve_ref_impl(ptr %self, ptr %v, ptr ${v.retain}, ptr ${v.release}, ptr ${traceArg(host.shapeHost, inner)})`, `  ret void`, `}`, ``);
+        host.journal?.built();
     }
     return sym;
 }
@@ -47,11 +51,14 @@ export function tagInSet(host, uName, unionId, tags) {
     }
     return acc;
 }
-export function arrPush(host, arr, acc, value) {
-    return emitDenseArrayPush(host, arr, acc, value);
+/** `element`: the array's element type, or null for arrays whose
+ * elements are not compact class references (dense-array-access.ts
+ * slotKind). */
+export function arrPush(host, arr, acc, value, element) {
+    return emitDenseArrayPush(host, arr, acc, element, value);
 }
 /** Move evaluated values through one bounded slot buffer per call site. */
-export function emitArrayValues(host, arr, acc, values, prepend = false, sharedBuffer) {
+export function emitArrayValues(host, arr, acc, element, values, prepend = false, sharedBuffer) {
     const B = host.B;
     if (acc === "ref")
         values.forEach((value) => host.toHeap(value));
@@ -63,11 +70,12 @@ export function emitArrayValues(host, arr, acc, values, prepend = false, sharedB
     }
     if (values.length === 1) {
         if (!prepend)
-            return arrPush(host, arr, acc, values[0].name);
-        const ty = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
-        host.declare(`declare double @scr_arr_unshift_${acc}(ptr, ${ty}${acc === "bool" ? " zeroext" : ""})`);
+            return arrPush(host, arr, acc, values[0].name, element);
+        const flat = runtimeAccess(acc);
+        const ty = flat === "f64" ? "double" : flat === "bool" ? "i1" : "ptr";
+        host.declare(`declare double @scr_arr_unshift_${flat}(ptr, ${ty}${flat === "bool" ? " zeroext" : ""})`);
         const result = B.tmp();
-        B.line(`${result} = call double @scr_arr_unshift_${acc}(ptr ${arr}, ${ty} ${values[0].name})`);
+        B.line(`${result} = call double @scr_arr_unshift_${flat}(ptr ${arr}, ${ty} ${values[0].name})`);
         return result;
     }
     const capacity = Math.min(values.length, 64);
@@ -85,7 +93,8 @@ export function emitArrayValues(host, arr, acc, values, prepend = false, sharedB
         for (let i = 0; i < count; i++) {
             const slot = B.tmp(), pointer = B.tmp();
             const value = values[start + i].name;
-            const pack = acc === "f64"
+            // The runtime takes double bits for int32 arrays too, and converts.
+            const pack = acc === "f64" || acc === "i32"
                 ? `bitcast double ${value} to i64`
                 : acc === "bool"
                     ? `zext i1 ${value} to i64`
@@ -169,6 +178,9 @@ function emitDiscarded(host, e) {
     const start = host.emitExpr(e.args[0]);
     const count = e.args[1] ? host.emitExpr(e.args[1]).name : F64_INF;
     const values = items.map((item) => host.emitExpr(item));
+    // Before the values move into the buffer: a throw releases them with the
+    // frame.
+    host.emitPublishedArrayGuard(r.name, e.receiver.type, 10, start.name, count, f64Lit(values.length));
     if (acc === "ref")
         values.forEach((value) => host.toHeap(value));
     let buffer = "null";
@@ -195,6 +207,29 @@ export function emitArrayCopyLoop(host, dst, src, acc) {
     host.declare(`declare double @scr_arr_push_spread(ptr, ptr)`);
     host.B.line(`call double @scr_arr_push_spread(ptr ${dst}, ptr ${src})`);
 }
+/** `s.charCodeAt(i)` in place of `s.charAt(i)`, the same index read as a
+ * code unit. The emitter records the charAt it stands for
+ * (charAtUnitReads), so a loop version's proof for the charAt covers it. */
+export function charAtUnitRead(host, charAt) {
+    const read = {
+        kind: "strIntrinsic",
+        method: "charCodeAt",
+        receiver: charAt.receiver,
+        args: charAt.args,
+        type: F64,
+        loc: charAt.loc,
+    };
+    host.charAtUnitReads.set(read, charAt);
+    return read;
+}
+/** An enclosing loop version proved the string of `e` ASCII and its index
+ * below the length (bytes-loop-versions.ts). */
+function provenStringRead(host, e) {
+    if (host.bytesBounds.has(e))
+        return true;
+    const origin = host.charAtUnitReads.get(e);
+    return origin !== undefined && host.bytesBounds.has(origin);
+}
 export function emitStrIntrinsic(host, e) {
     // String/array-returning methods hand back a +1 reference, including
     // identity returns. Inputs keep either a proven owner or a frame temp.
@@ -233,16 +268,35 @@ export function emitStrIntrinsic(host, e) {
             const t = B.tmp();
             const index = e.args[0] ? exactInteger(host, args[0], e.args[0]) : null;
             if (index) {
-                host.declare(STRING_CHAR_CODE_AT_INT_MARKER);
                 const wide = widenInteger(host, index);
+                if (provenStringRead(host, e))
+                    return { name: emitAsciiCharCode(host, r.name, wide), type: e.type };
+                host.declare(STRING_CHAR_CODE_AT_INT_MARKER);
                 B.line(`${t} = call double @sc_str_char_code_at_int(ptr ${r.name}, i64 ${wide})`);
                 return { name: t, type: e.type };
             }
             B.line(`${t} = call double @sc_str_char_code_at(ptr ${r.name}, double ${args[0].name})`);
             return { name: t, type: e.type };
         }
-        case "charAt":
-            return call("scr_str_char_at", "ptr (ptr, double)", `ptr ${r.name}, double ${args[0].name}`, "ptr", true);
+        case "charAt": {
+            // sc_str_char_at (string-reads.ts) answers proven-ASCII strings inline.
+            host.declare(STRING_CHAR_AT_DECL);
+            const t = B.tmp();
+            const index = e.args[0] ? exactInteger(host, args[0], e.args[0]) : null;
+            if (index) {
+                const wide = widenInteger(host, index);
+                // The table entry is immortal: nothing owns it.
+                if (provenStringRead(host, e))
+                    return host.markImmortal({ name: emitAsciiChar(host, r.name, wide), type: e.type });
+                host.declare(STRING_CHAR_AT_INT_MARKER);
+                B.line(`${t} = call ptr @sc_str_char_at_int(ptr ${r.name}, i64 ${wide})`);
+            }
+            else {
+                const at = args[0]?.name ?? f64Lit(0);
+                B.line(`${t} = call ptr @sc_str_char_at(ptr ${r.name}, double ${at})`);
+            }
+            return host.own({ name: t, type: e.type });
+        }
         case "indexOf":
             return call("scr_str_index_of", "double (ptr, ptr, double)", `ptr ${r.name}, ptr ${args[0].name}, double ${args[1]?.name ?? f64Lit(0)}`, "double", false);
         case "includes": {
@@ -359,7 +413,15 @@ into) {
     if (e.receiver.type.kind !== "array")
         throw new InternalCompilerError("llvm emitter bug: arrIntrinsic on non-array");
     const elem = e.receiver.type.elem;
-    const acc = elemAccess(elem);
+    // Int32 arrays (ir/int32-arrays.ts) reach only these methods; the others
+    // take the runtime family's flat access. One with checked stores tests
+    // its kind at each inline access (emitByElementKind) and otherwise takes
+    // the double entry points, which serve both kinds.
+    const checked = host.checkedInt32Array(e.receiver);
+    const access = checked ? "f64" : host.arrayAccess(e.receiver, elem);
+    if ((access === "i32" || checked) && !INT32_ARRAY_METHODS.has(e.method))
+        throw new InternalCompilerError(`llvm emitter bug: ${e.method} on an int32 array`);
+    const acc = runtimeAccess(access);
     const accTy = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
     const accArg = acc === "bool" ? "i1 zeroext" : accTy;
     const method = e.method;
@@ -377,9 +439,14 @@ into) {
             const table = e.receiver.kind === "varRef"
                 ? host.constantNumericTables.get(e.receiver.localId)
                 : undefined;
+            if (!table && elem.kind === "f64" && checked) {
+                const proven = host.provenDenseIndex(e.receiver, e.args[0]);
+                const value = host.emitByElementKind(r.name, "double", (kind) => emitDenseArrayNumber(host, r.name, index, e.args[0], proven, kind));
+                return { name: value, type: e.type };
+            }
             if (!table && elem.kind === "f64")
                 return {
-                    name: emitDenseArrayNumber(host, r.name, index, e.args[0], host.provenDenseIndex(e.receiver, e.args[0])),
+                    name: emitDenseArrayNumber(host, r.name, index, e.args[0], host.provenDenseIndex(e.receiver, e.args[0]), access === "i32" ? "i32" : "f64"),
                     type: e.type,
                 };
             host.declare(`declare double @scr_arr_get_number(ptr, double)`);
@@ -411,7 +478,23 @@ into) {
             // no-op zero-argument call.
             const vs = e.args.map((a) => host.emitExpr(a));
             host.emitPublishedArrayGuard(r.name, e.receiver.type, 1, f64Lit(0), f64Lit(vs.length));
-            return { name: emitArrayValues(host, r.name, acc, vs), type: e.type };
+            if (checked && vs.length > 0) {
+                // Each value appends in its own kind test: one that is not an int32
+                // widens the array before it is pushed.
+                let length = "";
+                vs.forEach((v, i) => {
+                    length = host.emitByElementKind(r.name, "double", (kind, widened) => {
+                        if (kind === "i32")
+                            host.emitCheckedInt32Store(r.name, v.name, e.args[i], widened);
+                        return arrPush(host, r.name, kind, v.name, elem);
+                    });
+                });
+                return { name: length, type: e.type };
+            }
+            // In an int32 kind loop's fast copy, every value is checked before
+            // the first appends.
+            vs.forEach((v, i) => host.emitInt32KindStoreCheck(e.receiver, v, e.args[i]));
+            return { name: emitArrayValues(host, r.name, access, elem, vs), type: e.type };
         }
         case "pushSpread": {
             // `a.push(...src)`: append src's elements in order (borrowed src,
@@ -430,10 +513,12 @@ into) {
             return { name: t, type: e.type };
         }
         case "concatSpread": {
+            // Appends to concat's fresh result: its storage grows to exactly
+            // the combined length (scr_arr_concat_copy_exact).
             const src = emitBorrowedInput(host, e.args[0]);
-            host.declare(`declare double @scr_arr_concat_copy(ptr, ptr)`);
+            host.declare(`declare double @scr_arr_concat_copy_exact(ptr, ptr)`);
             const t = B.tmp();
-            B.line(`${t} = call double @scr_arr_concat_copy(ptr ${r.name}, ptr ${src.name})`);
+            B.line(`${t} = call double @scr_arr_concat_copy_exact(ptr ${r.name}, ptr ${src.name})`);
             return { name: t, type: e.type };
         }
         case "unshift": {
@@ -441,7 +526,7 @@ into) {
             // from right to left so the final front order is source order.
             const vs = e.args.map((a) => host.emitExpr(a));
             host.emitPublishedArrayGuard(r.name, e.receiver.type, 4, f64Lit(0), f64Lit(vs.length));
-            return { name: emitArrayValues(host, r.name, acc, vs, true), type: e.type };
+            return { name: emitArrayValues(host, r.name, acc, elem, vs, true), type: e.type };
         }
         case "unshiftSpread": {
             // The runtime snapshots the borrowed source and handles self-spread.
@@ -483,7 +568,10 @@ into) {
             let slowLabel = "";
             if (method === "pop") {
                 slowLabel = B.newLabel("remove.slow");
-                denseRaw = emitDenseArrayPop(host, r.name, acc, la, slowLabel);
+                const empty = la, slow = slowLabel;
+                denseRaw = checked
+                    ? host.emitByElementKind(r.name, "i64", (kind) => emitDenseArrayPop(host, r.name, kind, elem, empty, slow))
+                    : emitDenseArrayPop(host, r.name, access, elem, la, slowLabel);
                 denseLabel = B.currentLabel();
                 B.br(lp);
                 B.startBlock(slowLabel);
@@ -552,7 +640,7 @@ into) {
             // by content, everything else by pointer). Strict equality. Arrays of
             // objects and strings scan inline (array-search.ts).
             const v = host.emitExpr(e.args[0]);
-            const search = acc === "ref" ? arraySearchKind(elem) : null;
+            const search = acc === "ref" ? arraySearchKind(elem, host.compactArrayElem(elem)) : null;
             if (search !== null) {
                 host.arraySearchKinds.add(search);
                 const t = B.tmp();
@@ -568,7 +656,7 @@ into) {
             // Borrowed needle, SameValueZero (NaN matches NaN). For the inline
             // searches SameValueZero is strict equality.
             const v = host.emitExpr(e.args[0]);
-            const search = acc === "ref" ? arraySearchKind(elem) : null;
+            const search = acc === "ref" ? arraySearchKind(elem, host.compactArrayElem(elem)) : null;
             if (search !== null) {
                 host.arraySearchKinds.add(search);
                 const at = B.tmp(), t = B.tmp();
@@ -661,7 +749,20 @@ into) {
         case "fill":
         case "fillUndefined": {
             const args = e.args.map((arg) => host.emitExpr(arg));
-            host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
+            // fill's range is its last two arguments; copyWithin's target,
+            // start and end are its three.
+            if (e.method === "copyWithin")
+                host.emitPublishedArrayGuard(r.name, e.receiver.type, 9, args[0].name, args[1].name, args[2].name);
+            else
+                host.emitPublishedArrayGuard(r.name, e.receiver.type, 8, args[args.length - 2].name, args[args.length - 1].name);
+            if (host.checkedFills.has(e)) {
+                // A new int32 array with checked stores, filled with a value that
+                // may not be an int32: widen it first then.
+                const filled = B.newLabel("arr.fill.kind");
+                host.emitCheckedInt32Store(r.name, args[0].name, e.args[0], filled);
+                B.br(filled);
+                B.startBlock(filled);
+            }
             const helper = e.method === "copyWithin"
                 ? "scr_arr_copy_within"
                 : e.method === "fillUndefined"
@@ -710,7 +811,7 @@ into) {
             // removes to the end (+Infinity, the slice convention).
             const start = host.emitExpr(e.args[0]);
             const cnt = e.args[1] ? host.emitExpr(e.args[1]).name : F64_INF;
-            host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
+            host.emitPublishedArrayGuard(r.name, e.receiver.type, 10, start.name, cnt, f64Lit(0));
             host.declare(`declare ptr @scr_arr_splice(ptr, double, double)`);
             const t = B.tmp();
             B.line(`${t} = call ptr @scr_arr_splice(ptr ${r.name}, double ${start.name}, double ${cnt})`);
@@ -720,7 +821,12 @@ into) {
             const start = host.emitExpr(e.args[0]);
             const count = host.emitExpr(e.args[1]);
             const items = emitBorrowedInput(host, e.args[2]);
-            host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
+            if (host.publishedTypes?.containerGuarded(e.receiver.type) === true) {
+                host.declare(`declare double @scr_arr_len(ptr)`);
+                const n = B.tmp();
+                B.line(`${n} = call double @scr_arr_len(ptr ${items.name})`);
+                host.emitPublishedArrayGuard(r.name, e.receiver.type, 10, start.name, count.name, n);
+            }
             host.declare(`declare ptr @scr_arr_splice_insert(ptr, double, double, ptr)`);
             const t = B.tmp();
             B.line(`${t} = call ptr @scr_arr_splice_insert(ptr ${r.name}, double ${start.name}, double ${count.name}, ptr ${items.name})`);
@@ -807,7 +913,9 @@ function newCollection(host, key, value) {
     const kind = mapKeyKindNum(key, arms);
     const m = B.tmp();
     host.declare(`declare ptr @scr_map_new(i32, i32, ptr)`);
-    B.line(`${m} = call ptr @scr_map_new(i32 ${kind}, i32 ${mapValKindNum(value)}, ptr ${collectionOps(host, key, value)})`);
+    // SCR_MAP_VAL_CREF (3): string keys and compact values (compactMapValues).
+    const valKind = compactMapValues(host, key, value) ? 3 : mapValKindNum(value);
+    B.line(`${m} = call ptr @scr_map_new(i32 ${kind}, i32 ${valKind}, ptr ${collectionOps(host, key, value)})`);
     return m;
 }
 export function emitMapNew(host, e) {
@@ -854,6 +962,9 @@ export function emitMapLikeIntrinsic(host, e) {
     const key = receiverType.kind === "map" ? receiverType.key : receiverType.elem;
     const kAcc = mapKeyAccess(key);
     const kTy = mapKeyParamType(kAcc);
+    // The map keeps compact values in 16-byte entries (SCR_MAP_VAL_CREF).
+    const compact = receiverType.kind === "map" && compactMapValues(host, key, receiverType.value);
+    const layout = mapEntryLayout(key, compact);
     const method = e.method;
     // A published Map or Set rejects mutation (the guard precedes the
     // operands, which each method evaluates itself).
@@ -1009,7 +1120,7 @@ export function emitMapLikeIntrinsic(host, e) {
                     raw = emitNumberMapGetRef(host, r.name, numberKey, value);
                 }
                 else if (stringKey !== null) {
-                    raw = emitStringMapGetRef(host, r.name, stringKey, value);
+                    raw = emitStringMapGetRef(host, r.name, stringKey, value, compact);
                 }
                 else {
                     host.declare(`declare ptr @scr_map_get_${kAcc}_ref(ptr, ${kTy})`);
@@ -1082,7 +1193,7 @@ export function emitMapLikeIntrinsic(host, e) {
                 return host.wrapNullable(raw, raw, value, valueTag, e.type, undefTag);
             }
             if (stringKey !== null && isRefCounted(value)) {
-                const raw = emitStringMapGetRef(host, r.name, stringKey, value);
+                const raw = emitStringMapGetRef(host, r.name, stringKey, value, compact);
                 return host.wrapNullable(raw, raw, value, valueTag, e.type, undefTag);
             }
             host.declare(`declare ptr @scr_map_get_${kAcc}_ref(ptr, ${kTy})`);
@@ -1131,7 +1242,7 @@ export function emitMapLikeIntrinsic(host, e) {
             if (kAcc === "f64")
                 return { name: emitNumberMapHas(host, r.name, k.name), type: e.type };
             if (kAcc === "str")
-                return { name: emitStringMapHas(host, r.name, k.name), type: e.type };
+                return { name: emitStringMapHas(host, r.name, k.name, compact), type: e.type };
             host.declare(`declare zeroext i1 @scr_map_has_${kAcc}(ptr, ${kTy})`);
             const t = B.tmp();
             B.line(`${t} = call zeroext i1 @scr_map_has_${kAcc}(ptr ${r.name}, ${kTy} ${k.name})`);
@@ -1144,12 +1255,8 @@ export function emitMapLikeIntrinsic(host, e) {
             B.line(`${t} = call zeroext i1 @scr_map_delete_${kAcc}(ptr ${r.name}, ${kTy} ${k.name})`);
             return { name: t, type: e.type };
         }
-        case "size": {
-            host.declare(`declare double @scr_map_size(ptr)`);
-            const t = B.tmp();
-            B.line(`${t} = call double @scr_map_size(ptr ${r.name})`);
-            return { name: t, type: e.type };
-        }
+        case "size":
+            return { name: emitMapSize(host, r.name), type: e.type };
         case "clear":
             host.declare(`declare void @scr_map_clear(ptr)`);
             B.line(`call void @scr_map_clear(ptr ${r.name})`);
@@ -1160,7 +1267,7 @@ export function emitMapLikeIntrinsic(host, e) {
             return { name: emitMapIterStart(host, r.name), type: e.type };
         case "iterLive": {
             const i = host.emitExpr(e.args[0]);
-            const entry = emitMapIterEntry(host, r.name, i.name, mapEntryLayout(key));
+            const entry = emitMapIterEntry(host, r.name, i.name, layout);
             const t = B.tmp();
             B.line(`${t} = icmp ne ptr ${entry}, null`);
             return { name: t, type: e.type };
@@ -1171,7 +1278,7 @@ export function emitMapLikeIntrinsic(host, e) {
             if (kAcc !== "ref") {
                 const retTy = kAcc === "f64" ? "double" : kAcc === "bool" ? "zeroext i1" : "ptr";
                 const symbol = `scr_map_iter_key_${kAcc}`;
-                const t = emitMapIterSlot(host, r.name, i.name, 0, kAcc === "str" ? "ref" : kAcc, key, { decl: `declare ${retTy} @${symbol}(ptr, double)`, symbol }, mapEntryLayout(key));
+                const t = emitMapIterSlot(host, r.name, i.name, 0, kAcc === "str" ? "ref" : kAcc, key, { decl: `declare ${retTy} @${symbol}(ptr, double)`, symbol }, layout);
                 return host.own({ name: t, type: e.type });
             }
             const retTy = "ptr";
@@ -1190,7 +1297,7 @@ export function emitMapLikeIntrinsic(host, e) {
             const t = emitMapIterSlot(host, r.name, i.name, 1, vAcc, receiverType.value, {
                 decl: `declare ${vAcc === "bool" ? "zeroext i1" : retTy} @${symbol}(ptr, double)`,
                 symbol,
-            }, mapEntryLayout(key));
+            }, layout);
             return host.own({ name: t, type: e.type });
         }
         case "iterEnter":
@@ -1239,4 +1346,5 @@ export function emitSetNew(host, e) {
     }
     return out;
 }
+registerReplay("resolveThunkFor", (host, args) => resolveThunkFor(host, args[0]));
 //# sourceMappingURL=expr-containers.js.map