@scriptc/compiler 0.3.3 → 0.3.4

package/dist/ir/validate.js

@@ -3461,6 +3461,45 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 err(`${e.name} has type ${e.name === "region.create" ? "f64" : "void"}`, e.loc);
             return;
         }
+        if (e.name === "itable.open" ||
+            e.name === "itable.find" ||
+            e.name === "itable.insert" ||
+            e.name === "itable.value" ||
+            e.name === "itable.size") {
+            for (const a of e.args)
+                checkExpr(a);
+            const [first, key, value] = e.args;
+            const arity = {
+                "itable.open": 2,
+                "itable.find": 2,
+                "itable.insert": 3,
+                "itable.value": 1,
+                "itable.size": 1,
+            }[e.name];
+            if (e.args.length !== arity)
+                err(`${e.name} takes ${arity} arguments`, e.loc);
+            else if (e.name === "itable.open") {
+                if (first.type.kind !== "string" || key.type.kind !== "f64")
+                    err("itable.open takes a string name and an f64 key kind", e.loc);
+            }
+            else if (first.type.kind !== "f64")
+                err(`${e.name} handle must be f64`, e.loc);
+            else if ((e.name === "itable.find" || e.name === "itable.insert") &&
+                key.type.kind !== "string" &&
+                key.type.kind !== "f64" &&
+                !(key.type.kind === "array" &&
+                    (key.type.elem.kind === "f64" || key.type.elem.kind === "string")))
+                err(`${e.name} key must be string, f64, or an array of either`, e.loc);
+            else if (e.name === "itable.insert" && !isSupportedMapValue(value.type))
+                err(`itable.insert value ${typeKey(value.type)} is not a table value type`, e.loc);
+            if (e.name === "itable.value") {
+                if (!isSupportedMapValue(e.type))
+                    err(`itable.value type ${typeKey(e.type)} is not a table value type`, e.loc);
+            }
+            else if (e.type.kind !== "f64")
+                err(`${e.name} has type f64`, e.loc);
+            return;
+        }
         if (e.name === "threads.publish") {
             if (e.args.length !== 1)
                 err("threads.publish takes exactly one argument", e.loc);
@@ -3633,6 +3672,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             e.fn === "passthrough.initDyn" ||
             e.fn === "stream.pipeline" ||
             e.fn === "stream.pipelineDyn" ||
+            e.fn === "stream.compose" ||
+            e.fn === "stream.pipelineStages" ||
+            e.fn === "stream.pipelineStagesDyn" ||
+            e.fn === "sp.pipelineStages" ||
             e.fn === "sp.pipeline" ||
             e.fn === "sp.pipelineOpts" ||
             e.fn === "sp.pipelineOptsSignal" ||
@@ -3694,6 +3737,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
     }
     function checkLibValueCall(e) {
+        if (e.fn === "tp.setTimeoutValue" || e.fn === "tp.setImmediateValue") {
+            const value = e.args[e.fn === "tp.setTimeoutValue" ? 1 : 0];
+            if (value?.type.kind !== "promise" || !typeEquals(e.type, value.type)) {
+                err(`libCall ${e.fn} must be the value's promise type`, e.loc);
+            }
+            return true;
+        }
         if (e.fn === "fileHandle.read" ||
             e.fn === "fileHandle.writeBytes" ||
             e.fn === "fileHandle.writeStr" ||
@@ -4744,7 +4794,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
-        if (e.fn === "assert.refEqBytes" || e.fn === "assert.bytesDeepEq") {
+        if (e.fn === "assert.refEqBytes" ||
+            e.fn === "assert.bytesDeepEq" ||
+            e.fn === "assert.looseBytesEq") {
             // Both value slots: ONE static bytes type (the frontend's
             // same-static-type gate — a u8/u32 mix would memcmp garbage).
             const a = e.args[0]?.type;
@@ -4783,6 +4835,26 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         return false;
     }
     function checkLibStreamCall(e, fixedArgs, result) {
+        if (e.fn.startsWith("zlib.stream")) {
+            // The zlib stream classes: streamNew answers a runtime Transform;
+            // the members take one as their receiver, and the Cb forms end in
+            // the () => void callback.
+            const isTransform = (t) => t?.kind === "object" && t.className === "%Transform";
+            if (e.fn === "zlib.streamNew") {
+                if (!isTransform(e.type))
+                    err(`libCall ${e.fn} must return a %Transform`, e.loc);
+                return true;
+            }
+            if (!isTransform(e.args[0]?.type)) {
+                err(`libCall ${e.fn} receiver must be a %Transform`, e.loc);
+            }
+            if (e.fn.endsWith("Cb") && e.args[e.args.length - 1]?.type.kind !== "func") {
+                err(`libCall ${e.fn} callback must be a func`, e.loc);
+            }
+            if (!typeEquals(e.type, result))
+                err(`libCall ${e.fn} result type mismatch`, e.loc);
+            return true;
+        }
         if (e.fn.startsWith("readable.") ||
             e.fn.startsWith("writable.") ||
             e.fn.startsWith("duplex.") ||
@@ -4797,6 +4869,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             e.fn === "stream.finishedDyn" ||
             e.fn === "stream.pipeline" ||
             e.fn === "stream.pipelineDyn" ||
+            e.fn === "stream.compose" ||
+            e.fn === "stream.pipelineStages" ||
+            e.fn === "stream.pipelineStagesDyn" ||
+            e.fn === "sp.pipelineStages" ||
             e.fn === "stream.addAbortSignal" ||
             e.fn === "stream.addAbortSignalFn" ||
             e.fn === "stream.finishedOpts" ||
@@ -4886,6 +4962,80 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 return true;
             }
+            if (e.fn === "stream.compose") {
+                // (count, s1..sn) → a Duplex (n >= 2), or the lone stream.
+                const count = e.args[0];
+                const n = count?.kind === "numLit" ? count.value : -1;
+                if (n < 1 || e.args.length !== n + 1) {
+                    err(`libCall ${e.fn} count/arity mismatch`, e.loc);
+                    return true;
+                }
+                for (let i = 1; i <= n; i++) {
+                    if (!isStreamObject(e.args[i]?.type)) {
+                        err(`libCall ${e.fn} stage ${i} must be a stream-hierarchy object`, e.loc);
+                    }
+                }
+                if (!isStreamObject(e.type))
+                    err(`libCall ${e.fn} must return a stream`, e.loc);
+                return true;
+            }
+            if (e.fn === "stream.pipelineStages" ||
+                e.fn === "stream.pipelineStagesDyn" ||
+                e.fn === "sp.pipelineStages") {
+                // (n, at, k, flags, mask, s1..sn, stage1..stagek, (next, read,
+                // return)?, box?, (signal, abort)?[, cb]): flags bit 0 a source
+                // function, bits 1-2 the destination, bits 3/4/5 the groups.
+                const [n, at, k, flags] = e.args
+                    .slice(0, 4)
+                    .map((a) => (a?.kind === "numLit" ? a.value : -1));
+                const source = (flags & 1) !== 0;
+                const destKind = (flags >> 1) & 3;
+                const groups = (flags & 8 ? 3 : 0) + (flags & 16 ? 1 : 0) + (flags & 32 ? 2 : 0);
+                const cbArgs = e.fn === "sp.pipelineStages" ? 0 : 1;
+                if (flags < 0 ||
+                    n < 0 ||
+                    k < 1 ||
+                    (source ? at !== 0 : at < 1) ||
+                    (destKind === 0 ? at + 0 >= n : at !== n) ||
+                    n + k < 2 ||
+                    e.args.length !== 5 + n + k + groups + cbArgs) {
+                    err(`libCall ${e.fn} count/arity mismatch`, e.loc);
+                    return true;
+                }
+                for (let i = 5; i < 5 + n; i++) {
+                    if (!isStreamObject(e.args[i]?.type)) {
+                        err(`libCall ${e.fn} stage ${i - 5} must be a stream-hierarchy object`, e.loc);
+                    }
+                }
+                let at2 = 5 + n;
+                for (let i = at2; i < at2 + k; i++) {
+                    if (e.args[i]?.type.kind !== "func")
+                        err(`libCall ${e.fn} stage function ${i} must be a func`, e.loc);
+                }
+                at2 += k;
+                const helpers = (flags & 8 ? 3 : 0) + (flags & 16 ? 1 : 0);
+                for (let i = at2; i < at2 + helpers; i++) {
+                    if (e.args[i]?.type.kind !== "func")
+                        err(`libCall ${e.fn} helper ${i} must be a func`, e.loc);
+                }
+                at2 += helpers;
+                if (flags & 32) {
+                    if (e.args[at2]?.type.kind !== "dyn" || e.args[at2 + 1]?.type.kind !== "func")
+                        err(`libCall ${e.fn} signal and abort must be a dyn and a func`, e.loc);
+                }
+                if (cbArgs) {
+                    const cbK = e.args[e.args.length - 1]?.type.kind;
+                    if (e.fn === "stream.pipelineStages" ? cbK !== "func" : cbK !== "dyn") {
+                        err(`libCall ${e.fn} callback has the wrong kind`, e.loc);
+                    }
+                    if (!isStreamObject(e.type))
+                        err(`libCall ${e.fn} must return a stream`, e.loc);
+                }
+                else if (e.type.kind !== "promise") {
+                    err(`libCall ${e.fn} must return a promise`, e.loc);
+                }
+                return true;
+            }
             if (e.fn === "stream.pipeline" || e.fn === "stream.pipelineDyn") {
                 // (count, s1..sn, cb) → the destination's type.
                 const count = e.args[0];
@@ -4908,10 +5058,50 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 return true;
             }
-            if (e.fn === "readable.fromArr") {
-                // No receiver: the seed array leads; the result is the class.
-                if (e.args[0]?.type.kind !== "array" || !isStreamObject(e.type)) {
-                    err(`libCall readable.fromArr must take an array and return a stream class`, e.loc);
+            if (e.fn === "readable.opMap" ||
+                e.fn === "readable.opFilter" ||
+                e.fn === "readable.opFlatMap" ||
+                e.fn === "readable.opDrop" ||
+                e.fn === "readable.opTake") {
+                if (!isStreamObject(e.args[0]?.type) || !isStreamObject(e.type)) {
+                    err(`libCall ${e.fn} must take a stream and return a stream class`, e.loc);
+                }
+                return true;
+            }
+            if (e.fn === "readable.opReduce") {
+                const inner = e.type.kind === "promise" ? e.type.inner : null;
+                const kind = e.args[5]?.kind === "numLit" ? e.args[5].value : -1;
+                const want = [DYN, F64, BOOL, STRING][kind];
+                if (!isStreamObject(e.args[0]?.type) || !inner || !want || !typeEquals(inner, want)) {
+                    err(`libCall readable.opReduce must return the promise its kind names`, e.loc);
+                }
+                return true;
+            }
+            if (e.fn === "readable.fromDone") {
+                if (e.args.length !== 0 || e.type.kind !== "dyn")
+                    err(`libCall ${e.fn} takes no arguments`, e.loc);
+                return true;
+            }
+            if (e.fn === "readable.fromGen" || e.fn === "readable.fromAsyncGen") {
+                const g = e.args[0]?.type;
+                const helpers = e.fn === "readable.fromGen" ? 3 : 4;
+                if (g?.kind !== "generator" ||
+                    (g.async === true) !== (e.fn === "readable.fromAsyncGen") ||
+                    !e.args.slice(1, 1 + helpers).every((a) => a.kind === "closure") ||
+                    e.args[1 + helpers]?.kind !== "numLit" ||
+                    !isStreamObject(e.type)) {
+                    err(`libCall ${e.fn} must take a generator, its helpers and the flags`, e.loc);
+                }
+                return true;
+            }
+            if (e.fn === "readable.fromArr" || e.fn === "readable.fromDyn") {
+                // No receiver: the source leads; the result is the class.
+                const src = e.fn === "readable.fromArr" ? "array" : "dyn";
+                if (e.args[0]?.type.kind !== src || !isStreamObject(e.type)) {
+                    err(`libCall ${e.fn} must take a ${src} source and return a stream class`, e.loc);
+                }
+                if (e.fn === "readable.fromArr" && e.args[1]?.kind !== "numLit") {
+                    err(`libCall readable.fromArr flags must be a number literal`, e.loc);
                 }
                 return true;
             }