@scriptc/compiler 0.3.4 → 0.3.6

package/dist/ir/validate.js

@@ -1219,6 +1219,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             case "recordGet":
             case "recordKeyGet":
             case "recordOvfHas":
+            case "recordNullProto":
             case "recordOvfKeys":
             case "recordHas":
             case "fieldAbsent":
@@ -2822,6 +2823,20 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                         isStrictSubclass(returned.className, e.type.className))) {
                     err(`virtualCall ${e.className}.${e.method} result type mismatch`, e.loc);
                 }
+                // Closed target sets name distinct implementations at or below the
+                // static class's chain, each an existing method function.
+                if (e.targets !== undefined) {
+                    if (e.targets.length < 2 || new Set(e.targets).size !== e.targets.length)
+                        err(`virtualCall ${e.className}.${e.method}: targets must be distinct, at least two`, e.loc);
+                    for (const target of e.targets) {
+                        if (!functions.has(`%${target}.${e.method}`))
+                            err(`virtualCall ${e.className}.${e.method}: target ${target} has no implementation`, e.loc);
+                        else if (target !== e.className &&
+                            !isStrictSubclass(target, e.className) &&
+                            !isStrictSubclass(e.className, target))
+                            err(`virtualCall ${e.className}.${e.method}: target ${target} is unrelated`, e.loc);
+                    }
+                }
                 break;
             }
             default: {
@@ -2842,6 +2857,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     err(`recordLit of undeclared shape "${e.type.shapeId}"`, e.loc);
                     break;
                 }
+                if (e.nullProto && (!shape.indexValue || shape.tuple))
+                    err(`recordLit nullProto on ${shape.id}: requires an index-signature record`, e.loc);
                 const want = recordValidation.get(shape.id).initializationFields;
                 const seen = new Set();
                 for (const f of e.fields) {
@@ -3003,6 +3020,18 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     err("recordOvfHas must be bool", e.loc);
                 break;
             }
+            case "recordNullProto": {
+                checkExpr(e.obj);
+                const shape = records.get(e.shapeId);
+                if (!shape)
+                    err(`recordNullProto on undeclared shape "${e.shapeId}"`, e.loc);
+                else if (!shape.indexValue || shape.tuple)
+                    err(`recordNullProto on ${e.shapeId}: requires an index-signature record`, e.loc);
+                expectType(e.obj, { kind: "record", shapeId: e.shapeId }, "recordNullProto receiver");
+                if (e.type.kind !== "bool")
+                    err("recordNullProto must be bool", e.loc);
+                break;
+            }
             case "recordOvfKeys": {
                 checkExpr(e.obj);
                 const shape = records.get(e.shapeId);
@@ -3737,6 +3766,18 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
     }
     function checkLibValueCall(e) {
+        if (e.fn === "events.once") {
+            const [recv, , boxer, errorBoxer] = e.args;
+            const arrayT = e.type.kind === "promise" ? e.type.inner : null;
+            const boxes = (b) => b?.type.kind === "func" && arrayT !== null && typeEquals(b.type.ret, arrayT);
+            if (recv?.type.kind !== "object" ||
+                arrayT?.kind !== "array" ||
+                !boxes(boxer) ||
+                !boxes(errorBoxer)) {
+                err(`libCall events.once must box its event tuples into the promised array`, e.loc);
+            }
+            return true;
+        }
         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)) {
@@ -3866,7 +3907,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
-        if (e.fn === "http.serverOnRequest") {
+        if (e.fn === "http.serverOnRequest" || e.fn === "http.serverOnCheck") {
             // The 'request' listener: the same shape as http.createServer's
             // handler — void, at most (req, res) in order.
             const cbT = e.args[1]?.type;
@@ -4274,14 +4315,27 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         return false;
     }
     function checkLibFileCall(e) {
+        if (e.fn === "fs.statProbeSync" || e.fn === "fs.lstatProbeSync") {
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const ok = def &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "stats") &&
+                def.arms.some((a) => a.kind === "undefinedT");
+            if (!ok) {
+                err(`libCall ${e.fn} must return the 'Stats | undefined' union`, e.loc);
+            }
+            return true;
+        }
         if (e.fn === "zlib.deflateCb" ||
             e.fn === "zlib.inflateCb" ||
             e.fn === "zlib.deflateRawCb" ||
             e.fn === "zlib.inflateRawCb" ||
             e.fn === "zlib.gzipCb" ||
             e.fn === "zlib.gunzipCb" ||
-            e.fn === "zlib.unzipCb") {
-            const cbT = e.args[1]?.type;
+            e.fn === "zlib.unzipCb" ||
+            e.fn === "zlib.cbOpts" ||
+            e.fn === "zlib.cbOptsDyn") {
+            const cbT = e.args[e.fn.startsWith("zlib.cbOpts") ? 3 : 1]?.type;
             let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 2;
             if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
                 const error = cbT.params[0];
@@ -4709,6 +4763,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
+        if (e.fn === "crypto.hashStream" || e.fn === "crypto.hashStreamPiped") {
+            const value = e.args[0]?.type.kind;
+            if (value !== "cryptoHash" && value !== "cryptoHmac")
+                err(`libCall ${e.fn} argument must be a Hash or Hmac`, e.loc);
+            return true;
+        }
         if (e.fn === "crypto.timingSafeEqual") {
             if (e.args[0]?.type.kind !== "bytes" || e.args[1]?.type.kind !== "bytes")
                 err(`libCall ${e.fn} arguments must be views`, e.loc);
@@ -5094,6 +5154,14 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 return true;
             }
+            if (e.fn === "readable.fromIter" || e.fn === "readable.fromAsyncIter") {
+                if (e.args[0]?.type.kind !== "dyn" ||
+                    e.args[1]?.kind !== "numLit" ||
+                    !isStreamObject(e.type)) {
+                    err(`libCall ${e.fn} must take an iterator object 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";