@scriptc/compiler 0.0.6 → 0.0.8

package/dist/backend/llvm/emitter.js

@@ -426,8 +426,8 @@ const LIB_FN_SYMS = {
     "net.sockUnshift": "scr_net_sock_unshift_bytes",
     "net.sockPipeRes": "scr_http_sock_pipe_res",
     "net.serverEmitConnection": "scr_net_server_emit_connection",
-    "net.getAutoSelTimeout": "scr_net_get_auto_sel_timeout",
-    "net.setAutoSelTimeout": "scr_net_set_auto_sel_timeout",
+    "net.getAutoSelTimeout": "scr_net_get_autosel_timeout",
+    "net.setAutoSelTimeout": "scr_net_set_autosel_timeout",
     "http.reqUrl": "scr_http_req_url",
     "http.reqMethod": "scr_http_req_method",
     "http.reqSocket": "scr_http_req_socket",
@@ -542,6 +542,8 @@ const LIB_FN_SYMS = {
     // (option/DataClone/cycle errors), and new RegExp's eager compile
     // (catchable SyntaxError) — all may-throw generics over the DOM.
     "dyn.objKeys": "scr_dyn_obj_keys",
+    "dyn.hasOwn": "scr_dyn_has_own",
+    "dyn.assign": "scr_dyn_assign",
     "dyn.objValues": "scr_dyn_obj_values",
     "dyn.objEntries": "scr_dyn_obj_entries",
     "dyn.structuredClone": "scr_structured_clone",
@@ -1023,7 +1025,7 @@ class LlEmitter {
                 this.declare(`declare ptr @scr_library_str_in(ptr, i64)`);
             }
             if (this.mod.lib.exports.some((e) => e.params.includes("bytes"))) {
-                this.declare(`declare ptr @scr_library_bytes_in(ptr, i64)`);
+                this.declare(`declare ptr @scr_library_bytes_in(ptr, i64, ptr)`);
             }
             if (this.mod.lib.exports.some((e) => e.returns === "string")) {
                 this.declare(`declare void @scr_library_str_out(ptr, ptr, ptr)`);
@@ -1267,6 +1269,15 @@ class LlEmitter {
             return `  store ${ty} ${zero}, ptr @${mangleGlobal(g.id)} ; ${g.name}`;
         });
         out.push(`define void @${lib.initSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext true) ; init always resets the result arena`, ...globalReleaseLines("ci"), ...zeroStores, `  call void @scr_library_reset()`, ...stamps, `  call void @${mangleFunction(this.mod.entry)}()`, `  call void @scr_library_check_exc()`, `  ret void`, `}`, ``, `define void @${lib.sinkRegisterSymbol}(ptr %fn, ptr %ctx) ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_set_sink(ptr %fn, ptr %ctx)`, `  ret void`, `}`, ``);
+        if (lib.identity !== undefined) {
+            // Profile-declared identity getters (the ask-2 sidecar's boot-time
+            // pairing fence): pure data returns with NO entry prologue — exempt
+            // from the poisoned guard and every runtime touch (ratified), so a
+            // host can read them before init and after a trap. The u64 rides
+            // i64 two's-complement (LLVM integer constants are signed).
+            const buildId = BigInt.asIntN(64, BigInt(`0x${lib.identity.buildId}`)).toString();
+            out.push(`define i64 @${lib.identity.buildIdSymbol}() ${FN_ATTRS} { ; identity getter build_id 0x${lib.identity.buildId}`, `entry:`, `  ret i64 ${buildId}`, `}`, ``, `define i32 @${lib.identity.abiVersionSymbol}() ${FN_ATTRS} { ; identity getter abi_version`, `entry:`, `  ret i32 ${lib.identity.abiVersion}`, `}`, ``);
+        }
         if (lib.resultResetSymbol !== null) {
             out.push(`define void @${lib.resultResetSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false)`, `  call void @scr_library_arena_reset()`, `  ret void`, `}`, ``);
         }
@@ -1277,6 +1288,14 @@ class LlEmitter {
             const params = [];
             const body = [`  call void @scr_library_entry(i1 zeroext ${autoReset ? "true" : "false"})`];
             const args = [];
+            if (e.inboundBytesTrap !== undefined) {
+                // The bytes-in helper's trap message: the compiler-assembled
+                // structured trap-teaching form (0x01 text 0x1F SC4012 0x1F symbol
+                // [0x1F remediation]) — the same bytes the C emission passes, so
+                // the sink message is emission-invariant by construction.
+                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)}"`, ``);
+            }
             e.params.forEach((cls, i) => {
                 switch (cls) {
                     case "f64":
@@ -1310,7 +1329,7 @@ class LlEmitter {
                         break;
                     case "bytes":
                         params.push(`ptr %a${i}_ptr`, `i64 %a${i}_len`);
-                        body.push(`  %c${i} = call ptr @scr_library_bytes_in(ptr %a${i}_ptr, i64 %a${i}_len)`);
+                        body.push(`  %c${i} = call ptr @scr_library_bytes_in(ptr %a${i}_ptr, i64 %a${i}_len, ptr @sc_lib_bytes_trap_${e.symbol})`);
                         args.push(`ptr %c${i}`);
                         break;
                 }
@@ -2549,9 +2568,13 @@ class LlEmitter {
                 if (isRefCounted(v.type))
                     this.moveTemp(v);
                 const shape = this.recordShape(s.shapeId);
-                const iv = shape.indexValue;
+                // Signature-free shapes dispatch over their (one-typed) declared
+                // fields and TRAP on a miss (scr_record_key_miss — JS would add
+                // the property, which a monomorphic struct cannot); overflow
+                // shapes keep the map insert tail.
+                const iv = shape.indexValue ?? shape.fields[0]?.type;
                 if (!iv)
-                    throw new Error(`llvm emitter bug: keyed write on non-overflow shape ${s.shapeId}`);
+                    throw new Error(`llvm emitter bug: keyed write on field-free non-overflow shape ${s.shapeId}`);
                 const vAcc = iv.kind === "f64" ? "f64" : iv.kind === "bool" ? "bool" : "ref";
                 if (s.overflowOnly === true) {
                     // A LITERAL key naming no declared field: a plain overflow
@@ -2562,7 +2585,7 @@ class LlEmitter {
                 }
                 const join = B.newLabel("rks.j");
                 this.declare(`declare zeroext i1 @scr_str_eq(ptr, ptr)`);
-                if (iv.kind === "dyn") {
+                if (iv.kind === "dyn" && shape.indexValue) {
                     // A dyn-valued shape (the C recordKeySetHelper's dyn arm,
                     // inline): declared keys VALIDATE the dyn value against the
                     // field's type first (dynCheck — a mismatched write throws the
@@ -2647,6 +2670,19 @@ class LlEmitter {
                     B.br(join);
                     B.startBlock(ln);
                 }
+                if (!shape.indexValue) {
+                    // The MISS on a fixed shape: release the moved-in value, throw
+                    // the catchable TypeError naming the key (scr_record_key_miss —
+                    // JS would add the property, the documented divergence).
+                    if (isRefCounted(iv))
+                        this.releaseValue(v.name, iv);
+                    this.declare(`declare void @scr_record_key_miss(ptr)`);
+                    B.line(`call void @scr_record_key_miss(ptr ${key.name})`);
+                    B.br(join);
+                    B.startBlock(join);
+                    this.emitPendingCheck();
+                    break;
+                }
                 const ovf = this.recordOvfPtr(obj.name, s.shapeId);
                 this.mapSet(ovf, "str", vAcc, key.name, v.name);
                 B.br(join);
@@ -4042,6 +4078,31 @@ class LlEmitter {
                 // TAG against its unit arms as the test. Pass-through shape: the
                 // result IS the left box. Narrowed shape: the single non-unit
                 // arm's payload extracts (+1 for ref kinds) and the box releases.
+                if (e.left.type.kind === "jsval") {
+                    // The island form: engine nullish test, lazy right (jsval).
+                    const l = this.emitExpr(e.left);
+                    this.moveTemp(l);
+                    this.declare(`declare zeroext i1 @scr_jsval_is_nullish(ptr)`);
+                    const slot = B.slot();
+                    B.entryAllocas.push(`${slot} = alloca ptr`);
+                    const isN = B.tmp();
+                    B.line(`${isN} = call zeroext i1 @scr_jsval_is_nullish(ptr ${l.name})`);
+                    const lu = B.newLabel("nulj.u");
+                    const lv = B.newLabel("nulj.v");
+                    const lj = B.newLabel("nulj.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);
@@ -5788,8 +5849,12 @@ class LlEmitter {
                     ? this.islandAdapter(fn.params.length, fn.ret.kind)
                     : this.islandTypedAdapter(fn);
                 this.declare(`declare ptr @scr_jsval_from_closure(ptr, i32, ptr)`);
+                // ISLAND-REST closures encode a NEGATIVE arity (the C emitter's
+                // rule): the wrapper hands the trailing slot the engine array of
+                // the surplus arguments.
+                const arity = fn.rest === true && fn.restAbi === "jsval" ? -fn.params.length : fn.params.length;
                 const t = B.tmp();
-                B.line(`${t} = call ptr @scr_jsval_from_closure(ptr ${v.name}, i32 ${fn.params.length}, ptr @${adapter})`);
+                B.line(`${t} = call ptr @scr_jsval_from_closure(ptr ${v.name}, i32 ${arity}, ptr @${adapter})`);
                 return this.own({ name: t, type: e.type });
             }
             default: {
@@ -5988,6 +6053,30 @@ class LlEmitter {
                 B.line(`${t} = call ptr @scr_jsval_obj_lit(i32 ${args.length / 2}, ptr ${pack})`);
                 return this.own({ name: t, type: e.type });
             }
+            case "tplStrings": {
+                const pack = argPack(args.map((x) => x.name));
+                this.declare(`declare ptr @scr_jsval_tpl_strings(i32, ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_jsval_tpl_strings(i32 ${args.length / 2}, ptr ${pack})`);
+                return this.own({ name: t, type: e.type });
+            }
+            case "objSpread": {
+                this.declare(`declare ptr @scr_jsval_obj_spread(ptr, ptr)`);
+                return fallible(() => {
+                    const t = B.tmp();
+                    B.line(`${t} = call ptr @scr_jsval_obj_spread(ptr ${a(0)}, ptr ${a(1)})`);
+                    return t;
+                });
+            }
+            case "defineGetter": {
+                // Getter completion for an island literal (the C emitter's
+                // scr_jsval_define_getter shape): defines key a(1) on obj a(0)
+                // as an engine getter invoking a(2); answers the object (+1).
+                this.declare(`declare ptr @scr_jsval_define_getter(ptr, ptr, ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_jsval_define_getter(ptr ${a(0)}, ptr ${a(1)}, ptr ${a(2)})`);
+                return this.own({ name: t, type: e.type });
+            }
             case "arrLit": {
                 const pack = argPack(args.map((x) => x.name));
                 this.declare(`declare ptr @scr_jsval_arr_lit(i32, ptr)`);
@@ -6297,7 +6386,7 @@ class LlEmitter {
         d.push(`  %fnp = getelementptr inbounds %ScrClosure, ptr %c, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`);
         if (ret.async) {
             // The closure returns a +1 ScrPromise; from_promise takes ownership.
-            const tagN = { void: 0, f64: 1, bool: 2, string: 3, jsval: 4, json: 0 }[ret.tag];
+            const tagN = { void: 0, f64: 1, bool: 2, string: 3, jsval: 4, json: 0, dyn: 0 }[ret.tag];
             this.declare(`declare ptr @scr_jsval_from_promise(ptr, i32)`);
             d.push(`  %pr = call ptr %fn(${passed.join(", ")})`, `  %prn = icmp eq ptr %pr, null`, `  br i1 %prn, label %pnull, label %pok`, `pnull:`, `  ret ptr null`, `pok:`, `  %pj = call ptr @scr_jsval_from_promise(ptr %pr, i32 ${tagN})`, `  ret ptr %pj`);
         }
@@ -6322,6 +6411,13 @@ class LlEmitter {
                     this.declare(`declare void @scr_str_release(ptr)`);
                     d.push(`  %r = call ptr %fn(${passed.join(", ")})`, `  %rn = icmp eq ptr %r, null`, `  br i1 %rn, label %snull, label %sok`, `snull:`, `  ret ptr null`, `sok:`, `  %j = call ptr @scr_jsval_from_str(ptr %r)`, `  call void @scr_str_release(ptr %r)`, `  ret ptr %j`);
                     break;
+                case "dyn":
+                    // A checked-dynamic (+1 DOM) result: deep copy into the engine
+                    // (the jsMarshal dyn rule); NULL is the throw-path dummy.
+                    this.declare(`declare ptr @scr_jsval_from_dyn(ptr)`);
+                    this.declare(`declare void @scr_dyn_release(ptr)`);
+                    d.push(`  %r = call ptr %fn(${passed.join(", ")})`, `  %rn = icmp eq ptr %r, null`, `  br i1 %rn, label %dnull, label %dok`, `dnull:`, `  ret ptr null`, `dok:`, `  %j = call ptr @scr_jsval_from_dyn(ptr %r)`, `  call void @scr_dyn_release(ptr %r)`, `  ret ptr %j`);
+                    break;
                 case "json": {
                     // A JSON-safe composite return: the jsMarshal path — the type-
                     // directed serializer, then the engine's JSON parser (deep