@scriptc/compiler 0.4.0 → 0.4.1

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,14 @@ 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",
 };
 export const DYN_KIND = {
     NULL: 0,
@@ -520,6 +529,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 +1386,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 +1982,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 +2043,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 +2128,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;
                 }