@scriptc/compiler 0.0.9 → 0.0.11

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",
@@ -397,6 +403,8 @@ const LIB_FN_SYMS = {
     // generic pending check; loop liveness rides USES_TIMERS_LIB_FNS.
     "readable.push": "scr_stream_push",
     "readable.pushStr": "scr_stream_push_str",
+    "readable.pushStrEnc": "scr_stream_push_str_enc",
+    "readable.pushEncoding": "scr_stream_set_push_encoding",
     "readable.pushNull": "scr_stream_push_null",
     "readable.pushDyn": "scr_stream_push_dyn",
     "readable.unshift": "scr_stream_unshift",
@@ -498,6 +506,11 @@ const LIB_FN_SYMS = {
     // stream/promises' finished form (+1 promise; may-throw pending check;
     // the pipeline form needs the stream-array compound and emits below).
     "sp.finished": "scr_sp_finished",
+    // stream/consumers' promise consumers (+1 promises; may-throw pending
+    // check — the 'newListener' meta emit can run user code).
+    "sc.text": "scr_sc_text",
+    "sc.json": "scr_sc_json",
+    "sc.buffer": "scr_sc_buffer",
     "dc.channel": "scr_dc_channel",
     "dc.subscribe": "scr_dc_subscribe",
     "dc.unsubscribe": "scr_dc_unsubscribe",
@@ -559,6 +572,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",
@@ -590,7 +611,8 @@ const USES_TIMERS_LIB_FNS = new Set([
     "readable.init", "writable.init", "duplex.init", "transform.init", "passthrough.init",
     "readable.newDyn", "writable.newDyn", "duplex.newDyn", "transform.newDyn", "passthrough.newDyn",
     "readable.initDyn", "writable.initDyn", "duplex.initDyn", "transform.initDyn", "passthrough.initDyn",
-    "readable.push", "readable.pushStr", "readable.pushNull", "readable.pushU", "readable.pushDyn",
+    "readable.push", "readable.pushStr", "readable.pushStrEnc", "readable.pushEncoding",
+    "readable.pushNull", "readable.pushU", "readable.pushDyn",
     "readable.unshift", "readable.unshiftStr", "readable.read", "readable.setEncoding",
     "readable.nextChunk", "readable.nextChunkDyn", "readable.fromArr", "readable.resume",
     "readable.pipe", "readable.unpipe",
@@ -602,8 +624,10 @@ const USES_TIMERS_LIB_FNS = new Set([
     "process.activeResources",
     "stream.finished", "stream.finishedDyn", "stream.pipeline", "stream.pipelineDyn",
     "sp.finished", "sp.pipeline",
+    "sc.text", "sc.json", "sc.buffer",
     "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",
@@ -1055,6 +1079,12 @@ class LlEmitter {
             if (this.mod.lib.exports.some((e) => e.params.includes("bytes"))) {
                 this.declare(`declare ptr @scr_library_bytes_in(ptr, i64, ptr)`);
             }
+            if (this.mod.lib.exports.some((e) => e.params.includes("i64"))) {
+                this.declare(`declare double @scr_library_i64_in(i64, ptr)`);
+            }
+            if (this.mod.lib.exports.some((e) => e.params.includes("u64"))) {
+                this.declare(`declare double @scr_library_u64_in(i64, ptr)`);
+            }
             if (this.mod.lib.exports.some((e) => e.returns === "string")) {
                 this.declare(`declare void @scr_library_str_out(ptr, ptr, ptr)`);
             }
@@ -1363,6 +1393,14 @@ class LlEmitter {
                 const trapBytes = Buffer.byteLength(e.inboundBytesTrap, "utf8");
                 out.push(`@sc_lib_bytes_trap_${e.symbol} = internal constant [${trapBytes + 1} x i8] c"${llStrBytes(e.inboundBytesTrap)}"`, ``);
             }
+            if (e.inboundIntTrap !== undefined) {
+                // The i64/u64-in helpers' host-contract trap message (ask 4): an
+                // inbound integer past ±(2^53−1) cannot ride f64 exactly. Same
+                // assembled structured form, same SC4012 code, same
+                // emission-invariance argument as the bytes trap.
+                const trapBytes = Buffer.byteLength(e.inboundIntTrap, "utf8");
+                out.push(`@sc_lib_int_trap_${e.symbol} = internal constant [${trapBytes + 1} x i8] c"${llStrBytes(e.inboundIntTrap)}"`, ``);
+            }
             e.params.forEach((cls, i) => {
                 switch (cls) {
                     case "f64":
@@ -1389,6 +1427,19 @@ class LlEmitter {
                         body.push(`  %c${i} = sitofp i32 %a${i} to double`);
                         args.push(`double %c${i}`);
                         break;
+                    case "i64":
+                        // Inbound declared-integer edge (ask 4): the helper converts
+                        // exactly or delivers the host-contract trap (past ±(2^53−1)
+                        // the value cannot ride f64 without silent rounding).
+                        params.push(`i64 %a${i}`);
+                        body.push(`  %c${i} = call double @scr_library_i64_in(i64 %a${i}, ptr @sc_lib_int_trap_${e.symbol})`);
+                        args.push(`double %c${i}`);
+                        break;
+                    case "u64":
+                        params.push(`i64 %a${i}`);
+                        body.push(`  %c${i} = call double @scr_library_u64_in(i64 %a${i}, ptr @sc_lib_int_trap_${e.symbol})`);
+                        args.push(`double %c${i}`);
+                        break;
                     case "string":
                         params.push(`ptr %a${i}_ptr`, `i64 %a${i}_len`);
                         body.push(`  %c${i} = call ptr @scr_library_str_in(ptr %a${i}_ptr, i64 %a${i}_len)`);
@@ -1415,6 +1466,16 @@ class LlEmitter {
                     retType = "double";
                     body.push(`  %r = call double ${target}(${callArgs})`, `  call void @scr_library_check_exc()`, `  ret double %r`);
                     break;
+                case "i64":
+                case "u64":
+                    // The outbound declared-integer edge (ask 4): every value
+                    // reaching this return was PROVEN whole and inside the class's
+                    // range at compile time, so the fp-to-int conversion is exact
+                    // by construction — the crossing carries the mathematically
+                    // exact integer the f64 held.
+                    retType = "i64";
+                    body.push(`  %r = call double ${target}(${callArgs})`, `  call void @scr_library_check_exc()`, `  %z = ${e.returns === "i64" ? "fptosi" : "fptoui"} double %r to i64`, `  ret i64 %z`);
+                    break;
                 case "bool":
                     retType = "i8";
                     body.push(`  %r = call i1 ${target}(${callArgs})`, `  call void @scr_library_check_exc()`, `  %z = zext i1 %r to i8`, `  ret i8 %z`);
@@ -4178,6 +4239,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 +5588,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 +5779,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 +5795,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 +5888,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 +5933,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 +5969,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 +6080,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);
@@ -8161,6 +8301,10 @@ class LlEmitter {
                 return call("scr_bytes_get", "double (ptr, double)", `ptr ${r.name}, double ${args[0].name}`, false, false);
             case "slice":
                 return call("scr_bytes_slice", "ptr (ptr, double, double)", `ptr ${r.name}, double ${args[0]?.name ?? f64Lit(0)}, double ${args[1]?.name ?? F64_INF}`, true, false);
+            case "subarray":
+                // A +1 VIEW aliasing the receiver's storage (subarray / Buffer's
+                // slice); same index defaults as slice.
+                return call("scr_bytes_subarray", "ptr (ptr, double, double)", `ptr ${r.name}, double ${args[0]?.name ?? f64Lit(0)}, double ${args[1]?.name ?? F64_INF}`, true, false);
             case "setFrom":
                 // dst.set(src, offset?) — void; throws Node's RangeError on
                 // overflow.
@@ -8214,6 +8358,10 @@ class LlEmitter {
                 B.line(`${t} = fcmp one double ${idx.name}, ${f64Lit(-1)}`);
                 return { name: t, type: e.type };
             }
+            case "fillElem":
+                // Per-element TypedArray fill (non-u8): slice-style index
+                // defaults, never throws; the receiver comes back +1.
+                return call("scr_bytes_fill_elem", "ptr (ptr, double, double, double)", `ptr ${r.name}, double ${args[0].name}, double ${args[1]?.name ?? f64Lit(0)}, double ${args[2]?.name ?? F64_INF}`, true, false);
             case "fill":
             case "fillNum": {
                 const sym = method === "fill" ? "scr_bytes_fill" : "scr_bytes_fill_num";
@@ -8666,6 +8814,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).
@@ -10417,11 +10613,12 @@ class LlEmitter {
         if (MAY_THROW_LIB_FNS.has(e.fn) && LIB_FN_SYMS[e.fn] === undefined) {
             throw new LlvmUnsupportedError(`libCall:${e.fn}`, e.loc);
         }
-        if (e.fn === "math.floor") {
+        if (e.fn === "math.floor" || e.fn === "math.trunc" || e.fn === "math.ceil") {
+            const intr = e.fn === "math.floor" ? "floor" : e.fn === "math.trunc" ? "trunc" : "ceil";
             const v = this.emitExpr(e.args[0]);
-            this.declare(`declare double @llvm.floor.f64(double)`);
+            this.declare(`declare double @llvm.${intr}.f64(double)`);
             const t = B.tmp();
-            B.line(`${t} = call double @llvm.floor.f64(double ${v.name})`);
+            B.line(`${t} = call double @llvm.${intr}.f64(double ${v.name})`);
             return { name: t, type: e.type };
         }
         if (e.fn === "math.abs") {