@scriptc/compiler 0.0.8 → 0.0.9

package/dist/ir/validate.js

@@ -180,6 +180,8 @@ export const LIB_FN_SIGS = {
     "regexp.escape": { argTypes: [STRING], result: STRING },
     "num.toExponential": { argTypes: [F64], result: STRING },
     "num.toFixed0": { argTypes: [F64], result: STRING },
+    "num.sameValue": { argTypes: [F64, F64], result: BOOL },
+    "intl.numFormatEnUs": { argTypes: [F64], result: STRING },
     "sym.new": { argTypes: [STRING], result: SYMBOL_T },
     "sym.newAnon": { argTypes: [], result: SYMBOL_T },
     "sym.for": { argTypes: [STRING], result: SYMBOL_T },
@@ -636,6 +638,16 @@ export const LIB_FN_SIGS = {
     "buffer.byteLenStr": { argTypes: [STRING, STRING], result: F64 },
     "buffer.isEncoding": { argTypes: [STRING], result: BOOL },
     "buffer.concatLen": { argTypes: [arrayOf(BYTES_U8), F64], result: BYTES_U8 },
+    // The checked-dynamic compare/equals validators (Node's argument
+    // ladders over DOM-boxed invalid-input probes).
+    "buffer.compareChk": { argTypes: [DYN, DYN], result: F64 },
+    "bytes.equalsChk": { argTypes: [BYTES_U8, DYN], result: BOOL },
+    "bytes.compareChk": { argTypes: [BYTES_U8, DYN, DYN, DYN, DYN, DYN], result: F64 },
+    "buffer.newStringFail": { argTypes: [DYN], result: BYTES_U8 },
+    "fs.toUnixTimestamp": { argTypes: [DYN], result: F64 },
+    "error.argTypeThrow": { argTypes: [STRING, STRING, DYN], result: VOID },
+    "emitter.setMaxChk": { argTypes: [null, DYN], result: VOID },
+    "emitter.setDefaultMaxChk": { argTypes: [DYN, STRING], result: VOID },
     "fs.readFileSyncBytes": { argTypes: [STRING], result: BYTES_U8 },
     "fs.writeFileSyncBytes": { argTypes: [STRING, BYTES_U8], result: VOID },
     "fsp.readFileBytes": { argTypes: [STRING], result: { kind: "promise", inner: BYTES_U8 } },
@@ -681,6 +693,8 @@ export const LIB_FN_SIGS = {
     // error.new's result and the receiver slots are builtin-error classes —
     // program-dependent object types, checked in the libCall case.
     "error.new": { argTypes: [STRING], result: VOID },
+    "error.nodeThrow": { argTypes: [F64, STRING, STRING], result: VOID },
+    "dyn.toStringCoerce": { argTypes: [DYN], result: STRING },
     // Always throws; the result is the READ's declared type (a typed dummy
     // the unwind abandons) — the libCall case skips the result check.
     "global.undefRead": { argTypes: [STRING], result: VOID },
@@ -768,6 +782,8 @@ export const LIB_FN_SIGS = {
     "stream.finishedDyn": { argTypes: [null, DYN], result: VOID },
     "stream.pipeline": { argTypes: [F64], result: VOID },
     "stream.pipelineDyn": { argTypes: [F64], result: VOID },
+    "sp.finished": { argTypes: [null], result: { kind: "promise", inner: VOID } },
+    "sp.pipeline": { argTypes: [F64], result: { kind: "promise", inner: VOID } },
     "readable.newDyn": { argTypes: [DYN], result: VOID },
     "writable.newDyn": { argTypes: [DYN], result: VOID },
     "duplex.newDyn": { argTypes: [DYN], result: VOID },
@@ -2059,12 +2075,21 @@ function validateFunction(fn, functions, classes, records, unions, globals, erro
                                                     ? { argTypes: [STRING, F64, F64, F64], minArgs: 4, result: F64 }
                                                     : e.method === "dataViewNew"
                                                         ? { argTypes: [F64, F64], minArgs: 0, result: BYTES_U8 }
-                                                        : {
-                                                            // dvGet*: the 8-bit getters take no littleEndian.
-                                                            argTypes: e.method === "dvGetUint8" || e.method === "dvGetInt8" ? [F64] : [F64, BOOL],
-                                                            minArgs: 1,
-                                                            result: F64,
-                                                        });
+                                                        : 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);
                 }
@@ -2777,6 +2802,21 @@ function validateFunction(fn, functions, classes, records, unions, globals, erro
                     if (a.type.kind !== "dyn")
                         err(`dynCall argument of kind ${a.type.kind} (must be dyn)`, e.loc);
                 }
+                // The runtime-arity form: spread entries point into args (their
+                // dyn values flatten at the call), strictly increasing.
+                if (e.spreads !== undefined) {
+                    if (e.spreads.length === 0)
+                        err("dynCall spreads must be non-empty when present", e.loc);
+                    let prev = -1;
+                    for (const s of e.spreads) {
+                        if (!Number.isInteger(s.arg) || s.arg < 0 || s.arg >= e.args.length) {
+                            err(`dynCall spread index ${s.arg} out of range`, e.loc);
+                        }
+                        if (s.arg <= prev)
+                            err("dynCall spread indices must be strictly increasing", e.loc);
+                        prev = s.arg;
+                    }
+                }
                 break;
             }
             case "dynInvoke": {
@@ -3184,6 +3224,7 @@ function validateFunction(fn, functions, classes, records, unions, globals, erro
                     e.fn === "duplex.initDyn" || e.fn === "transform.initDyn" ||
                     e.fn === "passthrough.initDyn" ||
                     e.fn === "stream.pipeline" || e.fn === "stream.pipelineDyn" ||
+                    e.fn === "sp.pipeline" ||
                     e.fn === "writable.write" ||
                     e.fn === "writable.writeStr" || e.fn === "writable.writeU" ||
                     e.fn === "writable.end" ||
@@ -3834,6 +3875,11 @@ function validateFunction(fn, functions, classes, records, unions, globals, erro
                     // of the undefined global mapped to (never materialized).
                     break;
                 }
+                if (e.fn === "error.nodeThrow" || e.fn === "error.argTypeThrow") {
+                    // Always throws — the result type is the replaced expression's
+                    // own (never materialized; the global.undefRead pattern).
+                    break;
+                }
                 if (e.fn === "error.new") {
                     // Which builtin the runtime constructs is named by the result type.
                     if (!isBuiltinErrorObject(e.type)) {
@@ -4048,6 +4094,7 @@ function validateFunction(fn, functions, classes, records, unions, globals, erro
                     break;
                 }
                 if (e.fn.startsWith("emitter.") && e.fn !== "emitter.setDefaultMax" &&
+                    e.fn !== "emitter.setDefaultMaxChk" &&
                     e.fn !== "emitter.getDefaultMax" && e.fn !== "emitter.checkListener") {
                     // Receiver: an emitter-hierarchy object (the %EventEmitter class
                     // itself, or a class whose base chain reaches it). emitter.new
@@ -4077,7 +4124,8 @@ function validateFunction(fn, functions, classes, records, unions, globals, erro
                     if (e.fn === "emitter.on" || e.fn === "emitter.off" ||
                         e.fn === "emitter.onDyn" || e.fn === "emitter.offDyn" ||
                         e.fn === "emitter.onData" || e.fn === "emitter.onDataDyn" ||
-                        e.fn === "emitter.removeAll" || e.fn === "emitter.setMax") {
+                        e.fn === "emitter.removeAll" || e.fn === "emitter.setMax" ||
+                        e.fn === "emitter.setMaxChk") {
                         if (!typeEquals(e.type, e.args[0].type)) {
                             err(`libCall ${e.fn} must return its receiver's type (the chaining 'this')`, e.loc);
                         }
@@ -4418,7 +4466,8 @@ function validateFunction(fn, functions, classes, records, unions, globals, erro
                 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";
+                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);
                 }
@@ -4428,6 +4477,7 @@ function validateFunction(fn, functions, classes, records, unions, globals, erro
                     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, 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)
                 };