@scriptc/compiler 0.1.2 → 0.1.4

package/dist/ir/ir.js

@@ -14,8 +14,11 @@ const POINTER_HANDLE_KINDS = [
     "httpRes",
     "httpClientReq",
     "secureCtx",
+    "cryptoHash",
+    "cryptoHmac",
     "fsWatcher",
     "childStream",
+    "childWriter",
 ];
 function irKindSet(kinds) {
     return new Set(kinds);
@@ -30,6 +33,7 @@ export const HANDLE_KINDS = irKindSet(HANDLE_KIND_LIST);
 /** The IR kinds represented as pointers in both native backends. */
 const POINTER_KIND_LIST = [
     "string",
+    "bigint",
     "array",
     "map",
     "set",
@@ -42,6 +46,7 @@ const POINTER_KIND_LIST = [
     "func",
     "object",
     "classval",
+    "moduleNs",
     "record",
     "union",
     "dyn",
@@ -57,6 +62,7 @@ export const POINTER_KINDS = irKindSet(POINTER_KIND_LIST);
  * until its one retain/release family is named here. */
 export const RUNTIME_RC_STEMS = {
     f64: "",
+    bigint: "scr_bigint",
     date: "",
     string: "scr_str",
     bool: "",
@@ -82,12 +88,16 @@ export const RUNTIME_RC_STEMS = {
     httpRes: "scr_http_res",
     httpClientReq: "scr_http_client",
     childStream: "scr_child_stream",
+    childWriter: "scr_child_writer",
     procStream: "",
     fsWatcher: "scr_watcher",
     secureCtx: "scr_secure_ctx",
+    cryptoHash: "scr_crypto_hash",
+    cryptoHmac: "scr_crypto_hash",
     func: "scr_closure",
     object: "",
     classval: "scr_classobj",
+    moduleNs: "scr_str",
     record: "",
     union: "scr_union",
     dyn: "scr_dyn",
@@ -124,13 +134,16 @@ export const REF_TRUTHY_KINDS = new Set([
     "symbol",
     "date", "array", "map", "set", "regex", "url", "searchParams", "stats", "fileHandle", "spawnRes", "child",
     "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq",
-    "secureCtx", "fsWatcher", "childStream", "procStream", "bytes", "func", "object", "record", "promise",
+    "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "procStream", "bytes", "func", "object", "record", "promise",
     // A generator object is a JS object: always truthy.
     "generator",
     // A class object is a JS object (constructors are functions): always truthy.
     "classval",
+    // A module namespace object is always truthy.
+    "moduleNs",
 ]);
 export const F64 = { kind: "f64" };
+export const BIGINT_T = { kind: "bigint" };
 export const DATE_T = { kind: "date" };
 export const BYTES_U8 = { kind: "bytes", elem: "u8" };
 export const STRING = { kind: "string" };
@@ -153,8 +166,11 @@ export const HTTPREQ_T = { kind: "httpReq" };
 export const HTTPRES_T = { kind: "httpRes" };
 export const HTTPCLIENTREQ_T = { kind: "httpClientReq" };
 export const SECURECTX_T = { kind: "secureCtx" };
+export const CRYPTOHASH_T = { kind: "cryptoHash" };
+export const CRYPTOHMAC_T = { kind: "cryptoHmac" };
 export const FSWATCHER_T = { kind: "fsWatcher" };
 export const CHILDSTREAM_T = { kind: "childStream" };
+export const CHILDWRITER_T = { kind: "childWriter" };
 export const PROCSTREAM_T = { kind: "procStream" };
 export const VOID = { kind: "void" };
 export const DYN = { kind: "dyn" };
@@ -177,6 +193,7 @@ export function isUnitType(t) {
 export function isSupportedArrayElem(t) {
     switch (t.kind) {
         case "f64":
+        case "bigint":
         case "bool":
         case "string":
         case "array":
@@ -192,6 +209,7 @@ export function isSupportedArrayElem(t) {
         case "netServer":
         case "symbol":
         case "classval":
+        case "moduleNs":
             return true;
         default:
             return false;
@@ -239,6 +257,7 @@ export function isSupportedSetElem(t) {
 export function isSupportedMapValue(t) {
     switch (t.kind) {
         case "f64":
+        case "bigint":
         case "string":
         case "bool":
         case "record":
@@ -329,6 +348,7 @@ export function typeKey(t) {
         return t.kind;
     switch (t.kind) {
         case "f64":
+        case "bigint":
         case "date":
         case "string":
         case "bool":
@@ -354,11 +374,13 @@ export function typeKey(t) {
         case "set":
             return `set<${typeKey(t.elem)}>`;
         case "func":
-            return `func(${[...t.params.map(typeKey), ...(t.rest ? [t.restAbi === "jsval" ? "...jsval[]" : "...dyn[]"] : [])].join(",")})=>${typeKey(t.ret)}`;
+            return `func(${[...t.params.map(typeKey), ...(t.rest ? [t.restAbi === "jsval" ? "...jsval[]" : t.restAbi === "typed" ? "...typed[]" : "...dyn[]"] : [])].join(",")})=>${typeKey(t.ret)}`;
         case "object":
             return `object:${t.className}`;
         case "classval":
             return `classval:${t.className}`;
+        case "moduleNs":
+            return `moduleNs:${t.moduleId}`;
         case "record":
             return `record:${t.shapeId}`;
         case "union":
@@ -388,6 +410,7 @@ export function typeEquals(a, b) {
         return (b.kind === "func" &&
             a.params.length === b.params.length &&
             (a.rest === true) === (b.rest === true) &&
+            a.restAbi === b.restAbi &&
             a.params.every((p, i) => typeEquals(p, b.params[i])) &&
             typeEquals(a.ret, b.ret));
     }
@@ -395,6 +418,8 @@ export function typeEquals(a, b) {
         return b.kind === "object" && a.className === b.className;
     if (a.kind === "classval")
         return b.kind === "classval" && a.className === b.className;
+    if (a.kind === "moduleNs")
+        return b.kind === "moduleNs" && a.moduleId === b.moduleId;
     // The frontend deduplicates shapes structurally (one shapeId per canonical
     // field list), so id equality IS structural equality.
     if (a.kind === "record")
@@ -746,6 +771,7 @@ function isJsonSafeAt(t, getRecord, getUnion, stringify, undefinedAllowed, visit
         // Symbols are DROPPED by Node's stringify (undefined at the top level,
         // omitted as object values) — silent divergence banned; rejected.
         case "symbol":
+        case "bigint":
         // Typed arrays stringify as index-keyed objects ({"0":1,...}) and
         // Buffers as {type:"Buffer",data:[...]} in Node — neither shape is
         // representable type-directedly; rejected like Maps.
@@ -755,6 +781,7 @@ function isJsonSafeAt(t, getRecord, getUnion, stringify, undefinedAllowed, visit
         case "caught":
         case "promise":
         case "generator":
+        case "moduleNs":
         case "void":
             return false;
         // Record fields drop undefined. Stringification also represents it in
@@ -1065,6 +1092,10 @@ export function canDynCheckTo(t, getRecord, getUnion) {
  * back). */
 export function canBoxFuncIntoDyn(t, getRecord, getUnion) {
     return (t.kind === "func" &&
+        // Only the legacy hidden-dyn rest ABI has a checked-dynamic call thunk.
+        // Typed rest stays static (its trailing array is compiler-packed), and
+        // island rest has its separate engine host-callback adapter.
+        (t.rest !== true || t.restAbi === undefined) &&
         // A jsval (island) param converts through scr_jsval_from_dyn in the
         // thunk (wrapped cells unwrap by reference, dyn data deep-copies) —
         // the checker-'any' callback params of the routed-dispatch lane
@@ -1630,11 +1661,14 @@ export function moduleUsesChildProcess(mod) {
         const node = v;
         if (node.kind === "libCall" &&
             typeof node.fn === "string" &&
-            (node.fn.startsWith("cp.") || node.fn.startsWith("child.") || node.fn.startsWith("spawnRes."))) {
+            (node.fn.startsWith("cp.") || node.fn.startsWith("child.") || node.fn.startsWith("writer.") || node.fn.startsWith("spawnRes.") ||
+                node.fn === "process.forkTarget" || node.fn === "process.connected" || node.fn === "process.send" ||
+                node.fn === "process.sendCb" || node.fn === "process.disconnect" || node.fn === "process.onMessage" ||
+                node.fn === "process.onDisconnect")) {
             found = true;
             return;
         }
-        if (node.kind === "child" || node.kind === "childStream" || node.kind === "spawnRes") {
+        if (node.kind === "child" || node.kind === "childStream" || node.kind === "childWriter" || node.kind === "spawnRes") {
             found = true;
             return;
         }
@@ -1719,6 +1753,31 @@ export function moduleUsesSymbol(mod) {
     visit(mod);
     return found;
 }
+/** True when bigint runtime operations or bigint-typed storage appears in
+ * the IR. The type check keeps retain/release references link-safe even
+ * when a producing statement was replaced by a runtime fence. */
+export function moduleUsesBigInt(mod) {
+    let found = false;
+    const visit = (v) => {
+        if (found || v === null || typeof v !== "object")
+            return;
+        if (Array.isArray(v)) {
+            for (const item of v)
+                visit(item);
+            return;
+        }
+        const node = v;
+        if (node.kind === "bigint" ||
+            (node.kind === "libCall" && typeof node.fn === "string" && node.fn.startsWith("bigint."))) {
+            found = true;
+            return;
+        }
+        for (const key of Object.keys(v))
+            visit(v[key]);
+    };
+    visit(mod);
+    return found;
+}
 /** True when the module uses the URLSearchParams surface — sp.* libCalls,
  * the url.searchParams getter, or a searchParams-kind type anywhere on
  * the IR (a fenced statement can leave a typed local whose release call
@@ -2056,6 +2115,13 @@ const LIB_MODE_REFUSED_PREFIXES = [
     // exclude — refuse the surface like the rest of the event-loop family.
     ["fs.existsChk", "the async fs callback surface (fs.exists)"],
     ["fs.renameCb", "the async fs callback surface (fs.rename)"],
+    ["zlib.deflateCb", "the async node:zlib callback surface"],
+    ["zlib.inflateCb", "the async node:zlib callback surface"],
+    ["zlib.deflateRawCb", "the async node:zlib callback surface"],
+    ["zlib.inflateRawCb", "the async node:zlib callback surface"],
+    ["zlib.gzipCb", "the async node:zlib callback surface"],
+    ["zlib.gunzipCb", "the async node:zlib callback surface"],
+    ["zlib.unzipCb", "the async node:zlib callback surface"],
     ["process.stdoutWriteBytesCb", "process.stdout.write completion callbacks"],
     ["process.stderrWriteBytesCb", "process.stderr.write completion callbacks"],
     ["timers.", "the timers surface (setTimeout family)"],
@@ -2103,6 +2169,7 @@ const LIB_MODE_REFUSED_KINDS = new Map([
     ["child", "the child_process surface"],
     ["spawnRes", "the child_process surface"],
     ["childStream", "the child_process surface"],
+    ["childWriter", "the child_process surface"],
     ["netServer", "the node:net surface"],
     ["netSocket", "the node:net surface"],
     ["http2Session", "the node:http2 surface"],
@@ -2238,6 +2305,7 @@ export const LIB_NONDETERMINISTIC_PREFIXES = [
     ["process.kill", "process authority (kill)"],
     ["process.umask", "process authority (umask)"],
     ["process.exit", "process authority (exit)"],
+    ["process.setExitCode", "process authority (exit status)"],
     ["fs.", "the filesystem"],
     ["os.", "machine/OS identity"],
     // The CA-store surface reads the host's certificate bundle (and the
@@ -2275,12 +2343,25 @@ export function moduleLibNondeterministicSurface(mod) {
 /** The may-throw seed: libCall members that can raise. Every fs.* member
  * EXCEPT existsSync (which, like Node's, swallows errors and returns false)
  * throws a catchable error on failure; json.parse throws a catchable
- * SyntaxError-shaped string on malformed input; process.* members never
- * throw. Backends' may-throw analyses must treat a function containing one
+ * SyntaxError-shaped string on malformed input. Backends' may-throw analyses must treat a function containing one
  * of these as throwing, exactly like a `throw` statement (and must ALSO
  * seed on `dynCheck` and `awaitExpr` nodes, which throw on validation
  * failure / promise rejection). */
 export const MAY_THROW_LIB_FNS = new Set([
+    "bigint.parse",
+    "bigint.fromF64",
+    "bigint.div",
+    "bigint.mod",
+    "bigint.pow",
+    "bigint.shl",
+    "bigint.shr",
+    "bigint.toString",
+    "bigint.asUintN",
+    "bigint.asIntN",
+    "bigint.bufferRead",
+    "bigint.bufferWrite",
+    "bigint.dataViewGet",
+    "bigint.dataViewSet",
     "fetch.responseNew",
     "fetch.abortTimeout",
     "fetch.abortAny",
@@ -2341,11 +2422,13 @@ export const MAY_THROW_LIB_FNS = new Set([
     // any of them can throw. emitError additionally THROWS its payload when
     // 'error' has no listener, Node's unhandled-'error' contract.
     "emitter.emit",
+    "emitter.emitFlex",
     "emitter.emitError",
     "emitter.on",
     "emitter.off",
     "emitter.checkListener",
     "emitter.onDyn",
+    "emitter.onFlex",
     "emitter.offDyn",
     "emitter.onData",
     "emitter.onDataDyn",
@@ -2358,8 +2441,27 @@ export const MAY_THROW_LIB_FNS = new Set([
     "net.sockEndDyn",
     "http.resWriteDyn",
     "http.resEndDyn",
+    "http.resAddTrailers",
+    "http.resFlushHeaders",
+    "http.resUncork",
+    "http.resWriteHead",
+    "http.resWriteHeadN",
+    "http.resWriteHeadPairs",
+    "http.resWrite",
+    "http.resWriteBytes",
+    "http.resEnd",
+    "http.resEndStr",
+    "http.resEndBytes",
     "http.clientWriteDyn",
     "http.clientEndDyn",
+    "http.clientAddTrailers",
+    "http.clientFlushHeaders",
+    "http.clientUncork",
+    "http.clientWrite",
+    "http.clientWriteBytes",
+    "http.clientEnd",
+    "http.clientEndStr",
+    "http.clientEndBytes",
     // The URL-string client form throws catchably on an unparsable input
     // ("Invalid URL") or a non-http scheme (ERR_INVALID_PROTOCOL).
     "http.requestUrl",
@@ -2439,6 +2541,7 @@ export const MAY_THROW_LIB_FNS = new Set([
     "http.requestConnCb",
     "process.kill",
     "process.killNum",
+    "process.setExitCode",
     // cpuUsage(prev)'s field validation: negative/non-finite prev fields
     // throw Node's ERR_INVALID_ARG_VALUE RangeError, catchably.
     "process.cpuPrevValidate",
@@ -2455,6 +2558,8 @@ export const MAY_THROW_LIB_FNS = new Set([
     "error.nodeThrow",
     // USVString coercion runs user toString/valueOf — throws propagate.
     "dyn.toStringCoerce",
+    // Numeric coercion runs user valueOf/toString — throws propagate.
+    "dyn.toNumberCoerce",
     "child.kill",
     // The caller's lookup runs synchronously inside the connect call — a
     // throw there propagates like Node's.
@@ -2555,6 +2660,27 @@ export const MAY_THROW_LIB_FNS = new Set([
     "fs.statSync",
     "crypto.randomBytesToString",
     "crypto.randomBytes",
+    "crypto.hashDigestStr",
+    "crypto.hashDigestBytes",
+    "crypto.hashNew",
+    "crypto.hmacNewStr",
+    "crypto.hmacNewBytes",
+    "crypto.hashUpdateStr",
+    "crypto.hashUpdateBytes",
+    "crypto.hmacUpdateStr",
+    "crypto.hmacUpdateBytes",
+    "crypto.hashCopy",
+    "crypto.hashDigestString",
+    "crypto.hashDigestBuffer",
+    "crypto.hmacDigestString",
+    "crypto.hmacDigestBuffer",
+    "crypto.timingSafeEqual",
+    "crypto.randomFill",
+    "crypto.randomFillRest",
+    "crypto.randomInt",
+    "crypto.pbkdf2",
+    "crypto.randomBytesCb",
+    "crypto.pbkdf2Cb",
     "buffer.concat",
     "buffer.concatLen",
     // The checked-dynamic compare/equals validators: Node's argument
@@ -2585,6 +2711,10 @@ export const MAY_THROW_LIB_FNS = new Set([
     "fs.readFileSyncBytes",
     "fs.writeFileSyncBytes",
     "zlib.inflateSync",
+    "zlib.inflateRawSync",
+    "zlib.gunzipSync",
+    "zlib.unzipSync",
+    "zlib.crc32",
     "date.toISOString",
     "date.toISOStringValue",
     "fs.mkdirRecursiveSync",
@@ -2612,10 +2742,12 @@ export const MAY_THROW_LIB_FNS = new Set([
     // catchable AssertionError on failure.
     "assert.ok",
     "assert.eqF64",
+    "assert.eqBigInt",
     "assert.eqStr",
     "assert.eqBool",
     "assert.eqSym",
     "assert.eqDyn",
+    "assert.looseResult",
     "assert.deepResult",
     "assert.match",
     "assert.refEqBytes",
@@ -2641,10 +2773,15 @@ export const MAY_THROW_LIB_FNS = new Set([
     "fs.copyFileSync",
     "fs.renameSync",
     "fs.lstatSync",
+    "fs.fstatSync",
+    "fs.fchmodSync",
+    "fs.fsyncSync",
+    "fs.linkSync",
     "fs.writeFileModeSync",
     "fs.mkdirModeSync",
     "fs.mkdirRecursiveModeSync",
     "fs.openSync",
+    "fs.openNumericSync",
     "fs.readSync",
     "fs.writeSync",
     "fs.writeStrSync",