@scriptc/compiler 0.2.10 → 0.3.1

package/dist/ir/validate.js

@@ -4,7 +4,7 @@
  * an ICE that points at source is a gift to whoever debugs it.
  */
 import { validByteNumberToken } from "./byte-numbers.js";
-import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canExitIslandToType, canMarshalIntoIsland, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, islandPromisePayloadTag, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSortValuesElement, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, jsOpResultKind, JSVAL, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, unionContainerArmsOk, VOID, } from "./ir.js";
+import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSortValuesElement, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, unionContainerArmsOk, VOID, } from "./ir.js";
 import { DYN_CLASS_PROPERTIES } from "./ir.js";
 import { unionWideningTags } from "./analysis.js";
 import { alwaysReturns } from "./control-flow.js";
@@ -55,7 +55,7 @@ export function validateModule(mod) {
     const moduleLoc = { file: mod.sourceFile, start: 0, end: 0 };
     if (mod.workers !== undefined && typeof mod.workers !== "boolean")
         errors.push({ message: "worker execution mode must be a boolean", loc: moduleLoc });
-    if (mod.workers && (mod.lib !== undefined || mod.embedded !== undefined))
+    if (mod.workers && mod.lib !== undefined)
         errors.push({
             message: "worker execution requires a native static executable",
             loc: moduleLoc,
@@ -545,9 +545,8 @@ export function validateModule(mod) {
             }
             else
                 fields.set(f.name, f.type);
-            // Unit kinds (undefinedT/nullT) exist only as union arms — a BARE
-            // unit field is as malformed as a void one. dyn and jsval slots
-            // are valid; both are refcounted values held by the record shape.
+            // Bare unit and void types have no record-field storage; unit values
+            // use their union representation.
             if (f.type.kind === "void" || isUnitType(f.type)) {
                 errors.push({
                     message: `record ${rec.id}: field "${f.name}" is ${f.type.kind}`,
@@ -688,7 +687,6 @@ export function validateModule(mod) {
             if (arm.kind === "void" ||
                 arm.kind === "union" ||
                 arm.kind === "dyn" ||
-                arm.kind === "jsval" ||
                 arm.kind === "date" ||
                 arm.kind === "generator") {
                 errors.push({ message: `union ${u.id}: arm ${i} is ${arm.kind}`, loc: noLoc });
@@ -1017,10 +1015,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             err(`${what}: expected ${want.kind}, got ${expr.type.kind}${detail}`, expr.loc);
         }
     };
-    /** Union arms a truthiness helper can answer: units (false), scalars and
-     * strings (per-value), ref kinds (always true), jsval (the engine
-     * answers). dyn/caught arms have no ToBoolean — the frontend fences them
-     * before emitting toBool/logical over the union. */
     const checkTruthyUnion = (unionId, loc) => {
         const def = unions.get(unionId);
         if (!def) {
@@ -1050,13 +1044,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
     };
     function checkNullishOperands(e) {
         expectType(e.right, e.type, "nullish right operand");
-        // The ISLAND form: `a ?? b` over an engine value — left, right,
-        // and result are all handles (the emitters' jsval nullish arm).
-        if (e.left.type.kind === "jsval") {
-            if (e.type.kind !== "jsval")
-                err("jsval nullish must answer jsval", e.loc);
-            return;
-        }
         // The CHECKED-DYNAMIC form: the runtime kind decides (the
         // emitters' scr_dyn_is_nullish arm) — left, right, and result
         // all live in the checked-dynamic tree.
@@ -1115,10 +1102,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 if (e.type.kind !== "f64" &&
                     e.type.kind !== "string" &&
                     e.type.kind !== "bool" &&
-                    e.type.kind !== "jsval" &&
                     e.type.kind !== "union" &&
                     e.type.kind !== "dyn") {
-                    err(`logical ${e.op} must be f64|string|bool|jsval|union|dyn, got ${e.type.kind}`, e.loc);
+                    err(`logical ${e.op} must be f64|string|bool|union|dyn, got ${e.type.kind}`, e.loc);
                 }
                 if (e.type.kind === "union")
                     checkTruthyUnion(e.type.unionId, e.loc);
@@ -1232,7 +1218,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             case "fieldAbsent":
                 return checkRecordExpr(e);
             case "dynFrom":
-            case "dynFromJsval":
             case "dynCall":
             case "dynInvoke":
             case "dynObjLit":
@@ -1252,6 +1237,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             case "unionKeyGet":
             case "unionIsTag":
                 return checkUnionExpr(e);
+            case "unionRetype":
+                return checkUnionRetype(e);
             case "intrinsic":
                 return checkIntrinsicExpr(e);
             case "libCall":
@@ -1266,11 +1253,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             case "newPromise":
             case "promiseWithResolvers":
                 return checkAsyncExpr(e);
-            case "jsMarshal":
-            case "jsOp":
-            case "jsExit":
-            case "jsBridgePromise":
-                return checkIslandExpr(e);
             default: {
                 const _exhaustive = e;
                 void _exhaustive;
@@ -1517,16 +1499,16 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             case "dynDestrCheck": {
                 checkExpr(e.value);
-                if (e.value.type.kind !== "dyn" && e.value.type.kind !== "jsval")
-                    err("dynDestrCheck value must be dyn or jsval", e.loc);
+                if (e.value.type.kind !== "dyn")
+                    err("dynDestrCheck value must be dyn", e.loc);
                 if (e.type.kind !== e.value.type.kind)
                     err("dynDestrCheck must have its value's type", e.loc);
                 break;
             }
             case "dynIterN": {
                 checkExpr(e.value);
-                if (e.value.type.kind !== "dyn" && e.value.type.kind !== "jsval")
-                    err("dynIterN value must be dyn or jsval", e.loc);
+                if (e.value.type.kind !== "dyn")
+                    err("dynIterN value must be dyn", e.loc);
                 if (e.type.kind !== e.value.type.kind)
                     err("dynIterN must have its value's type", e.loc);
                 if (!Number.isInteger(e.count) || e.count < 0)
@@ -1611,24 +1593,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 break;
             case "optChain": {
                 checkExpr(e.receiver);
-                // An island-handle chain (`x?.y` on 'any'): the nullish test is a
-                // runtime ask of the engine value; the body is the plain island
-                // operation over the bound handle, and both body and result stay
-                // jsval (the unit path is the engine's undefined).
-                if (e.receiver.type.kind === "jsval") {
-                    if (activeChains.has(e.id))
-                        err(`optChain id "${e.id}" shadows an active chain`, e.loc);
-                    activeChains.set(e.id, JSVAL);
-                    checkExpr(e.body);
-                    activeChains.delete(e.id);
-                    if (e.body.type.kind !== "jsval") {
-                        err(`jsval optChain with ${e.body.type.kind} body`, e.loc);
-                    }
-                    if (e.type.kind !== "jsval") {
-                        err(`jsval optChain must be jsval, got ${e.type.kind}`, e.loc);
-                    }
-                    break;
-                }
                 // A dyn (dyn) chain (`rawName?.match(re)` on a JSON.parse result):
                 // the nullish test reads the node's kind tag; the body is the
                 // validated dynamic dispatch, its result converted back into the
@@ -1817,7 +1781,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     if (want)
                         expectType(a, want, `regexIntrinsic ${e.method} arg ${i}`);
                 });
-                if (e.method === "match" || e.method === "exec") {
+                if (e.method === "execGroups" && e.args[1]?.kind !== "numLit") {
+                    err("regexIntrinsic execGroups mask must be a numeric literal", e.loc);
+                }
+                if (e.method === "match" || e.method === "exec" || e.method === "execGroups") {
                     // The `string[] | null` union (program-dependent id) — checked
                     // by arms, like the libCall case checks process.envGet.
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
@@ -2153,24 +2120,28 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                                                                                                     ? { argTypes: [], result: e.type } // union-checked below
                                                                                                     : e.method === "sortValues"
                                                                                                         ? { argTypes: [F64, null], result: VOID }
-                                                                                                        : { argTypes: [], result: F64 }; // length
+                                                                                                        : e.method === "sortDense"
+                                                                                                            ? { argTypes: [null, BOOL], result: BOOL }
+                                                                                                            : { argTypes: [], result: F64 }; // length
                 if ((e.method === "sortPrimitive" || e.method === "toSortedPrimitive") &&
                     elem.kind !== "string" &&
                     elem.kind !== "f64" &&
                     elem.kind !== "bool") {
                     err(`arrIntrinsic ${e.method} requires primitive elements, got ${elem.kind}`, e.loc);
                 }
-                if (e.method === "sortValues") {
+                if (e.method === "sortValues" || e.method === "sortDense") {
                     const arms = elem.kind === "union" ? unions.get(elem.unionId)?.arms : undefined;
                     if (!isSortValuesElement(elem, arms))
-                        err(`arrIntrinsic sortValues on ${elem.kind} elements`, e.loc);
-                    const cmp = e.args[1]?.type;
+                        err(`arrIntrinsic ${e.method} on ${elem.kind} elements`, e.loc);
+                    const cmp = e.args[e.method === "sortValues" ? 1 : 0]?.type;
                     if (!cmp ||
                         cmp.kind !== "func" ||
                         cmp.params.length > 2 ||
                         !cmp.params.every((param) => typeEquals(param, elem)) ||
                         cmp.ret.kind !== "f64")
-                        err("arrIntrinsic sortValues comparator must be (elem, elem) => number", e.loc);
+                        err(`arrIntrinsic ${e.method} comparator must be (elem, elem) => number`, e.loc);
+                    if (e.method === "sortDense" && e.args[1]?.kind !== "boolLit")
+                        err("arrIntrinsic sortDense owned flag must be a boolean literal", e.loc);
                 }
                 if (e.method === "getNumber" && elem.kind !== "f64") {
                     err(`arrIntrinsic getNumber requires f64 elements, got ${elem.kind}`, e.loc);
@@ -2480,7 +2451,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // declared params plus that one must match.
                 if (e.type.kind === "func") {
                     const wantRet = callSiteReturnType(target);
-                    // ISLAND-REST types (restAbi jsval) SPELL their trailing engine
                     // array param — the lifted signature matches directly, no
                     // hidden slot.
                     const hiddenRest = e.type.rest === true && e.type.restAbi === undefined;
@@ -3037,18 +3007,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 break;
             }
-            case "dynFromJsval": {
-                // The jsval→dyn crossing: exactly a jsval operand into a dyn
-                // result (the by-reference island wrap; scalars normalize at
-                // runtime).
-                checkExpr(e.value);
-                if (e.type.kind !== "dyn")
-                    err(`dynFromJsval must be dyn-typed, got ${e.type.kind}`, e.loc);
-                if (e.value.type.kind !== "jsval") {
-                    err(`dynFromJsval operand must be jsval, got ${e.value.type.kind}`, e.loc);
-                }
-                break;
-            }
             case "dynCall": {
                 checkExpr(e.callee);
                 if (e.calleeNameValue !== undefined) {
@@ -3262,6 +3220,26 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
         }
     }
+    function checkUnionRetype(e) {
+        checkExpr(e.value);
+        const from = unions.get(e.fromId);
+        const to = unions.get(e.unionId);
+        if (!from || !to) {
+            err(`unionRetype between undeclared unions "${e.fromId}" and "${e.unionId}"`, e.loc);
+            return;
+        }
+        expectType(e.value, { kind: "union", unionId: e.fromId }, "unionRetype operand");
+        if (!typeEquals(e.type, { kind: "union", unionId: e.unionId }))
+            err(`unionRetype type ${e.type.kind} != union ${e.unionId}`, e.loc);
+        if (e.tags.length === 0)
+            err(`unionRetype with no tags`, e.loc);
+        for (const tag of e.tags) {
+            const arm = from.arms[tag];
+            const target = to.arms[tag];
+            if (!Number.isInteger(tag) || !arm || !target || !typeEquals(arm, target))
+                err(`unionRetype tag ${tag} is not the same arm in ${e.fromId} and ${e.unionId}`, e.loc);
+        }
+    }
     function checkUnionExpr(e) {
         switch (e.kind) {
             case "unionNarrow": {
@@ -4548,14 +4526,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         return false;
     }
     function checkLibSpecialCall(e) {
-        if (e.fn === "island.castFail") {
-            // The deferred boundary failure's typed dummy: a promise (the
-            // only cast shape the frontend defers).
-            if (e.type.kind !== "promise") {
-                err(`libCall island.castFail must return a promise type, got ${e.type.kind}`, e.loc);
-            }
-            return true;
-        }
         if (e.fn === "global.undefRead") {
             // Always throws — the result type is whatever the declared type
             // of the undefined global mapped to (never materialized).
@@ -5002,6 +4972,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 if (!fn.async)
                     err("await outside an async function", e.loc);
+                if (e.adopt === true && fn.generator !== undefined)
+                    err("returned-promise adoption inside a generator", e.loc);
                 break;
             }
             case "yieldExpr": {
@@ -5044,6 +5016,26 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 const genT = e.gen.type;
                 if (e.arg !== null)
                     checkExpr(e.arg);
+                if (e.mode === "step" || e.mode === "value" || e.mode === "close") {
+                    if (genT.async)
+                        err(`genResume ${e.mode} on an async generator`, e.loc);
+                    if (e.arg !== null)
+                        err(`genResume ${e.mode} with an argument`, e.loc);
+                    if (e.mode === "step") {
+                        if (genT.nextT.kind !== "undefinedT" && genT.nextT.kind !== "dyn")
+                            err(`genResume step on a ${typeKey(genT.nextT)} next-channel`, e.loc);
+                        if (e.type.kind !== "bool")
+                            err(`genResume step result ${typeKey(e.type)}`, e.loc);
+                    }
+                    else if (e.mode === "close") {
+                        if (e.type.kind !== "void")
+                            err(`genResume close result ${typeKey(e.type)}`, e.loc);
+                    }
+                    else if (genT.yieldT.kind === "void" || !typeEquals(e.type, genT.yieldT)) {
+                        err(`genResume value ${typeKey(e.type)} != yield channel ${typeKey(genT.yieldT)}`, e.loc);
+                    }
+                    break;
+                }
                 if (e.mode === "next") {
                     if (e.arg === null) {
                         if (genT.nextT.kind !== "undefinedT" && genT.nextT.kind !== "dyn") {
@@ -5211,145 +5203,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
         }
     }
-    function checkIslandExpr(e) {
-        switch (e.kind) {
-            case "jsMarshal": {
-                checkExpr(e.value);
-                if (e.type.kind !== "jsval")
-                    err(`jsMarshal must be jsval, got ${e.type.kind}`, e.loc);
-                const src = e.value.type;
-                // The marshal direction admits qualifying closures (host-function
-                // wrapping) on top of the JSON-safe set; jsExit does not. Typed
-                // closures (per-param call-time conversion through the exit
-                // machinery) are the wider func shape.
-                // Typed arrays and URLs marshal IN (an engine typed-array copy /
-                // an engine URL built from the components) without ever joining
-                // the round-trip (JSON) set — the frontend's union lift narrows
-                // union arms before marshaling, so bare bytes/url operands are
-                // exactly what it produces.
-                if (src.kind !== "bytes" &&
-                    src.kind !== "url" &&
-                    src.kind !== "dyn" && // dyn values deep-copy in (data kinds; the runtime throws on boxes)
-                    // A STATIC promise crosses as a real engine thenable when its
-                    // fulfillment is in the reverse bridge's payload domain
-                    // (scr_jsval_from_promise — the async-callback return bridge).
-                    !(src.kind === "promise" && islandPromisePayloadTag(src.inner) !== null) &&
-                    !canMarshalIntoIsland(src, (id) => records.get(id), (id) => unions.get(id)) &&
-                    !canMarshalTypedFuncIntoIsland(src, (id) => records.get(id), (id) => unions.get(id))) {
-                    err(`jsMarshal of unmarshalable type ${src.kind}`, e.loc);
-                }
-                break;
-            }
-            case "jsOp": {
-                for (const a of e.args)
-                    checkExpr(a);
-                if (e.type.kind !== jsOpResultKind(e.op)) {
-                    err(`jsOp ${e.op} must be ${jsOpResultKind(e.op)}, got ${e.type.kind}`, e.loc);
-                }
-                const named = e.op === "getProp" ||
-                    e.op === "setProp" ||
-                    e.op === "callMethod" ||
-                    e.op === "optCallMethod" ||
-                    e.op === "globalGet" ||
-                    e.op === "callSpread"; // the spread expression's source spelling (V8's nullish text spells it)
-                if (named !== (e.name !== undefined)) {
-                    err(`jsOp ${e.op} ${named ? "requires" : "forbids"} a name`, e.loc);
-                }
-                const arity = {
-                    add: 2,
-                    sub: 2,
-                    mul: 2,
-                    div: 2,
-                    mod: 2,
-                    pow: 2,
-                    lt: 2,
-                    le: 2,
-                    gt: 2,
-                    ge: 2,
-                    eq: 2,
-                    neq: 2,
-                    instanceOf: 2,
-                    neg: 1,
-                    plus: 1,
-                    truthy: 1,
-                    not: 1,
-                    typeof: 1,
-                    toStr: 1,
-                    getProp: 1,
-                    setProp: 2,
-                    getIdx: 2,
-                    setIdx: 3,
-                    globalGet: 0,
-                    undefLit: 0,
-                    nullLit: 0,
-                    iterNew: 1,
-                    defineGetter: 3,
-                    objSpread: 2,
-                    callSpread: 3, // callee + pre array + spread source
-                    callMethod: null,
-                    optCallMethod: null,
-                    callFn: null,
-                    callFnThis: null,
-                    construct: null, // receiver/callee + any number of args
-                    objLit: null,
-                    arrLit: null,
-                    tplStrings: null, // variable length (objLit: key/value pairs; tplStrings: n cooked + n raw)
-                };
-                const want = arity[e.op];
-                if (want !== null && want !== undefined && e.args.length !== want) {
-                    err(`jsOp ${e.op} takes ${want} arg(s), got ${e.args.length}`, e.loc);
-                }
-                if (want === null &&
-                    e.op !== "objLit" &&
-                    e.op !== "arrLit" &&
-                    e.op !== "tplStrings" &&
-                    e.args.length < 1) {
-                    err(`jsOp ${e.op} needs a receiver/callee arg`, e.loc);
-                }
-                if (e.op === "callFnThis" && e.args.length < 2) {
-                    err("jsOp callFnThis needs a callee and receiver", e.loc);
-                }
-                if (e.op === "objLit" && e.args.length % 2 !== 0) {
-                    err("jsOp objLit takes key/value pairs", e.loc);
-                }
-                if (e.op === "tplStrings" && e.args.length % 2 !== 0) {
-                    err("jsOp tplStrings takes n cooked + n raw strings", e.loc);
-                }
-                for (const a of e.args) {
-                    if (a.type.kind !== "jsval")
-                        err(`jsOp ${e.op} arg must be jsval, got ${a.type.kind}`, e.loc);
-                }
-                break;
-            }
-            case "jsExit": {
-                checkExpr(e.value);
-                expectType(e.value, JSVAL, "jsExit operand");
-                if (!canExitIslandToType(e.type, (id) => records.get(id), (id) => unions.get(id))) {
-                    err(`jsExit to non-extractable type ${e.type.kind}`, e.loc);
-                }
-                break;
-            }
-            case "jsBridgePromise": {
-                checkExpr(e.value);
-                expectType(e.value, JSVAL, "jsBridgePromise operand");
-                // The settled engine value crosses as a HANDLE (or not at all) —
-                // plus the ONE converting payload: an `any[]`-declared
-                // fulfillment exits Array.isArray-gated by reference AT THE
-                // SETTLE (SCR_ISLP_JSVAL_ARR); every other typed use exits later.
-                if (e.type.kind !== "promise" ||
-                    (e.type.inner.kind !== "jsval" &&
-                        e.type.inner.kind !== "void" &&
-                        !(e.type.inner.kind === "array" && e.type.inner.elem.kind === "jsval"))) {
-                    err("jsBridgePromise must be a promise of jsval, void, or jsval-element array", e.loc);
-                }
-                break;
-            }
-            default: {
-                const _exhaustive = e;
-                void _exhaustive;
-            }
-        }
-    }
     // `continue` needs an enclosing loop; `break` an enclosing loop OR switch.
     let loopDepth = 0;
     let breakableDepth = 0;