@scriptc/compiler 0.3.6 → 0.4.0

package/dist/ir/validate.js

@@ -4,43 +4,28 @@
  * an ICE that points at source is a gift to whoever debugs it.
  */
 import { validByteNumberToken } from "./byte-numbers.js";
-import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, isDirentShape, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSortValuesElement, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, unionContainerArmsOk, VOID, } from "./ir.js";
-import { DYN_CLASS_PROPERTIES } from "./ir.js";
+import { arrayOf, BYTES_ELEMENT_NAME, BOOL, BYTES_U8, bytesOf, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, ffiClassType, ffiSourceParamTypes, isDirentShape, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isJsonSafeType, isJsonStringifySafeType, isRefCounted, isSortValuesElement, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, REF_TRUTHY_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, shapeHasAccessorSlots, STRING, typeEquals, typeKey, maybePromiseUnionArmsOk, VOID, } from "./ir.js";
+import { DYN_CLASS_PROPERTIES, callSiteReturnType, classValueConstructor } from "./ir.js";
 import { unionWideningTags } from "./analysis.js";
 import { alwaysReturns } from "./control-flow.js";
+import { dynamicOperationOf, functionTier } from "./tiers.js";
 import { LIB_FN_SIGS } from "./builtin-signatures.js";
+/** The promisified crypto calls' value kinds besides checked-dynamic. */
+const CRYPTO_PROMISE_VALUES = {
+    "crypto.randomBytesPromise": "buffer",
+    "crypto.pbkdf2Promise": "buffer",
+    "crypto.scryptPromise": "buffer",
+    "crypto.hkdfPromise": "dyn",
+    "crypto.randomFillPromise": "view",
+    "crypto.randomFillPromiseDyn": "dyn",
+    "crypto.randomIntPromise": "number",
+    "crypto.generateKeyPromise": "dyn",
+};
 import { REGEX_INTRINSIC_SIGS, STR_INTRINSIC_SIGS } from "./intrinsic-signatures.js";
 /** True for an object type naming a runtime-provided error class. */
 function isBuiltinErrorObject(t) {
     return t.kind === "object" && RUNTIME_ERROR_CLASSES.has(t.className);
 }
-/** The type a CALL SITE (or function value) receives from a module
- * function: an async body's returnType is the promise's INNER type, so
- * calls and closures over it see Promise<T>; a generator body's is the
- * TReturn channel, so call sites see the generator type. The one place
- * the body/call-site split is spelled out in the validator. */
-function callSiteReturnType(fn) {
-    if (fn.async && fn.generator !== undefined) {
-        return {
-            kind: "generator",
-            async: true,
-            yieldT: fn.generator.yieldT,
-            retT: fn.returnType,
-            nextT: fn.generator.nextT,
-        };
-    }
-    if (fn.async)
-        return { kind: "promise", inner: fn.returnType };
-    if (fn.generator !== undefined) {
-        return {
-            kind: "generator",
-            yieldT: fn.generator.yieldT,
-            retT: fn.returnType,
-            nextT: fn.generator.nextT,
-        };
-    }
-    return fn.returnType;
-}
 export function validateModule(mod) {
     const errors = [];
     const functionsByName = new Map();
@@ -262,7 +247,7 @@ export function validateModule(mod) {
             }
             const fits = (cls, t) => cls === "bool"
                 ? t.kind === "bool"
-                : cls === "string"
+                : cls === "string" || cls === "cstring"
                     ? t.kind === "string"
                     : cls === "bytes"
                         ? t.kind === "bytes" && t.elem === "u8"
@@ -689,7 +674,7 @@ export function validateModule(mod) {
         u.arms.forEach((arm, i) => {
             // The unit kinds (undefinedT/nullT) are valid arms — union membership
             // is the ONLY place they may appear. Container payloads preserve
-            // identity; promise data siblings retain their separate fence.
+            // identity; a union carries at most one promise arm (maybe-promise).
             if (arm.kind === "void" ||
                 arm.kind === "union" ||
                 arm.kind === "dyn" ||
@@ -697,9 +682,9 @@ export function validateModule(mod) {
                 arm.kind === "generator") {
                 errors.push({ message: `union ${u.id}: arm ${i} is ${arm.kind}`, loc: noLoc });
             }
-            if (arm.kind === "promise" && !unionContainerArmsOk(u.arms)) {
+            if (arm.kind === "promise" && !maybePromiseUnionArmsOk(u.arms)) {
                 errors.push({
-                    message: `union ${u.id}: ${arm.kind} arm ${i} beside non-unit arms`,
+                    message: `union ${u.id}: ${arm.kind} arm ${i} beside another promise arm`,
                     loc: noLoc,
                 });
             }
@@ -860,13 +845,21 @@ export function validateModule(mod) {
         }
     }
     for (const fn of mod.functions) {
-        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors, mod.workers === true, mod.lifetimeRegions === true);
+        validateFunction(fn, functionsByName, ffiByName, classesByName, recordsById, recordValidation, unionsById, globalsById, classValidation, errors, mod.workers === true, mod.lifetimeRegions === true, new Set(mod.threadSlotKeys ?? []));
     }
     return errors;
 }
-function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors, workers, lifetimeRegions) {
+function validateFunction(fn, functions, ffiByName, classes, records, recordValidation, unions, globals, classValidation, errors, workers, lifetimeRegions, threadSlotKeys) {
     const locals = new Map(fn.locals.map((l) => [l.id, l]));
     const err = (message, loc) => errors.push({ message: `in ${fn.name}: ${message}`, loc });
+    // Invariant I1 (ir/tiers.ts): a static function reaches dynamic values
+    // only through boundary operations and moves.
+    const staticTier = functionTier(fn) === "static";
+    const checkTier = (e) => {
+        const operation = dynamicOperationOf(e);
+        if (operation !== null)
+            err(`static-tier function performs the dynamic operation ${operation}`, e.loc);
+    };
     const asyncCaches = [
         ["asyncCacheGlobal", fn.asyncCacheGlobal],
         ["asyncCycleCacheGlobal", fn.asyncCycleCacheGlobal],
@@ -1105,6 +1098,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 continue;
             }
             if (e.kind === "logical") {
+                // checkExpr already checked the root's tier.
+                if (staticTier && e !== root)
+                    checkTier(e);
                 if (e.type.kind !== "f64" &&
                     e.type.kind !== "string" &&
                     e.type.kind !== "bool" &&
@@ -1149,6 +1145,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         checkExpr(e);
     }
     function checkExpr(e) {
+        if (staticTier)
+            checkTier(e);
         switch (e.kind) {
             case "numLit":
             case "strLit":
@@ -1760,8 +1758,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             case "regexLit": {
                 if (e.type.kind !== "regex")
                     err("regexLit must be regex-typed", e.loc);
-                if (!/^[gimsuy]*$/.test(e.flags)) {
-                    err(`regexLit flags "${e.flags}" outside the supported alphabet (gimsuy)`, e.loc);
+                if (!/^[gimsuvy]*$/.test(e.flags)) {
+                    err(`regexLit flags "${e.flags}" outside the supported alphabet (gimsuvy)`, e.loc);
                 }
                 if (new Set(e.flags).size !== e.flags.length) {
                     err(`regexLit flags "${e.flags}" contain a duplicate`, e.loc);
@@ -2629,7 +2627,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             case "downcast": {
                 // A pointer reinterpret is sound exactly between hierarchy
                 // relatives: upcast widens a STRICT descendant to an ancestor,
-                // downcast (checker-trusted) narrows an ancestor to a STRICT
+                // downcast (verified at run time) narrows an ancestor to a STRICT
                 // descendant. Upcast additionally widens CLASS VALUES
                 // (classval:D → classval:C): the same pointer, type-only — legal
                 // exactly when D strictly descends from C AND the two completed
@@ -2655,14 +2653,20 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                         err(`upcast: "${sub}" does not extend "${sup}"`, e.loc);
                         break;
                     }
-                    const subCtor = functions.get(`%${sub}.constructor`);
-                    const supCtor = functions.get(`%${sup}.constructor`);
-                    if (!subCtor || !supCtor) {
+                    const subClass = classes.get(sub);
+                    const supClass = classes.get(sup);
+                    const subValueCtor = subClass ? classValueConstructor(subClass) : null;
+                    const supValueCtor = supClass ? classValueConstructor(supClass) : null;
+                    const subCtor = subValueCtor ? functions.get(subValueCtor.fn) : undefined;
+                    const supCtor = supValueCtor ? functions.get(supValueCtor.fn) : undefined;
+                    if (!subCtor || !supCtor || !subValueCtor || !supValueCtor) {
                         err(`classval upcast: "${sub}"/"${sup}" lack constructor functions`, e.loc);
                         break;
                     }
-                    const abiEqual = subCtor.params.length === supCtor.params.length &&
-                        subCtor.params.every((p, i) => i === 0 || typeEquals(p.type, supCtor.params[i].type));
+                    const subArgs = subCtor.params.slice(subValueCtor.firstArg);
+                    const supArgs = supCtor.params.slice(supValueCtor.firstArg);
+                    const abiEqual = subArgs.length === supArgs.length &&
+                        subArgs.every((p, i) => typeEquals(p.type, supArgs[i].type));
                     if (!abiEqual) {
                         err(`classval upcast: "${sub}" and "${sup}" constructor ABIs differ`, e.loc);
                     }
@@ -2686,16 +2690,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     err(`classRef to undeclared class "${e.className}"`, e.loc);
                     break;
                 }
-                if (cls.runtime) {
-                    err(`classRef to runtime-provided class "${e.className}"`, e.loc);
-                }
-                if (cls.jsName === undefined) {
+                if (cls.jsName === undefined && !cls.runtime) {
                     err(`classRef to "${e.className}" without a jsName (the class object's .name)`, e.loc);
                 }
                 // A class value can always be constructed through — the frontend
                 // notes the constructor edge at every classRef, so the emitted
                 // thunk has a body to call.
-                if (!functions.has(`%${e.className}.constructor`)) {
+                if (!functions.has(classValueConstructor(cls).fn)) {
                     err(`classRef to "${e.className}" without its constructor function`, e.loc);
                 }
                 if (!typeEquals(e.type, { kind: "classval", className: e.className })) {
@@ -2723,18 +2724,21 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     break;
                 }
                 const cls = e.callee.type.className;
-                const ctor = functions.get(`%${cls}.constructor`);
-                if (!ctor) {
+                const calleeClass = classes.get(cls);
+                const valueCtor = calleeClass ? classValueConstructor(calleeClass) : null;
+                const ctor = valueCtor ? functions.get(valueCtor.fn) : undefined;
+                if (!ctor || !valueCtor) {
                     err(`newValue on "${cls}": missing constructor function`, e.loc);
                     break;
                 }
                 // Count-exact against the static class's completed ABI (every
                 // value legally in the slot shares it — the upcast rule).
-                if (ctor.params.length !== e.args.length + 1) {
-                    err(`newValue on "${cls}": ${e.args.length} args, ctor expects ${ctor.params.length - 1}`, e.loc);
+                const first = valueCtor.firstArg;
+                if (ctor.params.length !== e.args.length + first) {
+                    err(`newValue on "${cls}": ${e.args.length} args, ctor expects ${ctor.params.length - first}`, e.loc);
                 }
                 e.args.forEach((a, i) => {
-                    const p = ctor.params[i + 1];
+                    const p = ctor.params[i + first];
                     if (p)
                         expectType(a, p.type, `newValue on "${cls}" arg ${i}`);
                 });
@@ -3529,6 +3533,47 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 err(`${e.name} has type f64`, e.loc);
             return;
         }
+        if (e.name === "slots.get" ||
+            e.name === "slots.has" ||
+            e.name === "slots.set" ||
+            e.name === "slots.delete") {
+            for (const a of e.args)
+                checkExpr(a);
+            const [name, slots, key, value] = e.args;
+            const arity = e.name === "slots.set" ? 4 : 3;
+            const isSlots = (t) => t.kind === "object" && t.className === "%ThreadSlots";
+            // The key's class or one of its bases is a declared key.
+            const keyed = (className) => {
+                for (let c = className; c !== undefined; c = classes.get(c)?.base)
+                    if (threadSlotKeys.has(c))
+                        return true;
+                return false;
+            };
+            if (e.args.length !== arity)
+                err(`${e.name} takes ${arity} arguments`, e.loc);
+            else if (name.kind !== "strLit" || !isSlots(slots.type))
+                err(`${e.name} takes a name literal and a %ThreadSlots value`, e.loc);
+            else if (key.type.kind !== "object" || !keyed(key.type.className))
+                err(`${e.name} key ${typeKey(key.type)} is not a ThreadSlots key class`, e.loc);
+            else if (e.name === "slots.set") {
+                const kind = value.type.kind;
+                if (kind !== "object" &&
+                    kind !== "record" &&
+                    kind !== "array" &&
+                    kind !== "map" &&
+                    kind !== "set")
+                    err(`slots.set value ${typeKey(value.type)} is not a ThreadSlots value type`, e.loc);
+                if (e.type.kind !== "void" && !isSlots(e.type))
+                    err("slots.set has type void or %ThreadSlots", e.loc);
+            }
+            else if (e.name === "slots.get") {
+                if (e.type.kind !== "union")
+                    err("slots.get has a V | undefined union type", e.loc);
+            }
+            else if (e.type.kind !== "bool")
+                err(`${e.name} has type bool`, e.loc);
+            return;
+        }
         if (e.name === "threads.publish") {
             if (e.args.length !== 1)
                 err("threads.publish takes exactly one argument", e.loc);
@@ -3739,9 +3784,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         if (checkLibEmitterCall(e, sig.result))
             return;
         if (e.fn === "error.stack" ||
+            e.fn === "error.setStack" ||
             e.fn === "error.cause" ||
             e.fn === "error.hasCause" ||
             e.fn === "error.setCause" ||
+            e.fn === "error.setCode" ||
+            e.fn === "error.setCodeDyn" ||
+            e.fn === "error.assign" ||
+            e.fn === "error.hasKey" ||
+            e.fn === "error.hasCode" ||
             e.fn === "error.defineCause" ||
             e.fn === "error.deleteCause") {
             const recv = e.args[0];
@@ -3766,7 +3817,20 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         }
     }
     function checkLibValueCall(e) {
-        if (e.fn === "events.once") {
+        const cryptoPromise = CRYPTO_PROMISE_VALUES[e.fn];
+        if (cryptoPromise) {
+            const inner = e.type.kind === "promise" ? e.type.inner : undefined;
+            const view = e.fn === "crypto.randomFillPromise" ? e.args[0]?.type : undefined;
+            const ok = inner !== undefined &&
+                (inner.kind === "dyn" ||
+                    (cryptoPromise === "buffer" && inner.kind === "bytes" && inner.elem === "u8") ||
+                    (cryptoPromise === "view" && view !== undefined && typeEquals(inner, view)) ||
+                    (cryptoPromise === "number" && inner.kind === "f64"));
+            if (!ok)
+                err(`libCall ${e.fn} must be a promise of its ${cryptoPromise} value`, e.loc);
+            return true;
+        }
+        if (e.fn === "events.once" || e.fn === "events.onceSignal") {
             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);
@@ -3774,12 +3838,17 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 arrayT?.kind !== "array" ||
                 !boxes(boxer) ||
                 !boxes(errorBoxer)) {
-                err(`libCall events.once must box its event tuples into the promised array`, e.loc);
+                err(`libCall ${e.fn} 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 (e.fn === "tp.setTimeoutValue" ||
+            e.fn === "tp.setImmediateValue" ||
+            e.fn === "tp.setTimeoutSignal" ||
+            e.fn === "tp.setImmediateSignal" ||
+            e.fn === "tp.schedulerWaitValue" ||
+            e.fn === "tp.schedulerWaitSignal") {
+            const value = e.args[e.fn === "tp.setImmediateValue" || e.fn === "tp.setImmediateSignal" ? 0 : 1];
             if (value?.type.kind !== "promise" || !typeEquals(e.type, value.type)) {
                 err(`libCall ${e.fn} must be the value's promise type`, e.loc);
             }
@@ -4006,7 +4075,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             e.fn === "http.clientOnResponse" ||
             e.fn === "http.requestAgentCb" ||
             e.fn === "https.requestAgentCb" ||
-            e.fn === "https.requestUrlCb") {
+            e.fn === "https.requestUrlCb" ||
+            e.fn === "http.requestDynCb" ||
+            e.fn === "https.requestDynCb") {
             // The response listener: void, no params or exactly (res: httpReq).
             const cbT = e.args[e.fn === "http.requestCb"
                 ? 7
@@ -4014,11 +4085,13 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     ? 9
                     : e.fn === "http.requestUrlCb" || e.fn === "https.requestUrlCb"
                         ? 3
-                        : e.fn === "http.requestAgentCb"
-                            ? 8
-                            : e.fn === "https.requestAgentCb"
-                                ? 10
-                                : 1]?.type;
+                        : e.fn === "http.requestDynCb" || e.fn === "https.requestDynCb"
+                            ? 2
+                            : 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";
@@ -4630,7 +4703,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
                 const p = cbT.params[0];
                 if (e.fn === "stdin.onData")
-                    ok = p.kind === "bytes" && p.elem === "u8";
+                    ok = (p.kind === "bytes" && p.elem === "u8") || p.kind === "string";
                 else if (e.fn === "stdin.onError")
                     ok = p.kind === "object" && p.className === "%Error";
                 else
@@ -4740,6 +4813,33 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             }
             return true;
         }
+        if (e.fn === "stream.dynNative" || e.fn === "stream.dynNativePipe") {
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const side = e.args[1];
+            const className = side?.kind === "numLit" ? (side.value === 1 ? "%Readable" : "%Writable") : null;
+            const ok = def &&
+                className !== null &&
+                e.args[0]?.type.kind === "dyn" &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "object" && a.className === className) &&
+                def.arms.some((a) => a.kind === "nullT");
+            if (!ok)
+                err(`libCall ${e.fn} must return its side's stream class or null`, e.loc);
+            return true;
+        }
+        if (e.fn === "child.stdioStream") {
+            const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+            const slot = e.args[1];
+            const className = slot?.kind === "numLit" ? (slot.value === 0 ? "%Writable" : "%Readable") : null;
+            const ok = def &&
+                className !== null &&
+                def.arms.length === 2 &&
+                def.arms.some((a) => a.kind === "object" && a.className === className) &&
+                def.arms.some((a) => a.kind === "nullT");
+            if (!ok)
+                err(`libCall ${e.fn} must return the stream class of its stdio slot or null`, e.loc);
+            return true;
+        }
         if (e.fn === "child.stdin" || e.fn === "child.stdout" || e.fn === "child.stderr") {
             const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
             const handleKind = e.fn === "child.stdin" ? "childWriter" : "childStream";
@@ -4755,7 +4855,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
         return false;
     }
     function checkLibSpecialCall(e) {
-        if (e.fn === "crypto.randomFillView" || e.fn === "crypto.randomFillViewRest") {
+        if (e.fn === "crypto.randomFillView" ||
+            e.fn === "crypto.randomFillViewRest" ||
+            e.fn === "crypto.getRandomValues") {
             // The filled view is the result, at its own element type.
             const view = e.args[0]?.type;
             if (view?.kind !== "bytes" || !typeEquals(e.type, view)) {
@@ -5197,9 +5299,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                 }
                 return true;
             }
-            if (e.fn === "readable.pipe") {
+            if (e.fn === "readable.pipe" || e.fn === "readable.pipeGeneral") {
                 if (!isStreamObject(e.args[1]?.type) || !typeEquals(e.type, e.args[1].type)) {
-                    err(`libCall readable.pipe must return its destination's type`, e.loc);
+                    err(`libCall ${e.fn} must return its destination's type`, e.loc);
                 }
                 return true;
             }
@@ -5236,6 +5338,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
             e.fn !== "emitter.setDefaultMax" &&
             e.fn !== "emitter.setDefaultMaxChk" &&
             e.fn !== "emitter.getDefaultMax" &&
+            e.fn !== "emitter.esmDefaultMax" &&
+            e.fn !== "emitter.esmSync" &&
             e.fn !== "emitter.errorMonitor" &&
             e.fn !== "emitter.checkListener") {
             // Receiver: an emitter-hierarchy object (the %EventEmitter class
@@ -5627,7 +5731,10 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     if (expectsArg && (rp.params.length !== 1 || !typeEquals(rp.params[0], inner))) {
                         err(`newPromise resolve param must be (${inner.kind}) => void`, e.loc);
                     }
-                    if (!expectsArg && rp.params.length !== 0) {
+                    // A Promise<never> executor types resolve as `(value: never) =>
+                    // void` (one parameter over a void inner): the void resolve never
+                    // reads an argument, and a never value cannot be produced.
+                    if (!expectsArg && rp.params.length > 1) {
                         err("newPromise<void> resolve takes no argument", e.loc);
                     }
                 }