@scriptc/compiler 0.0.17 → 0.0.19

package/dist/ir/validate.js

@@ -1441,6 +1441,36 @@ export function validateModule(mod) {
 function validateFunction(fn, functions, ffiByName, classes, records, unions, globals, errors) {
     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 = [
+        ["asyncCacheGlobal", fn.asyncCacheGlobal],
+        ["asyncCycleCacheGlobal", fn.asyncCycleCacheGlobal],
+    ];
+    for (const [field, cacheId] of asyncCaches) {
+        if (cacheId === undefined)
+            continue;
+        if (fn.async !== true) {
+            err(`an ${field} is only valid on an async function`, fn.loc);
+        }
+        if (fn.params.length !== 0 || (fn.captures?.length ?? 0) !== 0) {
+            err("a cached async function must have no parameters or captures", fn.loc);
+        }
+        const cache = globals.get(cacheId);
+        if (cache === undefined) {
+            err(`async cache names undeclared global "${cacheId}"`, fn.loc);
+        }
+        else {
+            const expected = { kind: "promise", inner: fn.returnType };
+            if (!typeEquals(cache.type, expected)) {
+                err(`async cache global "${cacheId}" has type ${typeKey(cache.type)}, expected ${typeKey(expected)}`, fn.loc);
+            }
+            if (!cache.mutable) {
+                err(`async cache global "${cacheId}" is immutable`, fn.loc);
+            }
+        }
+    }
+    if (fn.asyncCycleCacheGlobal !== undefined && fn.asyncCacheGlobal === undefined) {
+        err("an asyncCycleCacheGlobal requires a module asyncCacheGlobal", fn.loc);
+    }
     // The class graph's two questions (upcast/downcast/instanceOf/virtualCall
     // legality): strict-descendant tests over the base links, and hierarchy
     // membership (a class that extends or is extended).
@@ -2178,35 +2208,43 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         ? { argTypes: [F64], minArgs: 1, result: F64 }
                         : e.method === "slice" || e.method === "subarray"
                             ? { argTypes: [F64, F64], minArgs: 0, result: bytesOf(recv.elem) }
-                            : e.method === "setFrom"
-                                ? { argTypes: [bytesOf(recv.elem), F64], minArgs: 1, result: VOID }
-                                : e.method === "toString"
-                                    ? { argTypes: [STRING, F64, F64], minArgs: 1, result: STRING }
-                                    : e.method === "readNum"
-                                        ? { argTypes: [STRING, F64], minArgs: 2, result: F64 }
-                                        : e.method === "writeNum"
-                                            ? { argTypes: [STRING, F64, F64], minArgs: 3, result: F64 }
-                                            : e.method === "readNumVar"
-                                                ? { argTypes: [STRING, F64, F64], minArgs: 3, result: F64 }
-                                                : e.method === "writeNumVar"
-                                                    ? { argTypes: [STRING, F64, F64, F64], minArgs: 4, result: F64 }
-                                                    : e.method === "dataViewNew"
-                                                        ? { argTypes: [F64, F64], minArgs: 0, result: BYTES_U8 }
-                                                        : e.method.startsWith("dvSet")
-                                                            ? {
-                                                                // dvSet*: [offset, value], the 8-bit setters take no littleEndian.
-                                                                argTypes: e.method === "dvSetUint8" || e.method === "dvSetInt8"
-                                                                    ? [F64, F64]
-                                                                    : [F64, F64, BOOL],
-                                                                minArgs: 2,
-                                                                result: VOID,
-                                                            }
-                                                            : {
-                                                                // dvGet*: the 8-bit getters take no littleEndian.
-                                                                argTypes: e.method === "dvGetUint8" || e.method === "dvGetInt8" ? [F64] : [F64, BOOL],
-                                                                minArgs: 1,
-                                                                result: F64,
-                                                            });
+                            : e.method === "toReversed"
+                                ? { argTypes: [], minArgs: 0, result: bytesOf(recv.elem) }
+                                : e.method === "with"
+                                    ? { argTypes: [F64, F64], minArgs: 2, result: bytesOf(recv.elem) }
+                                    : e.method === "join"
+                                        ? { argTypes: [STRING], minArgs: 1, result: STRING }
+                                        : e.method === "toArray"
+                                            ? { argTypes: [], minArgs: 0, result: arrayOf(F64) }
+                                            : e.method === "setFrom"
+                                                ? { argTypes: [bytesOf(recv.elem), F64], minArgs: 1, result: VOID }
+                                                : e.method === "toString"
+                                                    ? { argTypes: [STRING, F64, F64], minArgs: 1, result: STRING }
+                                                    : e.method === "readNum"
+                                                        ? { argTypes: [STRING, F64], minArgs: 2, result: F64 }
+                                                        : e.method === "writeNum"
+                                                            ? { argTypes: [STRING, F64, F64], minArgs: 3, result: F64 }
+                                                            : e.method === "readNumVar"
+                                                                ? { argTypes: [STRING, F64, F64], minArgs: 3, result: F64 }
+                                                                : e.method === "writeNumVar"
+                                                                    ? { argTypes: [STRING, F64, F64, F64], minArgs: 4, result: F64 }
+                                                                    : e.method === "dataViewNew"
+                                                                        ? { argTypes: [F64, F64], minArgs: 0, result: BYTES_U8 }
+                                                                        : e.method.startsWith("dvSet")
+                                                                            ? {
+                                                                                // dvSet*: [offset, value], the 8-bit setters take no littleEndian.
+                                                                                argTypes: e.method === "dvSetUint8" || e.method === "dvSetInt8"
+                                                                                    ? [F64, F64]
+                                                                                    : [F64, F64, BOOL],
+                                                                                minArgs: 2,
+                                                                                result: VOID,
+                                                                            }
+                                                                            : {
+                                                                                // dvGet*: the 8-bit getters take no littleEndian.
+                                                                                argTypes: e.method === "dvGetUint8" || e.method === "dvGetInt8" ? [F64] : [F64, BOOL],
+                                                                                minArgs: 1,
+                                                                                result: F64,
+                                                                            });
                 if (e.args.length < sig.minArgs || e.args.length > sig.argTypes.length) {
                     err(`bytesIntrinsic ${e.method}: ${e.args.length} args`, e.loc);
                 }
@@ -2242,11 +2280,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                                         ? { argTypes: [STRING], result: STRING }
                                         : e.method === "slice"
                                             ? { argTypes: [F64, F64], result: e.receiver.type }
-                                            : e.method === "splice"
-                                                ? { argTypes: [F64, F64], result: e.receiver.type }
-                                                : e.method === "shift"
-                                                    ? { argTypes: [], result: e.type } // union-checked below
-                                                    : { argTypes: [], result: F64 }; // length
+                                            : e.method === "toReversed"
+                                                ? { argTypes: [], result: e.receiver.type }
+                                                : e.method === "toSpliced"
+                                                    ? { argTypes: [F64, F64, e.receiver.type], result: e.receiver.type }
+                                                    : e.method === "with"
+                                                        ? { argTypes: [F64, elem], result: e.receiver.type }
+                                                        : e.method === "splice"
+                                                            ? { argTypes: [F64, F64], result: e.receiver.type }
+                                                            : e.method === "shift"
+                                                                ? { argTypes: [], result: e.type } // union-checked below
+                                                                : { argTypes: [], result: F64 }; // length
                 if (e.method === "join" &&
                     elem.kind !== "f64" && elem.kind !== "string" && elem.kind !== "bool" &&
                     !(elem.kind === "union" &&
@@ -3262,6 +3306,19 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 break;
             }
             case "intrinsic":
+                if (e.name === "module.await") {
+                    if (e.args.length !== 1)
+                        err("module.await takes exactly one argument", e.loc);
+                    for (const a of e.args) {
+                        checkExpr(a);
+                        if (a.type.kind !== "promise" || a.type.inner.kind !== "void") {
+                            err(`${typeKey(a.type)} argument to module.await (needs promise<void>)`, a.loc);
+                        }
+                    }
+                    if (e.type.kind !== "void")
+                        err("module.await must be void", e.loc);
+                    break;
+                }
                 if (e.name === "promise.all") {
                     // ONE argument: an array of promises whose inner type is the
                     // result's array element (or void, collapsing to promise<void>).
@@ -3528,15 +3585,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
-                if (e.fn === "http.requestCb" || e.fn === "http.requestUrlCb" || e.fn === "http.clientOnResponse" ||
+                if (e.fn === "http.requestCb" || e.fn === "https.requestCb" ||
+                    e.fn === "http.requestUrlCb" || e.fn === "http.clientOnResponse" ||
                     e.fn === "http.requestAgentCb" || e.fn === "https.requestAgentCb" ||
                     e.fn === "https.requestUrlCb") {
                     // The response listener: void, no params or exactly (res: httpReq).
                     const cbT = e.args[e.fn === "http.requestCb" ? 7
-                        : e.fn === "http.requestUrlCb" || e.fn === "https.requestUrlCb" ? 3
-                            : e.fn === "http.requestAgentCb" ? 8
-                                : e.fn === "https.requestAgentCb" ? 10
-                                    : 1]?.type;
+                        : e.fn === "https.requestCb" ? 9
+                            : e.fn === "http.requestUrlCb" || e.fn === "https.requestUrlCb" ? 3
+                                : e.fn === "http.requestAgentCb" ? 8
+                                    : e.fn === "https.requestAgentCb" ? 10
+                                        : 1]?.type;
                     let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
                     if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
                         ok = cbT.params[0].kind === "httpReq";