@scriptc/compiler 0.3.0 → 0.3.2

package/dist/ir/validate.js

@@ -55,6 +55,8 @@ 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.lifetimeRegions !== undefined && mod.lifetimeRegions !== true)
+        errors.push({ message: "lifetimeRegions must be true when present", loc: moduleLoc });
     if (mod.workers && mod.lib !== undefined)
         errors.push({
             message: "worker execution requires a native static executable",
@@ -359,6 +361,10 @@ export function validateModule(mod) {
         if (cls.jsLength !== undefined && (!Number.isSafeInteger(cls.jsLength) || cls.jsLength < 0)) {
             errors.push({ message: `class ${cls.name}: invalid constructor length`, loc: cls.loc });
         }
+        if (cls.prototypeNames !== undefined &&
+            new Set(cls.prototypeNames).size !== cls.prototypeNames.length) {
+            errors.push({ message: `class ${cls.name}: duplicate prototype member names`, loc: cls.loc });
+        }
         if (cls.tracksOwnFields &&
             (cls.runtime ||
                 cls.fields.find((field) => field.name === DYN_CLASS_PROPERTIES)?.type.kind !== "dyn")) {
@@ -854,11 +860,11 @@ export function validateModule(mod) {
         }
     }
     for (const fn of mod.functions) {
-        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors, mod.workers === true);
+        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors, mod.workers === true, mod.lifetimeRegions === true);
     }
     return errors;
 }
-function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors, workers) {
+function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors, workers, lifetimeRegions) {
     const locals = new Map(fn.locals.map((l) => [l.id, l]));
     const err = (message, loc) => errors.push({ message: `in ${fn.name}: ${message}`, loc });
     const asyncCaches = [
@@ -1237,6 +1243,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":
@@ -1456,6 +1464,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     allowed.add("return");
                     allowed.add("throw");
                     allowed.add("runtimeFence");
+                    allowed.add("tryCatch");
                 }
                 if (e.diverges) {
                     const last = e.stmts[e.stmts.length - 1];
@@ -1779,7 +1788,15 @@ 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.method === "execSpans" || e.method === "matchGroups") &&
+                    e.args.slice(1).some((mask) => mask.kind !== "numLit")) {
+                    err(`regexIntrinsic ${e.method} masks must be numeric literals`, e.loc);
+                }
+                if (e.method === "match" ||
+                    e.method === "exec" ||
+                    e.method === "execGroups" ||
+                    e.method === "execSpans" ||
+                    e.method === "matchGroups") {
                     // 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;
@@ -2114,25 +2131,54 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                                                                                                 : e.method === "shift"
                                                                                                     ? { argTypes: [], result: e.type } // union-checked below
                                                                                                     : e.method === "sortValues"
-                                                                                                        ? { argTypes: [F64, null], result: VOID }
-                                                                                                        : { argTypes: [], result: F64 }; // length
+                                                                                                        ? {
+                                                                                                            argTypes: [F64, null, F64, null],
+                                                                                                            result: VOID,
+                                                                                                        }
+                                                                                                        : e.method === "sortDense"
+                                                                                                            ? {
+                                                                                                                argTypes: [null, BOOL, F64, null],
+                                                                                                                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);
+                    // A recognized comparator's key order: [order] for numbers,
+                    // [order, key reader] for record and class elements.
+                    const order = e.args[2];
+                    if (order) {
+                        if (order.kind !== "numLit" || (order.value !== 1 && order.value !== -1))
+                            err(`arrIntrinsic ${e.method} key order must be the literal 1 or -1`, e.loc);
+                        const key = e.args[3]?.type;
+                        if (elem.kind === "f64"
+                            ? key !== undefined
+                            : elem.kind !== "record" && elem.kind !== "object")
+                            err(`arrIntrinsic ${e.method} key order on ${elem.kind} elements`, e.loc);
+                        if (elem.kind !== "f64" &&
+                            (!key ||
+                                key.kind !== "func" ||
+                                key.params.length !== 1 ||
+                                !typeEquals(key.params[0], elem) ||
+                                key.ret.kind !== "f64"))
+                            err(`arrIntrinsic ${e.method} key reader must be (elem) => number`, e.loc);
+                    }
                 }
                 if (e.method === "getNumber" && elem.kind !== "f64") {
                     err(`arrIntrinsic getNumber requires f64 elements, got ${elem.kind}`, e.loc);
@@ -2179,7 +2225,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 // slice's indices and splice's count are optional (omitted args
                 // omitted from the IR — backends fill the defaults); everything
                 // else is exact.
-                const minArgs = e.method === "slice" ? 0 : e.method === "splice" ? 1 : sig.argTypes.length;
+                const minArgs = e.method === "slice"
+                    ? 0
+                    : e.method === "splice"
+                        ? 1
+                        : e.method === "sortValues" || e.method === "sortDense"
+                            ? 2
+                            : sig.argTypes.length;
                 if (e.args.length < minArgs || e.args.length > sig.argTypes.length) {
                     err(`arrIntrinsic ${e.method}: ${e.args.length} args, expected ${sig.argTypes.length}`, e.loc);
                 }
@@ -2778,25 +2830,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 const want = recordValidation.get(shape.id).initializationFields;
                 const seen = new Set();
                 for (const f of e.fields) {
-                    if (f.drop || f.overflow)
+                    if (f.overflow)
                         checkExpr(f.value);
                     else
                         checkSlotValue(f.value);
                     if (seen.has(f.name))
                         err(`recordLit initializes field "${f.name}" twice`, e.loc);
                     seen.add(f.name);
-                    if (f.drop) {
-                        // A mapping-dropped field (the PromiseSettledResult honest
-                        // subset): evaluated, never stored — it must NOT name a
-                        // declared field (that would silently drop a real store),
-                        // and its value may be any type, void included.
-                        if (f.overflow)
-                            err(`recordLit drop entry "${f.name}" flagged overflow too`, e.loc);
-                        if (want.has(f.name)) {
-                            err(`recordLit drop entry "${f.name}" shadows a declared field of shape ${shape.id}`, e.loc);
-                        }
-                        continue;
-                    }
                     if (f.overflow) {
                         // Overflow entries exist only on index-signature shapes, name
                         // no declared field, and carry the index-value type exactly
@@ -2818,7 +2858,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     else
                         expectType(f.value, ft, `recordLit field "${f.name}"`);
                 }
-                if (e.fields.filter((f) => !f.overflow && !f.drop).length !== shape.fields.length) {
+                if (e.fields.filter((f) => !f.overflow).length !== shape.fields.length) {
                     err(`recordLit does not initialize every field of shape ${shape.id}`, e.loc);
                 }
                 break;
@@ -3211,6 +3251,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": {
@@ -3368,6 +3428,24 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 err("module.tdzCheck must be void", e.loc);
             return;
         }
+        if (e.name === "region.create" ||
+            e.name === "region.enter" ||
+            e.name === "region.leave" ||
+            e.name === "region.release") {
+            if (!lifetimeRegions)
+                err(`${e.name} outside a lifetimeRegions module`, e.loc);
+            const takesId = e.name === "region.enter" || e.name === "region.release";
+            if (e.args.length !== (takesId ? 1 : 0))
+                err(`${e.name} takes ${takesId ? "one region id" : "no arguments"}`, e.loc);
+            for (const a of e.args) {
+                checkExpr(a);
+                if (a.type.kind !== "f64")
+                    err(`${e.name} id must be f64`, e.loc);
+            }
+            if (e.type.kind !== (e.name === "region.create" ? "f64" : "void"))
+                err(`${e.name} has type ${e.name === "region.create" ? "f64" : "void"}`, e.loc);
+            return;
+        }
         if (e.name === "threads.publish") {
             if (e.args.length !== 1)
                 err("threads.publish takes exactly one argument", e.loc);
@@ -3411,6 +3489,26 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return;
         }
+        if (e.name === "promise.allSettled" || e.name === "promise.any") {
+            if (e.args.length !== 1)
+                err(`${e.name} takes exactly one argument`, e.loc);
+            for (const a of e.args) {
+                checkExpr(a);
+                if (a.type.kind !== "array" || a.type.elem.kind !== "promise") {
+                    err(`${a.type.kind} argument to ${e.name} (needs an array of promises)`, a.loc);
+                }
+                else if (e.name === "promise.any" && !typeEquals(a.type.elem, e.type)) {
+                    err("promise.any result must be the entries' promise type", e.loc);
+                }
+            }
+            if (e.type.kind !== "promise")
+                err(`${e.name} must be promise-typed`, e.loc);
+            else if (e.name === "promise.allSettled" &&
+                (e.type.inner.kind !== "array" || e.type.inner.elem.kind !== "union")) {
+                err("promise.allSettled result must be a promise of a settled-record union array", e.loc);
+            }
+            return;
+        }
         if (e.name === "promise.reject") {
             // ONE argument: the %Error-rooted reason object (the rejection
             // payload shares the thrown-Error representation — the
@@ -3602,6 +3700,23 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
+        if (e.fn === "dyn.objEntryPairs") {
+            // Result: the native [string, any][] the backend assembles from the
+            // runtime's owned pair snapshot.
+            const shape = e.type.kind === "array" && e.type.elem.kind === "record"
+                ? records.get(e.type.elem.shapeId)
+                : undefined;
+            const field = (name) => shape?.fields.find((f) => f.name === name)?.type;
+            const ok = shape !== undefined &&
+                shape.tuple === true &&
+                shape.indexValue === undefined &&
+                shape.fields.length === 2 &&
+                field("0")?.kind === "string" &&
+                field("1")?.kind === "dyn";
+            if (!ok)
+                err(`libCall dyn.objEntryPairs must return a [string, any] tuple array`, e.loc);
+            return true;
+        }
         if (e.fn === "fetch.streamFrom") {
             const t = e.args[0]?.type;
             const ok = t?.kind === "string" ||
@@ -4528,6 +4643,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
+        if (e.fn === "error.aggregateSetErrors" || e.fn === "error.aggregateErrors") {
+            // Receiver: exactly %AggregateError (subclassing is fenced — the
+            // hidden runtime slot admits no other layout).
+            const recv = e.args[0];
+            if (!recv || recv.type.kind !== "object" || recv.type.className !== "%AggregateError") {
+                err(`libCall ${e.fn} receiver must be %AggregateError`, e.loc);
+            }
+            return true;
+        }
         if (e.fn === "error.newDom") {
             if (e.type.kind !== "object" || e.type.className !== "%DOMException") {
                 err(`libCall error.newDom must return %DOMException, got ${e.type.kind}`, e.loc);
@@ -4763,6 +4887,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             e.fn !== "emitter.setDefaultMax" &&
             e.fn !== "emitter.setDefaultMaxChk" &&
             e.fn !== "emitter.getDefaultMax" &&
+            e.fn !== "emitter.errorMonitor" &&
             e.fn !== "emitter.checkListener") {
             // Receiver: an emitter-hierarchy object (the %EventEmitter class
             // itself, or a class whose base chain reaches it). emitter.new
@@ -4931,6 +5056,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
         }
     }
+    // The yield a `delegate` genResume is checking as its argument.
+    let delegatedYield = null;
     function checkAsyncExpr(e) {
         switch (e.kind) {
             case "awaitExpr": {
@@ -4943,6 +5070,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": {
@@ -4960,7 +5089,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 // The undefined next-channel has no C value form: such yields are
                 // void-typed (statement position only — the frontend fences reads).
-                if (e.captureCompletion) {
+                if (e.delegated) {
+                    if (delegatedYield !== e)
+                        err("delegated yield outside a delegate resume", e.loc);
+                    if (e.type.kind !== "void" || e.captureCompletion)
+                        err("invalid delegated yield", e.loc);
+                }
+                else if (e.captureCompletion) {
                     if (fn.async ||
                         e.type.kind !== "dyn" ||
                         !typeEquals(e.captureCompletion.returnType, fn.returnType)) {
@@ -4983,8 +5118,49 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     break;
                 }
                 const genT = e.gen.type;
+                if (e.mode === "delegate") {
+                    if (e.arg !== null) {
+                        if (e.arg.kind === "yieldExpr" && e.arg.delegated)
+                            delegatedYield = e.arg;
+                        else
+                            err("genResume delegate argument is not a delegated yield", e.loc);
+                        checkExpr(e.arg);
+                        delegatedYield = null;
+                    }
+                    const outer = fn.generator;
+                    if (outer === undefined || fn.async || genT.async)
+                        err("genResume delegate outside a sync generator body", e.loc);
+                    else if (genT.nextT.kind !== "undefinedT" &&
+                        genT.nextT.kind !== "dyn" &&
+                        !typeEquals(genT.nextT, outer.nextT))
+                        err(`genResume delegate into a ${typeKey(genT.nextT)} next-channel from ${typeKey(outer.nextT)}`, e.loc);
+                    if (e.type.kind !== "bool" && e.type.kind !== "record")
+                        err(`genResume delegate result ${typeKey(e.type)}`, e.loc);
+                    break;
+                }
                 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)) &&
+                        (genT.retT.kind === "void" || !typeEquals(e.type, genT.retT))) {
+                        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") {