@scriptc/compiler 0.0.9 → 0.0.10

package/dist/backend/llvm/emitter.js

@@ -197,6 +197,11 @@ const LIB_FN_SYMS = {
     "bytes.compareChk": "scr_bytes_compare_chk",
     "buffer.newStringFail": "scr_buffer_new_string_fail",
     "fs.toUnixTimestamp": "scr_fs_to_unix_timestamp",
+    "fs.existsChk": "scr_fs_exists_async",
+    "fs.mkdtempSyncChk": "scr_fs_mkdtemp_sync_chk",
+    "net.connectAttempt": "scr_net_connect_attempt",
+    "fs.lchmodSyncChk": "scr_fs_lchmod_sync_chk",
+    "fsp.lchmodChk": "scr_fsp_lchmod_chk",
     "fs.readFileSyncBuf": "scr_fs_read_file_bytes",
     "fs.readFileSyncBytes": "scr_fs_read_file_bytes",
     "fs.writeFileSyncBytes": "scr_fs_write_file_bytes",
@@ -342,9 +347,10 @@ const LIB_FN_SYMS = {
     // ambient-this read never throw. The fs dyn read is the sync-fs story.
     "json.parse": "scr_json_parse",
     "dyn.keySet": "scr_dyn_key_set",
+    "dyn.iterPack": "scr_dyn_iter_pack",
     "dyn.defineProps": "scr_dyn_define_props",
     "dyn.typeof": "scr_dyn_typeof",
-    "dyn.toString": "scr_dyn_to_string",
+    "dyn.toString": "scr_dyn_to_string_method",
     "dyn.this": "scr_dyn_this_get",
     "insp.dyn": "scr_insp_dyn",
     "insp.dynS": "scr_insp_dyn_s",
@@ -559,6 +565,14 @@ const LIB_FN_SYMS = {
     "dyn.objKeys": "scr_dyn_obj_keys",
     "dyn.hasOwn": "scr_dyn_has_own",
     "dyn.assign": "scr_dyn_assign",
+    // variadic Object.assign: the source pack (push never throws; the
+    // spread flatten throws V8's spread-call TypeErrors) and the final
+    // left-to-right copy (ToObject TypeError on a nullish target).
+    "dyn.packPush": "scr_dyn_pack_push",
+    "dyn.packPushSpread": "scr_dyn_pack_push_spread",
+    "dyn.packPushSpreadIter": "scr_dyn_pack_push_spread_iter",
+    "dyn.assignAll": "scr_dyn_assign_all",
+    "dyn.objCreateNullProto": "scr_dyn_new_obj_null_proto",
     "dyn.objValues": "scr_dyn_obj_values",
     "dyn.objEntries": "scr_dyn_obj_entries",
     "dyn.structuredClone": "scr_structured_clone",
@@ -603,7 +617,8 @@ const USES_TIMERS_LIB_FNS = new Set([
     "stream.finished", "stream.finishedDyn", "stream.pipeline", "stream.pipelineDyn",
     "sp.finished", "sp.pipeline",
     "net.listen", "net.listenCb", "net.listenOpts", "net.listenOptsCb",
-    "net.connect", "net.connectCb", "net.connectLookup",
+    "net.connect", "net.connectCb", "net.connectLookup", "net.connectAttempt",
+    "fs.existsChk",
     "http.createServer", "http.createServerEmpty",
     "http.request", "http.requestCb", "http.requestUrl", "http.requestUrlCb",
     "http.requestConn", "http.requestConnCb",
@@ -4178,6 +4193,33 @@ class LlEmitter {
                     B.line(`${t} = load ptr, ptr ${slot}`);
                     return this.own({ name: t, type: e.type });
                 }
+                if (e.left.type.kind === "dyn") {
+                    // The checked-dynamic form: the runtime kind decides (UNDEF/
+                    // NULL take the default; a wrapped island value asks the
+                    // engine); the right runs lazily in its branch (already dyn).
+                    const l = this.emitExpr(e.left);
+                    this.moveTemp(l);
+                    this.declare(`declare zeroext i1 @scr_dyn_is_nullish(ptr)`);
+                    const slot = B.slot();
+                    B.entryAllocas.push(`${slot} = alloca ptr`);
+                    const isN = B.tmp();
+                    B.line(`${isN} = call zeroext i1 @scr_dyn_is_nullish(ptr ${l.name})`);
+                    const lu = B.newLabel("nuld.u");
+                    const lv = B.newLabel("nuld.v");
+                    const lj = B.newLabel("nuld.j");
+                    B.condBr(isN, lu, lv);
+                    B.startBlock(lu);
+                    this.releaseValue(l.name, e.left.type);
+                    this.emitBranchInto(slot, e.right);
+                    B.br(lj);
+                    B.startBlock(lv);
+                    B.line(`store ptr ${l.name}, ptr ${slot}`);
+                    B.br(lj);
+                    B.startBlock(lj);
+                    const t = B.tmp();
+                    B.line(`${t} = load ptr, ptr ${slot}`);
+                    return this.own({ name: t, type: e.type });
+                }
                 if (e.left.type.kind !== "union")
                     throw new Error("llvm emitter bug: nullish left is not a union");
                 const def = this.unionsById.get(e.left.type.unionId);
@@ -5500,6 +5542,16 @@ class LlEmitter {
                 B.line(`${t} = call ptr @${conv}(${valTy} ${v.name})`);
                 return this.own({ name: t, type: e.type });
             }
+            case "dynFromJsval": {
+                // Island value → DOM: the by-reference wrap (scr_dyn_from_jsval
+                // retains the cell in; engine scalars normalize to native DOM
+                // kinds at wrap time). Operand borrowed, result +1, never throws.
+                const v = this.emitExpr(e.value);
+                this.declare(`declare ptr @scr_dyn_from_jsval(ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_dyn_from_jsval(ptr ${v.name})`);
+                return this.own({ name: t, type: e.type });
+            }
             case "caughtToDyn": {
                 // A catch binding flowing into an `unknown` slot: the snapshot's
                 // runtime kind converts through the interned helper (+1 fresh
@@ -5681,7 +5733,8 @@ class LlEmitter {
                 B.startBlock(lNotObj);
                 const isArr = B.tmp();
                 B.line(`${isArr} = icmp eq i32 ${kd}, ${DK.ARR}`);
-                B.condBr(isArr, lArr, lj);
+                const lNotArr = B.newLabel("dhk.na");
+                B.condBr(isArr, lArr, lNotArr);
                 B.startBlock(lArr);
                 if (e.key === "length") {
                     B.line(`store i1 true, ptr ${slot}`);
@@ -5696,9 +5749,20 @@ class LlEmitter {
                     B.line(`store i1 ${inR}, ptr ${slot}`);
                 }
                 B.br(lj);
+                // An ISLAND-held receiver fences loudly (Node asks the real
+                // engine object — `false` would be a silent wrong answer); the
+                // helper answers false for every other kind, so this arm is a
+                // plain unconditional call.
+                B.startBlock(lNotArr);
+                this.declare(`declare zeroext i1 @scr_dyn_isl_fence(ptr, ptr)`);
+                const fenced = B.tmp();
+                B.line(`${fenced} = call zeroext i1 @scr_dyn_isl_fence(ptr ${d.name}, ptr ${this.cstr("'in'")})`);
+                B.line(`store i1 ${fenced}, ptr ${slot}`);
+                B.br(lj);
                 B.startBlock(lj);
                 const raw = B.tmp();
                 B.line(`${raw} = load i1, ptr ${slot}`);
+                this.emitPendingCheck();
                 if (!e.negated)
                     return { name: raw, type: e.type };
                 const neg = B.tmp();
@@ -5778,13 +5842,18 @@ class LlEmitter {
                 }
                 else if (e.test === "error") {
                     // `u instanceof Error`: the DOM's error encoding — an object
-                    // carrying the reserved "%error" marker key.
+                    // carrying the reserved "%error" marker key — or a real engine
+                    // Error held by reference (the isl helper answers false for
+                    // every non-JSVAL kind, so the call is unconditional).
                     const kd = this.dynKind(d.name);
                     const isObj = B.tmp();
                     B.line(`${isObj} = icmp eq i32 ${kd}, ${DK.OBJ}`);
                     const slot = B.slot();
                     B.entryAllocas.push(`${slot} = alloca i1`);
-                    B.line(`store i1 false, ptr ${slot}`);
+                    this.declare(`declare zeroext i1 @scr_dyn_isl_is_error(ptr)`);
+                    const isl = B.tmp();
+                    B.line(`${isl} = call zeroext i1 @scr_dyn_isl_is_error(ptr ${d.name})`);
+                    B.line(`store i1 ${isl}, ptr ${slot}`);
                     const lObj = B.newLabel("dts.o");
                     const lj = B.newLabel("dts.j");
                     B.condBr(isObj, lObj, lj);
@@ -5818,13 +5887,33 @@ class LlEmitter {
                         }
                         return acc;
                     };
+                    // ISLAND-held nodes route the tests that depend on the engine's
+                    // answer through the scr_dyn_isl_* helpers (false on every
+                    // other kind — the calls stay unconditional and branch-free).
+                    const orIsl = (acc, helper, arg) => {
+                        this.declare(`declare zeroext i1 @${helper}(ptr${arg !== undefined ? ", ptr" : ""})`);
+                        const c = B.tmp();
+                        B.line(`${c} = call zeroext i1 @${helper}(ptr ${d.name}${arg !== undefined ? `, ptr ${arg}` : ""})`);
+                        const o = B.tmp();
+                        B.line(`${o} = or i1 ${acc}, ${c}`);
+                        return o;
+                    };
                     if (e.test === "nullish") {
                         test = oneOf([DK.UNDEF, DK.NULL]);
                     }
                     else if (e.test === "object") {
                         // `typeof v === "object"`: objects, arrays, bytes, native
-                        // handles, promises, AND null.
-                        test = oneOf([DK.OBJ, DK.ARR, DK.BYTES, DK.HANDLE, DK.PROMISE, DK.NULL]);
+                        // handles, promises, AND null — engine-held objects by the
+                        // engine's own typeof.
+                        test = orIsl(oneOf([DK.OBJ, DK.ARR, DK.BYTES, DK.HANDLE, DK.PROMISE, DK.NULL]), "scr_dyn_isl_typeof_is", this.cstr("object"));
+                    }
+                    else if (e.test === "array") {
+                        // Array.isArray: the DOM's array kind, or the engine's own
+                        // answer for an engine-held value.
+                        test = orIsl(oneOf([DK.ARR]), "scr_dyn_isl_is_array");
+                    }
+                    else if (e.test === "function") {
+                        test = orIsl(oneOf([DK.FUNC]), "scr_dyn_isl_typeof_is", this.cstr("function"));
                     }
                     else {
                         const kindOf = {
@@ -5834,8 +5923,6 @@ class LlEmitter {
                             undefined: DK.UNDEF,
                             null: DK.NULL,
                             bytes: DK.BYTES,
-                            array: DK.ARR,
-                            function: DK.FUNC,
                         };
                         test = oneOf([kindOf[e.test]]);
                     }
@@ -5947,6 +6034,13 @@ class LlEmitter {
                 return simple("scr_jsval_from_bool", "i1", false);
             case "string":
                 return simple("scr_jsval_from_str", "ptr", false);
+            case "dyn":
+                // A CHECKED-DYNAMIC (DOM) value entering the island: deep copy,
+                // data kinds only — boxed functions/handles/promises throw the
+                // catchable TypeError in the runtime, and a wrapped island value
+                // unwraps to the SAME engine value (the identity round trip).
+                // The C emitter's rule, mirrored.
+                return simple("scr_jsval_from_dyn", "ptr", true);
             case "bytes":
                 // A typed array crossing IN: a COPY (the boundary's copy stance).
                 return simple("scr_jsval_from_bytes", "ptr", true);
@@ -8666,6 +8760,54 @@ class LlEmitter {
             this.emitPendingCheck();
             return out;
         }
+        if (e.fn === "error.propTypeThrow") {
+            // The property flavor of argTypeThrow — same always-throw shape.
+            const an = this.emitExpr(e.args[0]);
+            const ex = this.emitExpr(e.args[1]);
+            const got = this.emitExpr(e.args[2]);
+            this.declare(`declare void @scr_throw_prop_type(ptr, ptr, ptr)`);
+            B.line(`call void @scr_throw_prop_type(ptr ${an.name}, ptr ${ex.name}, ptr ${got.name})`);
+            const ty = this.llType(e.type);
+            if (ty === "void") {
+                this.emitPendingCheck();
+                return { name: "", type: e.type };
+            }
+            const dummy = ty === "double" ? f64Lit(0) : ty === "i1" ? "false" : "null";
+            const out = this.own({ name: dummy, type: e.type });
+            this.emitPendingCheck();
+            return out;
+        }
+        {
+            // The fs validation-ladder Chk forms that ALWAYS throw (a
+            // validation error or the trailing compiler-rendered fence): every
+            // argument is a ptr (dyns + the fence string), and the typed dummy
+            // is abandoned by the pending check's unwind.
+            const FS_CHK_THROW_SYMS = {
+                "fs.mkdtempChk": "scr_fs_mkdtemp_chk",
+                "fs.readFileChk": "scr_fs_read_file_chk",
+                "fs.opendirChk": "scr_fs_opendir_chk",
+                "fs.watchFileChk": "scr_fs_watch_file_chk",
+                "fs.lchmodChk": "scr_fs_lchmod_chk",
+                "fs.readChk": "scr_fs_read_chk",
+                "fs.streamOptsChk": "scr_fs_stream_opts_chk",
+                "net.connectOptsChk": "scr_net_connect_opts_chk",
+            };
+            const sym = FS_CHK_THROW_SYMS[e.fn];
+            if (sym !== undefined) {
+                const args = e.args.map((a) => this.emitExpr(a));
+                this.declare(`declare void @${sym}(${args.map(() => "ptr").join(", ")})`);
+                B.line(`call void @${sym}(${args.map((a) => `ptr ${a.name}`).join(", ")})`);
+                const ty = this.llType(e.type);
+                if (ty === "void") {
+                    this.emitPendingCheck();
+                    return { name: "", type: e.type };
+                }
+                const dummy = ty === "double" ? f64Lit(0) : ty === "i1" ? "false" : "null";
+                const out = this.own({ name: dummy, type: e.type });
+                this.emitPendingCheck();
+                return out;
+            }
+        }
         if (e.fn === "error.nodeThrow") {
             // The compiler-resolved Node-parity throw (always throws — the
             // typed dummy is abandoned by the pending check's unwind).