@scriptc/compiler 0.4.0 → 0.4.2

package/dist/backend/llvm/dyn.js

@@ -4,7 +4,7 @@ import { BYTES_ELEM_NUM, SCR_ARR_FIELD, f64Lit, sizeToDouble } from "./common.js
 import { emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { INLINE_UNION_FIELD, loadInlineUnion, stackUnionBox, storeInlineUnion, unionBoxBits, } from "./inline-unions.js";
 import { InternalCompilerError } from "../../errors.js";
-import { accessorSlotProp, DYN_HANDLE_KINDS, isDirentShape, isDynTypedRefType, isRefCounted, typeKey, } from "../../ir/ir.js";
+import { accessorSlotProp, DYN_HANDLE_KINDS, isDirentShape, isDynTypedRefType, isRefCounted, isUnitType, typeKey, } from "../../ir/ir.js";
 import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
@@ -35,6 +35,7 @@ export const DYN_HANDLE_TAG_NUM = {
     child: 16,
     fileHandle: 17,
     dir: 44,
+    dgramSocket: 62,
     cryptoHash: 52,
     cryptoHmac: 53,
 };
@@ -44,6 +45,22 @@ export const DYN_HANDLE_TAG_NUM = {
 const DYN_HANDLE_BOX_FN = {
     cryptoHash: "scr_crypto_hash_to_dyn",
     cryptoHmac: "scr_crypto_hash_to_dyn",
+    dgramSocket: "scr_dgram_to_dyn",
+};
+/** Handle kinds whose box holds a unit-owned wrapper rather than the
+ * handle itself (a dgram socket's box carries its untyped listeners):
+ * the unit's own function unwraps it, with the tag check and TypeError
+ * of scr_dyn_handle_unbox. */
+const DYN_HANDLE_UNBOX_FN = {
+    dgramSocket: "scr_dgram_from_dyn",
+};
+/** ScrMessageKind (scr_message.h): the node kinds message readers test. */
+const MESSAGE_KIND = {
+    UNDEFINED: 0,
+    NULL: 1,
+    BOOL: 2,
+    NUMBER: 3,
+    STRING: 4,
 };
 export const DYN_KIND = {
     NULL: 0,
@@ -83,6 +100,8 @@ export class LlDyn {
     dynFuncThunks = new Map();
     dynFuncBoxes = new Map();
     dynFuncAdapters = new Map();
+    messageListeners = new Map();
+    messageReaders = new Map();
     promiseDynAdapters = new Map();
     mapDynOps = new Map();
     dynToStrFn = null;
@@ -520,6 +539,44 @@ export class LlDyn {
     }
     /** Emit the standard in-helper pending check: on a pending exception
      * run `cleanup` and return `dummy`. */
+    /** The failure block of a union dynCheck whose value matched no arm. A
+     * value of the one container kind exactly one arm can take (an object
+     * for the union's only record arm, an array for its only array arm,
+     * beside unit and scalar arms) runs that arm's builder, which throws the
+     * deepest failing path and the reason there (`expected string at
+     * $.order.owner.id, got undefined`) instead of the union's own outer
+     * path. Other values, and an arm builder that unexpectedly succeeds,
+     * fall through to the union's message. Only the failure path changes. */
+    unionArmFailure(B, def, kind) {
+        const scalar = (arm) => isUnitType(arm) ||
+            arm.kind === "f64" ||
+            arm.kind === "bool" ||
+            arm.kind === "string" ||
+            arm.kind === "bigint";
+        const containers = def.arms.filter((arm) => !scalar(arm));
+        const arm = containers.length === 1 ? containers[0] : null;
+        const container = arm?.kind === "array"
+            ? DYN_KIND.ARR
+            : arm?.kind === "record" && !this.host.recordsById.get(arm.shapeId)?.tuple
+                ? DYN_KIND.OBJ
+                : null;
+        if (!arm || container === null)
+            return;
+        const host = this.host;
+        const deep = B.newLabel("dcu.deep");
+        const outer = B.newLabel("dcu.outer");
+        const same = B.tmp();
+        B.line(`${same} = icmp eq i32 ${kind}, ${container}`);
+        B.condBr(same, deep, outer);
+        B.startBlock(deep);
+        const built = B.tmp();
+        B.line(`${built} = call ptr @${this.dynCheckHelper(arm)}(ptr %d, ptr %path)`);
+        this.pendingBail(B, "dcu.deep", () => { }, "ptr null");
+        const rc = vAdapters(host, arm);
+        B.line(`call void ${rc.release}(ptr ${built})`);
+        B.br(outer);
+        B.startBlock(outer);
+    }
     pendingBail(B, hint, cleanup, dummy) {
         const p = B.tmp();
         for (const line of this.host.pendingTestLines(p))
@@ -1339,10 +1396,10 @@ export class LlDyn {
                                 : []),
                         ]
                         : [
-                            { index: 1, type: host.sizeType, name: "length" },
-                            { index: 2, type: host.sizeType, name: "capacity" },
+                            // The dense states follow the data slots: they move with data and capacity.
+                            { index: SCR_ARR_FIELD.len, type: "i32", name: "length" },
+                            { index: SCR_ARR_FIELD.cap, type: "i32", name: "capacity" },
                             { index: SCR_ARR_FIELD.data, type: "ptr", name: "data" },
-                            { index: SCR_ARR_FIELD.present, type: "ptr", name: "presence" },
                             { index: SCR_ARR_FIELD.filled, type: "i32", name: "filled" },
                         ];
                     members.forEach((member) => {
@@ -1935,6 +1992,7 @@ export class LlDyn {
                     B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
                     B.terminate(`ret ptr ${checked}`);
                     B.startBlock(lFail);
+                    this.unionArmFailure(B, def, kind);
                     B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
                     B.terminate(`ret ptr null`);
                     break;
@@ -1995,6 +2053,7 @@ export class LlDyn {
                 B.line(`call void @scr_dyn_typed_ref_cache_cast(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr ${checked}, ptr ${rc.retain}, ptr ${rc.release}, i1 ${traceAdapter(host, t) !== null ? "true" : "false"})`);
                 B.terminate(`ret ptr ${checked}`);
                 B.startBlock(lFail);
+                this.unionArmFailure(B, def, kind);
                 B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
                 B.terminate(`ret ptr null`);
                 break;
@@ -2079,9 +2138,16 @@ export class LlDyn {
                 // TypeError on any other kind or tag).
                 const h = DYN_HANDLE_KINDS.get(t.kind);
                 if (h) {
-                    host.declare(`declare ptr @scr_dyn_handle_unbox(ptr, i32, ptr, ptr)`);
                     const r = B.tmp();
-                    B.line(`${r} = call ptr @scr_dyn_handle_unbox(ptr %d, i32 ${DYN_HANDLE_TAG_NUM[t.kind]}, ptr %path, ptr ${want})`);
+                    const unbox = DYN_HANDLE_UNBOX_FN[t.kind];
+                    if (unbox) {
+                        host.declare(`declare ptr @${unbox}(ptr, ptr, ptr)`);
+                        B.line(`${r} = call ptr @${unbox}(ptr %d, ptr %path, ptr ${want})`);
+                    }
+                    else {
+                        host.declare(`declare ptr @scr_dyn_handle_unbox(ptr, i32, ptr, ptr)`);
+                        B.line(`${r} = call ptr @scr_dyn_handle_unbox(ptr %d, i32 ${DYN_HANDLE_TAG_NUM[t.kind]}, ptr %path, ptr ${want})`);
+                    }
                     B.terminate(`ret ptr ${r}`);
                     break;
                 }
@@ -2749,7 +2815,8 @@ export class LlDyn {
     }
     /* ── the dyn ToString pair (dynToStrHelper, ported) ────────────────── */
     /** Node's String() over a dyn value — sc_ds (+1 result) over the
-     * recursive sc_ds_buf walker. Borrowed operand; never throws. */
+     * recursive sc_ds_buf walker. Borrowed operand; an exception that an
+     * object's toString or valueOf throws stays pending. */
     dynToStrHelper() {
         if (this.dynToStrFn)
             return this.dynToStrFn;
@@ -2853,9 +2920,9 @@ export class LlDyn {
             B.startBlock(labels.get(DYN_KIND.ARR));
             {
                 // Array.prototype.toString: join(",") — null/undefined ELEMENTS
-                // print empty (unlike top level), nested arrays flatten.
+                // print empty (unlike top level), nested arrays flatten. The length
+                // is read once, as join reads it.
                 const n = this.lenOf(B, "%d");
-                const items = this.itemsOf(B, "%d");
                 this.i64Loop(B, "ds.ar", n, (i, brNext) => {
                     const nz = B.tmp();
                     B.line(`${nz} = icmp ugt ${this.S} ${i}, 0`);
@@ -2866,7 +2933,22 @@ export class LlDyn {
                     B.line(`call void @scr_jb_putc(ptr %b, i8 44)`);
                     B.br(lel);
                     B.startBlock(lel);
-                    const e = this.itemAt(B, items, i);
+                    // Each index reads the element as join does (scr_dyn_arr_at, +1):
+                    // from the current storage, undefined past the current length,
+                    // and through the prototype for a hole. An element's toString
+                    // can append to, shrink or reallocate the array; a getter that
+                    // throws answers NULL with the exception pending.
+                    host.declare(`declare ptr @scr_dyn_arr_at(ptr, double)`);
+                    host.declare(`declare void @scr_dyn_release_v(ptr)`);
+                    const index = B.tmp();
+                    B.line(`${index} = uitofp ${this.S} ${i} to double`);
+                    const e = B.tmp();
+                    B.line(`${e} = call ptr @scr_dyn_arr_at(ptr %d, double ${index})`);
+                    const missing = B.tmp();
+                    B.line(`${missing} = icmp eq ptr ${e}, null`);
+                    const lGot = B.newLabel("ds.gt");
+                    B.condBr(missing, done, lGot);
+                    B.startBlock(lGot);
                     const ek = this.kindOf(B, e);
                     const isU = B.tmp();
                     const isN = B.tmp();
@@ -2874,20 +2956,31 @@ export class LlDyn {
                     B.line(`${isU} = icmp eq i32 ${ek}, ${DYN_KIND.UNDEF}`);
                     B.line(`${isN} = icmp eq i32 ${ek}, ${DYN_KIND.NULL}`);
                     B.line(`${unit} = or i1 ${isU}, ${isN}`);
-                    const lSkip = B.newLabel("ds.sk");
                     const lRec = B.newLabel("ds.rc");
+                    const lSkip = B.newLabel("ds.sk");
                     B.condBr(unit, lSkip, lRec);
                     B.startBlock(lSkip);
+                    B.line(`call void @scr_dyn_release_v(ptr ${e})`);
                     brNext();
                     B.startBlock(lRec);
                     B.line(`call void @sc_ds_buf(ptr %b, ptr ${e})`);
+                    B.line(`call void @scr_dyn_release_v(ptr ${e})`);
+                    // The first exception an element's conversion throws ends the
+                    // conversion; later elements are not read.
+                    const thrown = B.tmp();
+                    for (const line of host.pendingTestLines(thrown))
+                        B.line(line.trimStart());
+                    const lMore = B.newLabel("ds.mo");
+                    B.condBr(thrown, done, lMore);
+                    B.startBlock(lMore);
                 });
                 B.br(done);
             }
             B.startBlock(labels.get(DYN_KIND.OBJ));
             {
                 // The checked-dynamic tree's error encoding renders Error.prototype.toString;
-                // plain objects are "[object Object]".
+                // other objects convert with ToPrimitive's string hint: a toString or
+                // valueOf of their own or of their prototypes, else "[object Object]".
                 const marker = this.objGetLit(B, "%d", "%error");
                 const isErr = B.tmp();
                 B.line(`${isErr} = icmp ne ptr ${marker}, null`);
@@ -2895,8 +2988,21 @@ export class LlDyn {
                 const lPlain = B.newLabel("ds.pl");
                 B.condBr(isErr, lErr, lPlain);
                 B.startBlock(lPlain);
-                this.puts(B, "%b", "[object Object]");
-                B.br(done);
+                {
+                    // Null leaves the exception the conversion threw pending.
+                    host.declare(`declare ptr @scr_dyn_string_coerce_js(ptr)`);
+                    host.declare(`declare void @scr_str_release(ptr)`);
+                    const text = B.tmp();
+                    B.line(`${text} = call ptr @scr_dyn_string_coerce_js(ptr %d)`);
+                    const converted = B.tmp();
+                    B.line(`${converted} = icmp ne ptr ${text}, null`);
+                    const lPut = B.newLabel("ds.pp");
+                    B.condBr(converted, lPut, done);
+                    B.startBlock(lPut);
+                    this.putScrStr(B, "%b", text);
+                    B.line(`call void @scr_str_release(ptr ${text})`);
+                    B.br(done);
+                }
                 B.startBlock(lErr);
                 // Error.prototype.toString, reading name and message through the
                 // prototype. Null leaves the exception its conversion threw pending.
@@ -3993,6 +4099,279 @@ export class LlDyn {
         this.defs.push(`define internal ptr @${name}(ptr %v, ptr %fname) ${FN_ATTRS} { ; box ${key} into dyn`, `entry:`, `  %c = call ptr @scr_closure_retain_v(ptr %v)`, `  %r = call ptr @scr_dyn_new_func(ptr %c, ptr @${thunk}, i32 ${t.params.length - (t.restAbi === "typed" ? 1 : 0)}, ptr ${sigLit}, ptr %fname)`, `  ret ptr %r`, `}`, ``);
         return name;
     }
+    /** `sc_dml_<n>(ptr c, ptr message) -> i1`, the typed message entry of a
+     * closure registered as a 'message' listener (ScrDynMessageListener):
+     * builds the closure's parameter from the message's nodes and calls the
+     * closure. It answers false, without calling it, when the message does
+     * not have the parameter's exact layout, and the listener then runs
+     * through its thunk on the decoded message, as before. Null when the
+     * signature's parameter has no message reader (messageReadable). */
+    messageListenerHelper(t) {
+        const key = typeKey(t);
+        const existing = this.messageListeners.get(key);
+        if (existing !== undefined)
+            return existing;
+        const param = t.params[0];
+        const supported = t.params.length === 1 &&
+            t.rest !== true &&
+            param !== undefined &&
+            (t.ret.kind === "void" || t.ret.kind === "f64" || t.ret.kind === "bool") &&
+            this.messageReadable(param, new Set());
+        if (!supported) {
+            this.messageListeners.set(key, null);
+            return null;
+        }
+        const name = `sc_dml_${this.messageListeners.size}`;
+        this.messageListeners.set(key, name);
+        const B = new BlockBuilder();
+        B.entryAllocas.push(`%fail = alloca i1`);
+        B.line(`store i1 false, ptr %fail`);
+        const value = B.tmp();
+        B.line(`${value} = call ${this.valTy(param)} @${this.messageReaderHelper(param)}(ptr %m, ${this.host.sizeType} 0, ptr %fail)`);
+        const failed = B.tmp();
+        B.line(`${failed} = load i1, ptr %fail`);
+        const lMiss = B.newLabel("dml.miss");
+        const lCall = B.newLabel("dml.call");
+        B.condBr(failed, lMiss, lCall);
+        B.startBlock(lMiss);
+        B.terminate(`ret i1 false`);
+        B.startBlock(lCall);
+        // The closure consumes its parameter; a pending exception stays for
+        // the emitter, as after the thunk.
+        const fnp = B.tmp();
+        const fn = B.tmp();
+        B.line(`${fnp} = getelementptr inbounds %ScrClosure, ptr %c, i64 0, i32 1`);
+        B.line(`${fn} = load ptr, ptr ${fnp}`);
+        const args = `ptr %c, ${this.valTy(param)} ${value}`;
+        if (t.ret.kind === "void")
+            B.line(`call void ${fn}(${args})`);
+        else
+            B.line(`${B.tmp()} = call ${this.valTy(t.ret)} ${fn}(${args})`);
+        B.terminate(`ret i1 true`);
+        this.defs.push(`define internal zeroext i1 @${name}(ptr %c, ptr %m) ${FN_ATTRS} { ; message entry for ${llvmCommentText(key)}`, B.render(), `}`, ``);
+        return name;
+    }
+    /** Whether a message reader can build T: numbers, booleans and strings;
+     * records of them with only declared fields, none of union type; and
+     * boxed unions of those arms and null or undefined without a literal
+     * discriminator, with at most one number, boolean and string arm. */
+    messageReadable(t, seen) {
+        switch (t.kind) {
+            case "f64":
+            case "bool":
+            case "string":
+                return true;
+            case "record": {
+                const shape = this.host.recordsById.get(t.shapeId);
+                if (!shape || shape.tuple || shape.indexValue || shape.fields.length === 0)
+                    return false;
+                if (seen.has(t.shapeId) || this.isRecursiveShape(t))
+                    return false;
+                seen.add(t.shapeId);
+                const readable = shape.fields.every((f) => !f.name.startsWith("%") &&
+                    f.type.kind !== "union" &&
+                    llFieldType(f.type, this.host.inlineUnions.record(f.type)) !== INLINE_UNION_FIELD &&
+                    this.messageReadable(f.type, seen));
+                seen.delete(t.shapeId);
+                return readable;
+            }
+            case "union": {
+                const def = this.host.unionsById.get(t.unionId);
+                // A discriminated union's checked conversion also tests the arm's
+                // literal discriminator, which the readers do not.
+                if (!def || def.discriminant || this.host.nullableUnions.has(t.unionId))
+                    return false;
+                const scalars = new Set();
+                for (const arm of def.arms) {
+                    if (arm.kind === "nullT" || arm.kind === "undefinedT")
+                        continue;
+                    if (arm.kind === "f64" || arm.kind === "bool" || arm.kind === "string") {
+                        if (scalars.has(arm.kind))
+                            return false;
+                        scalars.add(arm.kind);
+                        continue;
+                    }
+                    if (arm.kind !== "record" || !this.messageReadable(arm, seen))
+                        return false;
+                }
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
+    /** `sc_dmr_<n>(ptr message, size node, ptr fail) -> T`: T (+1) built
+     * from a message node, for a type messageReadable accepts. Sets *fail
+     * and returns a dummy when the node does not have T's layout: the arm
+     * the checked conversion would choose, a record's declared keys in
+     * declaration order and no others. */
+    messageReaderHelper(t) {
+        const key = typeKey(t);
+        const existing = this.messageReaders.get(key);
+        if (existing)
+            return existing;
+        const name = `sc_dmr_${this.messageReaders.size}`;
+        this.messageReaders.set(key, name);
+        const host = this.host;
+        const S = host.sizeType;
+        if (t.kind !== "record")
+            host.declare(`declare i32 @scr_message_kind(ptr, ${S})`);
+        const retTy = this.valTy(t);
+        const dummy = retTy === "double" ? f64Lit(0) : retTy === "i1" ? "false" : "null";
+        const B = new BlockBuilder();
+        const lFail = B.newLabel("dmr.fail");
+        // scr_message_fields tests a record's kind itself.
+        const kind = B.tmp();
+        if (t.kind !== "record")
+            B.line(`${kind} = call i32 @scr_message_kind(ptr %m, ${S} %n)`);
+        const requireKind = (want) => {
+            const ok = B.tmp();
+            B.line(`${ok} = icmp eq i32 ${kind}, ${want}`);
+            const lOk = B.newLabel("dmr.kind");
+            B.condBr(ok, lOk, lFail);
+            B.startBlock(lOk);
+        };
+        switch (t.kind) {
+            case "f64":
+            case "bool": {
+                host.declare(`declare double @scr_message_number(ptr, ${S})`);
+                requireKind(t.kind === "f64" ? MESSAGE_KIND.NUMBER : MESSAGE_KIND.BOOL);
+                const n = B.tmp();
+                B.line(`${n} = call double @scr_message_number(ptr %m, ${S} %n)`);
+                if (t.kind === "f64")
+                    B.terminate(`ret double ${n}`);
+                else {
+                    const b = B.tmp();
+                    B.line(`${b} = fcmp une double ${n}, ${f64Lit(0)}`);
+                    B.terminate(`ret i1 ${b}`);
+                }
+                break;
+            }
+            case "string": {
+                host.declare(`declare ptr @scr_message_string(ptr, ${S})`);
+                requireKind(MESSAGE_KIND.STRING);
+                const str = B.tmp();
+                B.line(`${str} = call ptr @scr_message_string(ptr %m, ${S} %n)`);
+                B.terminate(`ret ptr ${str}`);
+                break;
+            }
+            case "record": {
+                const shape = host.recordsById.get(t.shapeId);
+                const order = recordSourceFieldOrder(shape);
+                const fields = new Map(shape.fields.map((f, i) => [f.name, { field: f, index: i }]));
+                const base = host.nullableUnions.fieldBase(t.shapeId);
+                const struct = mangleRecordStruct(t.shapeId);
+                const names = this.recordNameTable(t.shapeId, shape);
+                host.declare(`declare zeroext i1 @scr_message_fields(ptr, ${S}, ptr, ptr, ${S}, ptr)`);
+                B.entryAllocas.push(`%kids = alloca [${order.length} x ${S}]`);
+                const matched = B.tmp();
+                B.line(`${matched} = call zeroext i1 @scr_message_fields(ptr %m, ${S} %n, ptr ${names.names}, ptr ${names.lens}, ${S} ${order.length}, ptr %kids)`);
+                const lBuild = B.newLabel("dmr.build");
+                B.condBr(matched, lBuild, lFail);
+                B.startBlock(lBuild);
+                B.line(`%r0 = call ptr @${mangleRecordNew(t.shapeId)}()`);
+                order.forEach((fieldName, i) => {
+                    const { field, index } = fields.get(fieldName);
+                    const kidp = B.tmp();
+                    const kid = B.tmp();
+                    B.line(`${kidp} = getelementptr inbounds [${order.length} x ${S}], ptr %kids, i64 0, i64 ${i}`);
+                    B.line(`${kid} = load ${S}, ptr ${kidp}`);
+                    const v = B.tmp();
+                    B.line(`${v} = call ${this.valTy(field.type)} @${this.messageReaderHelper(field.type)}(ptr %m, ${S} ${kid}, ptr %fail)`);
+                    const failed = B.tmp();
+                    B.line(`${failed} = load i1, ptr %fail`);
+                    const lDrop = B.newLabel("dmr.drop");
+                    const lStore = B.newLabel("dmr.store");
+                    B.condBr(failed, lDrop, lStore);
+                    B.startBlock(lDrop);
+                    B.line(`call void ${releaseSym(host, t)}(ptr %r0)`);
+                    B.terminate(`ret ptr null`);
+                    B.startBlock(lStore);
+                    const p = B.tmp();
+                    B.line(`${p} = getelementptr inbounds %${struct}, ptr %r0, i64 0, i32 ${index + base} ; .${llvmCommentText(fieldName)}`);
+                    const fieldTy = llFieldType(field.type, host.inlineUnions.record(field.type));
+                    if (fieldTy === "i8") {
+                        const z = B.tmp();
+                        B.line(`${z} = zext i1 ${v} to i8`);
+                        B.line(`store i8 ${z}, ptr ${p}`);
+                    }
+                    else {
+                        B.line(`store ${fieldTy} ${v}, ptr ${p}`);
+                    }
+                });
+                B.terminate(`ret ptr %r0`);
+                break;
+            }
+            case "union": {
+                const def = host.unionsById.get(t.unionId);
+                def.arms.forEach((arm, i) => {
+                    const lNext = B.newLabel("dmr.next");
+                    if (arm.kind === "nullT" || arm.kind === "undefinedT") {
+                        const hit = B.tmp();
+                        B.line(`${hit} = icmp eq i32 ${kind}, ${arm.kind === "nullT" ? MESSAGE_KIND.NULL : MESSAGE_KIND.UNDEFINED}`);
+                        const lHit = B.newLabel("dmr.unit");
+                        B.condBr(hit, lHit, lNext);
+                        B.startBlock(lHit);
+                        B.terminate(`ret ptr ${host.unitInstanceRef(t.unionId, i)}`);
+                        B.startBlock(lNext);
+                        return;
+                    }
+                    if (arm.kind !== "record") {
+                        const want = arm.kind === "f64"
+                            ? MESSAGE_KIND.NUMBER
+                            : arm.kind === "bool"
+                                ? MESSAGE_KIND.BOOL
+                                : MESSAGE_KIND.STRING;
+                        const hit = B.tmp();
+                        B.line(`${hit} = icmp eq i32 ${kind}, ${want}`);
+                        const lHit = B.newLabel("dmr.arm");
+                        B.condBr(hit, lHit, lNext);
+                        B.startBlock(lHit);
+                    }
+                    // A record arm that does not match leaves *fail clear for the
+                    // next arm, like the checked conversion's next-arm match.
+                    const v = B.tmp();
+                    B.line(`${v} = call ${this.valTy(arm)} @${this.messageReaderHelper(arm)}(ptr %m, ${S} %n, ptr %fail)`);
+                    if (arm.kind === "record") {
+                        const failed = B.tmp();
+                        B.line(`${failed} = load i1, ptr %fail`);
+                        const lHit = B.newLabel("dmr.arm");
+                        const lMiss = B.newLabel("dmr.miss");
+                        B.condBr(failed, lMiss, lHit);
+                        B.startBlock(lMiss);
+                        B.line(`store i1 false, ptr %fail`);
+                        B.br(lNext);
+                        B.startBlock(lHit);
+                    }
+                    const u = B.tmp();
+                    if (arm.kind === "f64") {
+                        host.declare(`declare ptr @scr_union_new_f64(i32, double)`);
+                        B.line(`${u} = call ptr @scr_union_new_f64(i32 ${i}, double ${v})`);
+                    }
+                    else if (arm.kind === "bool") {
+                        host.declare(`declare ptr @scr_union_new_bool(i32, i1 zeroext)`);
+                        B.line(`${u} = call ptr @scr_union_new_bool(i32 ${i}, i1 ${v})`);
+                    }
+                    else {
+                        const rc = vAdapters(host, arm);
+                        host.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
+                        B.line(`${u} = call ptr @scr_union_new_ref(i32 ${i}, ptr ${v}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host, arm)})`);
+                    }
+                    B.terminate(`ret ptr ${u}`);
+                    B.startBlock(lNext);
+                });
+                B.br(lFail);
+                break;
+            }
+            default:
+                throw new InternalCompilerError(`llvm emitter bug: message reader of ${key}`);
+        }
+        B.startBlock(lFail);
+        B.line(`store i1 true, ptr %fail`);
+        B.terminate(`ret ${retTy} ${dummy}`);
+        this.defs.push(`define internal ${retTy === "i1" ? "zeroext i1" : retTy} @${name}(ptr %m, ${S} %n, ptr %fail) ${FN_ATTRS} { ; message reader for ${llvmCommentText(key)}`, B.render(), `}`, ``);
+        return name;
+    }
     /** The adapter closure body for one TARGET signature: caps[0] is an
      * untraced obj-box owning the dyn function value. */
     dynFuncAdapterHelper(t) {