@scriptc/compiler 0.2.6 → 0.2.8

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

@@ -5,10 +5,15 @@ import { isRefCounted, typeEquals, typeKey } from "../../ir/ir.js";
 import { mangleResolveThunk } from "../mangle.js";
 import { elemAccess, FN_ATTRS, mapKeyAccess, mapKeyKindNum, mapKeyParamType, mapValKindNum, traceArg, vAdapters, } from "./shapes.js";
 import { F64_INF, f64Lit } from "./common.js";
+import { MUTATING_COLLECTION_METHODS } from "../publication.js";
 import { borrowsStringInputs, emitStringInputs } from "./string-lifetimes.js";
-import { emitMapLookupKey, borrowsMapReadInputs, borrowsMapMutationReceiver, } from "./map-read-lifetimes.js";
+import { emitMapLookupKey, borrowsMapReadInputs, borrowsMapMutationReceiver, inlineNumberKey, } from "./map-read-lifetimes.js";
+import { emitNumberMapGetRef, emitNumberMapGetScalar, emitNumberMapHas, } from "./map-number-lookup.js";
 import { emitBorrowedInput } from "./borrowed-inputs.js";
 import { emitStringSliceRead } from "./string-slices.js";
+import { STRING_CHAR_CODE_AT_DECL, STRING_UTF16_LEN_DECL } from "./string-reads.js";
+import { emitDenseArrayNumber, emitDenseArrayPush } from "./dense-array-access.js";
+import { emitUnionWiden } from "./expr-records.js";
 export function resolveThunkFor(host, inner) {
     const key = typeKey(inner);
     let sym = host.resolveThunks.get(key);
@@ -21,9 +26,9 @@ export function resolveThunkFor(host, inner) {
     }
     return sym;
 }
-export function tagInSet(host, uName, tags) {
+export function tagInSet(host, uName, unionId, tags) {
     const B = host.B;
-    const tag = host.unionTag(uName);
+    const tag = host.unionTag(uName, unionId);
     let acc = "";
     for (const t of tags) {
         const c = B.tmp();
@@ -40,11 +45,7 @@ export function tagInSet(host, uName, tags) {
     return acc;
 }
 export function arrPush(host, arr, acc, value) {
-    const argTy = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
-    host.declare(`declare double @scr_arr_push_${acc}(ptr, ${argTy === "i1" ? "i1 zeroext" : argTy})`);
-    const t = host.B.tmp();
-    host.B.line(`${t} = call double @scr_arr_push_${acc}(ptr ${arr}, ${argTy} ${value})`);
-    return t;
+    return emitDenseArrayPush(host, arr, acc, value);
 }
 /** Move evaluated values through one bounded slot buffer per call site. */
 export function emitArrayValues(host, arr, acc, values, prepend = false, sharedBuffer) {
@@ -95,6 +96,97 @@ export function emitArrayValues(host, arr, acc, values, prepend = false, sharedB
     }
     return result;
 }
+/** A splice whose removed-elements array is discarded (statement position)
+ * and whose insertion items, if any, are plain evaluated values: evaluate
+ * the receiver, start, count, and items in order, then splice the values in
+ * without a result or argument array. Returns false for every other shape,
+ * which keeps the ordinary intrinsic. */
+export function emitDiscardedSplice(host, e) {
+    if (!discardsSplice(e))
+        return false;
+    emitDiscarded(host, e);
+    return true;
+}
+/** The plain-value items of a splice that can drop its result, or null. */
+function droppableSpliceItems(e) {
+    if (e.kind !== "arrIntrinsic" || e.receiver.type.kind !== "array")
+        return null;
+    if (e.method === "splice")
+        return [];
+    if (e.method !== "spliceInsert")
+        return null;
+    const list = e.args[2];
+    if (list?.kind !== "arrayLit" || (list.spreads?.length ?? 0) > 0)
+        return null;
+    return list.elems.length <= 64 ? list.elems : null;
+}
+/** A droppable splice, possibly behind statements or one arm of a
+ * conditional (the runtime-optional item lowering). */
+function discardsSplice(e) {
+    if (e.kind === "seqExpr")
+        return discardsSplice(e.result);
+    if (e.kind === "ternary")
+        return discardsSplice(e.then) || discardsSplice(e.else_);
+    return droppableSpliceItems(e) !== null;
+}
+/** Emit an expression whose value is unused. Ternary arms keep their own
+ * frames, exactly like an evaluated conditional. */
+function emitDiscarded(host, e) {
+    const B = host.B;
+    if (e.kind === "seqExpr") {
+        for (const s of e.stmts)
+            host.emitStmt(s);
+        emitDiscarded(host, e.result);
+        return;
+    }
+    if (e.kind === "ternary") {
+        const c = host.emitExpr(e.cond);
+        const lt = B.newLabel("drop.t"), lf = B.newLabel("drop.f"), lj = B.newLabel("drop.j");
+        B.condBr(c.name, lt, lf);
+        for (const [label, arm] of [
+            [lt, e.then],
+            [lf, e.else_],
+        ]) {
+            B.startBlock(label);
+            host.frames.push([]);
+            emitDiscarded(host, arm);
+            host.releaseFrame(host.frames.pop());
+            B.br(lj);
+        }
+        B.startBlock(lj);
+        return;
+    }
+    const items = droppableSpliceItems(e);
+    if (items === null || e.kind !== "arrIntrinsic" || e.receiver.type.kind !== "array") {
+        host.emitExpr(e);
+        return;
+    }
+    const r = emitBorrowedInput(host, e.receiver);
+    const acc = elemAccess(e.receiver.type.elem);
+    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));
+    if (acc === "ref")
+        values.forEach((value) => host.moveTemp(value));
+    let buffer = "null";
+    if (values.length > 0) {
+        buffer = B.tmp();
+        B.entryAllocas.push(`${buffer} = alloca [${values.length} x i64]`);
+        values.forEach((value, i) => {
+            const slot = B.tmp(), pointer = B.tmp();
+            const pack = acc === "f64"
+                ? `bitcast double ${value.name} to i64`
+                : acc === "bool"
+                    ? `zext i1 ${value.name} to i64`
+                    : `ptrtoint ptr ${value.name} to i64`;
+            B.line(`${slot} = ${pack}`);
+            B.line(`${pointer} = getelementptr inbounds i64, ptr ${buffer}, ${host.sizeType} ${i}`);
+            B.line(`store i64 ${slot}, ptr ${pointer}`);
+        });
+    }
+    host.declare(`declare void @scr_arr_splice_drop(ptr, double, double, ${host.sizeType}, ptr)`);
+    B.line(`call void @scr_arr_splice_drop(ptr ${r.name}, double ${start.name}, double ${count}, ${host.sizeType} ${values.length}, ptr ${buffer})`);
+}
 export function emitArrayCopyLoop(host, dst, src, acc) {
     void acc;
     host.declare(`declare double @scr_arr_push_spread(ptr, ptr)`);
@@ -126,10 +218,19 @@ export function emitStrIntrinsic(host, e) {
     };
     const method = e.method;
     switch (method) {
-        case "length":
-            return call("scr_str_utf16_len", "double (ptr)", `ptr ${r.name}`, "double", false);
-        case "charCodeAt":
-            return call("scr_str_char_code_at", "double (ptr, double)", `ptr ${r.name}, double ${args[0].name}`, "double", false);
+        case "length": {
+            // sc_str_utf16_len (string-reads.ts) answers proven-ASCII strings inline.
+            host.declare(STRING_UTF16_LEN_DECL);
+            const t = B.tmp();
+            B.line(`${t} = call double @sc_str_utf16_len(ptr ${r.name})`);
+            return { name: t, type: e.type };
+        }
+        case "charCodeAt": {
+            host.declare(STRING_CHAR_CODE_AT_DECL);
+            const t = B.tmp();
+            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 "indexOf":
@@ -156,8 +257,12 @@ export function emitStrIntrinsic(host, e) {
             return call("scr_str_slice", "ptr (ptr, double, double)", `ptr ${r.name}, double ${args[0]?.name ?? f64Lit(0)}, double ${args[1]?.name ?? F64_INF}`, "ptr", true);
         case "substring":
             return call("scr_str_substring", "ptr (ptr, double, double)", `ptr ${r.name}, double ${args[0].name}, double ${args[1]?.name ?? F64_INF}`, "ptr", true);
-        case "repeat":
-            return call("scr_str_repeat", "ptr (ptr, double)", `ptr ${r.name}, double ${args[0].name}`, "ptr", true);
+        case "repeat": {
+            // A negative or infinite count throws Node's catchable RangeError.
+            const result = call("scr_str_repeat", "ptr (ptr, double)", `ptr ${r.name}, double ${args[0].name}`, "ptr", true);
+            host.emitPendingCheck();
+            return result;
+        }
         case "trim":
             return call("scr_str_trim", "ptr (ptr)", `ptr ${r.name}`, "ptr", true);
         case "trimStart":
@@ -248,6 +353,8 @@ export function emitArrIntrinsic(host, e) {
             const table = e.receiver.kind === "varRef"
                 ? host.constantNumericTables.get(e.receiver.localId)
                 : undefined;
+            if (!table && elem.kind === "f64")
+                return { name: emitDenseArrayNumber(host, r.name, index, e.args[0]), type: e.type };
             host.declare(`declare double @scr_arr_get_number(ptr, double)`);
             const t = B.tmp();
             B.line(`${t} = call double @${table ? `${table.symbol}_get` : "scr_arr_get_number"}(ptr ${r.name}, double ${index.name})`);
@@ -276,12 +383,19 @@ export function emitArrIntrinsic(host, e) {
             // the last push's return, or the unchanged length for Node's
             // 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 };
         }
         case "pushSpread": {
             // `a.push(...src)`: append src's elements in order (borrowed src,
             // count snapshotted). Result: the new length.
             const src = emitBorrowedInput(host, e.args[0]);
+            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 ${src.name})`);
+                host.emitPublishedArrayGuard(r.name, e.receiver.type, 1, f64Lit(0), n);
+            }
             host.emitArrayCopyLoop(r.name, src.name, acc);
             host.declare(`declare double @scr_arr_len(ptr)`);
             const t = B.tmp();
@@ -299,11 +413,18 @@ export function emitArrIntrinsic(host, e) {
             // Evaluate every argument before the first mutation, then insert
             // 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 };
         }
         case "unshiftSpread": {
             // The runtime snapshots the borrowed source and handles self-spread.
             const src = emitBorrowedInput(host, e.args[0]);
+            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 ${src.name})`);
+                host.emitPublishedArrayGuard(r.name, e.receiver.type, 4, f64Lit(0), n);
+            }
             host.declare(`declare double @scr_arr_unshift_spread(ptr, ptr)`);
             const t = B.tmp();
             B.line(`${t} = call double @scr_arr_unshift_spread(ptr ${r.name}, ptr ${src.name})`);
@@ -311,6 +432,7 @@ export function emitArrIntrinsic(host, e) {
         }
         case "pop":
         case "shift": {
+            host.emitPublishedArrayGuard(r.name, e.receiver.type, method === "pop" ? 2 : 6);
             const dynamic = elem.kind === "dyn" && e.type.kind === "dyn";
             if (!dynamic && e.type.kind !== "union")
                 throw new InternalCompilerError("llvm emitter bug: array removal result is not a union");
@@ -343,7 +465,7 @@ export function emitArrIntrinsic(host, e) {
                 B.line(`${value} = icmp ne i64 ${raw}, 0`);
             else
                 B.line(`${value} = inttoptr i64 ${raw} to ptr`);
-            B.line(`store ptr ${dynamic || sameUnion ? value : host.unionNewOwned(tag, { name: value, type: elem })}, ptr ${resultSlot}`);
+            B.line(`store ptr ${dynamic || sameUnion || e.type.kind !== "union" ? value : host.unionNewOwned(e.type.unionId, tag, { name: value, type: elem })}, ptr ${resultSlot}`);
             B.br(lj);
             B.startBlock(la);
             if (dynamic) {
@@ -413,13 +535,28 @@ export function emitArrIntrinsic(host, e) {
         }
         case "sortPrimitive":
         case "toSortedPrimitive": {
+            if (e.method === "sortPrimitive")
+                host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
             host.declare(`declare ptr @scr_arr_sort_primitive(ptr, i1 zeroext)`);
             const result = B.tmp();
             B.line(`${result} = call ptr @scr_arr_sort_primitive(ptr ${r.name}, i1 ${e.method === "toSortedPrimitive" ? 1 : 0})`);
             return host.own({ name: result, type: e.type });
         }
+        case "sortValues": {
+            // The runtime invokes the borrowed comparator with the callValue ABI
+            // and stops at the first pending exception.
+            const count = host.emitExpr(e.args[0]);
+            const comparator = emitBorrowedInput(host, e.args[1]);
+            const cmp = e.args[1].type;
+            const arity = cmp.kind === "func" ? cmp.params.length : 0;
+            host.declare(`declare void @scr_arr_sort_values(ptr, double, ptr, i32)`);
+            B.line(`call void @scr_arr_sort_values(ptr ${r.name}, double ${count.name}, ptr ${comparator.name}, i32 ${arity})`);
+            host.emitPendingCheck();
+            return { name: "", type: e.type };
+        }
         case "reverse": {
             // Mutates in place and returns the same receiver as a fresh +1.
+            host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
             host.declare(`declare ptr @scr_arr_reverse(ptr)`);
             const t = B.tmp();
             B.line(`${t} = call ptr @scr_arr_reverse(ptr ${r.name})`);
@@ -429,6 +566,7 @@ export function emitArrIntrinsic(host, e) {
         case "fill":
         case "fillUndefined": {
             const args = e.args.map((arg) => host.emitExpr(arg));
+            host.emitPublishedArrayGuard(r.name, e.receiver.type, 7);
             const helper = e.method === "copyWithin"
                 ? "scr_arr_copy_within"
                 : e.method === "fillUndefined"
@@ -477,6 +615,7 @@ export function emitArrIntrinsic(host, e) {
             // 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.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})`);
@@ -486,6 +625,7 @@ export function emitArrIntrinsic(host, e) {
             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);
             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})`);
@@ -508,6 +648,16 @@ export function emitArrIntrinsic(host, e) {
 }
 export function wrapNullable(host, raw, present, valueType, valueTag, resultType, absentTag) {
     const B = host.B;
+    if (host.nullableUnions.has(resultType.unionId)) {
+        // A nullable union is its present payload, or the absent arm's encoding.
+        const absent = host.unitInstanceRef(resultType.unionId, absentTag);
+        if (raw === present && absent === "null")
+            return host.own({ name: present, type: resultType });
+        const isnull = B.tmp(), t = B.tmp();
+        B.line(`${isnull} = icmp eq ptr ${raw}, null`);
+        B.line(`${t} = select i1 ${isnull}, ptr ${absent}, ptr ${present}`);
+        return host.own({ name: t, type: resultType });
+    }
     const slot = B.slot();
     B.entryAllocas.push(`${slot} = alloca ptr`);
     const isnull = B.tmp();
@@ -517,7 +667,7 @@ export function wrapNullable(host, raw, present, valueType, valueTag, resultType
     const lj = B.newLabel("nw.j");
     B.condBr(isnull, la, lp);
     B.startBlock(lp);
-    B.line(`store ptr ${host.unionNewOwned(valueTag, { name: present, type: valueType })}, ptr ${slot}`);
+    B.line(`store ptr ${host.unionNewOwned(resultType.unionId, valueTag, { name: present, type: valueType })}, ptr ${slot}`);
     B.br(lj);
     B.startBlock(la);
     B.line(`store ptr ${host.unitInstanceRef(resultType.unionId, absentTag)}, ptr ${slot}`);
@@ -601,6 +751,10 @@ export function emitMapLikeIntrinsic(host, e) {
     const kAcc = mapKeyAccess(key);
     const kTy = mapKeyParamType(kAcc);
     const method = e.method;
+    // A published Map or Set rejects mutation (the guard precedes the
+    // operands, which each method evaluates itself).
+    if (MUTATING_COLLECTION_METHODS.has(method))
+        host.emitPublishedCollectionGuard(r.name, receiverType);
     if (method === "clone" || method === "keySet") {
         const keysOnly = method === "keySet" || receiverType.kind === "set";
         const checked = key.kind === "dyn" &&
@@ -704,12 +858,48 @@ export function emitMapLikeIntrinsic(host, e) {
             if (!def || undefTag < 0)
                 throw new InternalCompilerError("llvm emitter bug: map get union lacks its undefined arm");
             const absent = host.unitInstanceRef(e.type.unionId, undefTag);
-            if (value.kind === "union") {
+            if (value.kind === "union" &&
+                host.nullableUnions.has(value.unionId) &&
+                !typeEquals(value, e.type)) {
+                // A nullable `C | null` value widens into `C | null | undefined`:
+                // NULL is the stored null, so presence decides the undefined arm.
+                host.declare(`declare zeroext i1 @scr_map_has_${kAcc}(ptr, ${kTy})`);
                 host.declare(`declare ptr @scr_map_get_${kAcc}_ref(ptr, ${kTy})`);
+                const has = B.tmp();
+                B.line(`${has} = call zeroext i1 @scr_map_has_${kAcc}(ptr ${r.name}, ${k.args})`);
+                const slot = B.slot();
+                B.entryAllocas.push(`${slot} = alloca ptr`);
+                const lp = B.newLabel("mgn.p");
+                const la = B.newLabel("mgn.a");
+                const lj = B.newLabel("mgn.j");
+                B.condBr(has, lp, la);
+                B.startBlock(lp);
                 const raw = B.tmp();
+                B.line(`${raw} = call ptr @scr_map_get_${kAcc}_ref(ptr ${r.name}, ${k.args})`);
+                const widened = emitUnionWiden(host, raw, value.unionId, e.type.unionId, true);
+                B.line(`store ptr ${widened}, ptr ${slot}`);
+                B.br(lj);
+                B.startBlock(la);
+                B.line(`store ptr ${absent}, ptr ${slot}`);
+                B.br(lj);
+                B.startBlock(lj);
+                const t = B.tmp();
+                B.line(`${t} = load ptr, ptr ${slot}`);
+                return host.own({ name: t, type: e.type });
+            }
+            const numberKey = inlineNumberKey(k);
+            if (value.kind === "union") {
                 const isnull = B.tmp();
                 const t = B.tmp();
-                B.line(`${raw} = call ptr @scr_map_get_${kAcc}_ref(ptr ${r.name}, ${k.args})`);
+                let raw;
+                if (numberKey !== null) {
+                    raw = emitNumberMapGetRef(host, r.name, numberKey, value);
+                }
+                else {
+                    host.declare(`declare ptr @scr_map_get_${kAcc}_ref(ptr, ${kTy})`);
+                    raw = B.tmp();
+                    B.line(`${raw} = call ptr @scr_map_get_${kAcc}_ref(ptr ${r.name}, ${k.args})`);
+                }
                 B.line(`${isnull} = icmp eq ptr ${raw}, null`);
                 B.line(`${t} = select i1 ${isnull}, ptr ${absent}, ptr ${raw}`);
                 return host.own({ name: t, type: e.type });
@@ -719,12 +909,36 @@ export function emitMapLikeIntrinsic(host, e) {
                 throw new InternalCompilerError("llvm emitter bug: map get union lacks its value arm");
             if (value.kind === "f64" || value.kind === "bool") {
                 const outTy = value.kind === "f64" ? "double" : "i8";
-                const outSlot = B.slot();
-                B.entryAllocas.push(`${outSlot} = alloca ${outTy}`);
-                B.line(`store ${outTy} ${value.kind === "f64" ? f64Lit(0) : "0"}, ptr ${outSlot}`);
-                host.declare(`declare zeroext i1 @scr_map_get_${kAcc}_${value.kind === "f64" ? "f64" : "bool"}(ptr, ${kTy}, ptr)`);
-                const found = B.tmp();
-                B.line(`${found} = call zeroext i1 @scr_map_get_${kAcc}_${value.kind === "f64" ? "f64" : "bool"}(ptr ${r.name}, ${k.args}, ptr ${outSlot})`);
+                let found;
+                let readHit;
+                if (numberKey !== null) {
+                    const scalar = emitNumberMapGetScalar(host, r.name, numberKey);
+                    found = scalar.found;
+                    readHit = () => {
+                        const hit = B.tmp();
+                        B.line(value.kind === "f64"
+                            ? `${hit} = bitcast i64 ${scalar.bits} to double`
+                            : `${hit} = icmp ne i64 ${scalar.bits}, 0`);
+                        return hit;
+                    };
+                }
+                else {
+                    const outSlot = B.slot();
+                    B.entryAllocas.push(`${outSlot} = alloca ${outTy}`);
+                    B.line(`store ${outTy} ${value.kind === "f64" ? f64Lit(0) : "0"}, ptr ${outSlot}`);
+                    host.declare(`declare zeroext i1 @scr_map_get_${kAcc}_${value.kind === "f64" ? "f64" : "bool"}(ptr, ${kTy}, ptr)`);
+                    found = B.tmp();
+                    B.line(`${found} = call zeroext i1 @scr_map_get_${kAcc}_${value.kind === "f64" ? "f64" : "bool"}(ptr ${r.name}, ${k.args}, ptr ${outSlot})`);
+                    readHit = () => {
+                        const rawOut = B.tmp();
+                        B.line(`${rawOut} = load ${outTy}, ptr ${outSlot}`);
+                        if (value.kind !== "bool")
+                            return rawOut;
+                        const hit = B.tmp();
+                        B.line(`${hit} = trunc i8 ${rawOut} to i1`);
+                        return hit;
+                    };
+                }
                 const slot = B.slot();
                 B.entryAllocas.push(`${slot} = alloca ptr`);
                 const lp = B.newLabel("mg.p");
@@ -732,14 +946,8 @@ export function emitMapLikeIntrinsic(host, e) {
                 const lj = B.newLabel("mg.j");
                 B.condBr(found, lp, la);
                 B.startBlock(lp);
-                const rawOut = B.tmp();
-                B.line(`${rawOut} = load ${outTy}, ptr ${outSlot}`);
-                let hit = rawOut;
-                if (value.kind === "bool") {
-                    hit = B.tmp();
-                    B.line(`${hit} = trunc i8 ${rawOut} to i1`);
-                }
-                B.line(`store ptr ${host.unionNewOwned(valueTag, { name: hit, type: value })}, ptr ${slot}`);
+                const hit = readHit();
+                B.line(`store ptr ${host.unionNewOwned(e.type.unionId, valueTag, { name: hit, type: value })}, ptr ${slot}`);
                 B.br(lj);
                 B.startBlock(la);
                 B.line(`store ptr ${absent}, ptr ${slot}`);
@@ -749,6 +957,10 @@ export function emitMapLikeIntrinsic(host, e) {
                 B.line(`${t} = load ptr, ptr ${slot}`);
                 return host.own({ name: t, type: e.type });
             }
+            if (numberKey !== null && isRefCounted(value)) {
+                const raw = emitNumberMapGetRef(host, r.name, numberKey, value);
+                return host.wrapNullable(raw, raw, value, valueTag, e.type, undefTag);
+            }
             host.declare(`declare ptr @scr_map_get_${kAcc}_ref(ptr, ${kTy})`);
             const raw = B.tmp();
             B.line(`${raw} = call ptr @scr_map_get_${kAcc}_ref(ptr ${r.name}, ${k.args})`);
@@ -778,6 +990,8 @@ export function emitMapLikeIntrinsic(host, e) {
         }
         case "has": {
             const k = borrowInputs ? host.emitReadReceiver(e.args[0]) : host.emitExpr(e.args[0]);
+            if (kAcc === "f64")
+                return { name: emitNumberMapHas(host, r.name, k.name), 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})`);