@scriptc/compiler 0.3.2 → 0.3.4

package/dist/frontend/lowering/lower-calls.js

@@ -10,15 +10,18 @@ import { adaptZeroArgTimerCallback, lowerTimersMemberCall, TIMER_MODULE_MEMBERS,
 import { objectEnumerationReceiver } from "./object-enumeration-receiver.js";
 import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
+import { isZlibStreamMember, lowerZlibStreamMethodCall } from "./builtins/compression.js";
 import { lowerGenMethodCall } from "./lower-generators.js";
 import { lowerClassSymbolMethodCall } from "./symbol-methods.js";
 import { errorToStringCall } from "./error-methods.js";
 import { lowerClassPrototypeAssign, lowerClassPrototypeDescriptors } from "./class-prototypes.js";
 import { BYTES_ELEMENT_NAME, BIGINT_T, BOOL, CAUGHT, DYN, F64, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, funcOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
+import { lowerProtocolMethodCall } from "./class-protocol-dispatch.js";
 import { isJsSourceFile, locOf, requireSpecOf } from "../program.js";
+import { lowerAssertInstanceCall } from "./assert-instances.js";
 import { isGenericCallableMemberType, typeKey } from "../type-mapper.js";
 import { dynFallbackType, jsFuncNameOf, newFnCtx, staticImportNamespaceType } from "./lowerer.js";
-import { NARROW_FIRST, STRING_INDEX_METHODS, STR_METHODS, stdlibGlobalNameOf } from "./surfaces.js";
+import { NARROW_FIRST, STRING_INDEX_METHODS, STR_METHODS, UTIL_TYPES_KEYS, stdlibGlobalNameOf, } from "./surfaces.js";
 import { dynStringReceiver } from "./containers/dynamic-receivers.js";
 import { lowerArrayConstructor, lowerArrayFromCall, lowerArrayOfCall, } from "./containers/array-construction.js";
 import { lowerDynArrayFilterCall, lowerDynArrayFlatMapCall } from "./containers/array-callbacks.js";
@@ -32,9 +35,9 @@ import { lowerRegexMethodCall, lowerStringIndexCall, lowerStringMethodCall, lowe
 import { createRequireSpecOf } from "./builtins/module-bindings.js";
 import { lowerChildStreamMethodCall, lowerChildWriterMethodCall, } from "./builtins/child-process-methods.js";
 import { lowerCreateRequireCall, lowerImportMetaResolveCall, lowerRequireResolveCall, } from "./builtins/module-resolution.js";
-import { lowerCryptoHashMethodCall } from "./builtins/crypto.js";
-import { lowerDirentMethodCall, lowerFileHandleMethodCall, lowerWatcherMethodCall, } from "./builtins/filesystem.js";
-import { lowerPerfHooksCall } from "./builtins/performance.js";
+import { lowerCipherMethodCall, lowerCryptoHashMethodCall } from "./builtins/crypto.js";
+import { lowerDirentMethodCall, lowerFileHandleMethodCall, lowerDirMethodCall, lowerWatcherMethodCall, } from "./builtins/filesystem.js";
+import { fencePerfEntryKeyWalk, isPerfEntryType, lowerPerfHooksCall, perfEntryTag, } from "./builtins/performance.js";
 import { lowerProcStreamMethodCall } from "./builtins/process.js";
 import { lowerReflectCall } from "./builtins/reflection.js";
 import { lowerAbsenceProbe, lowerOptionalNumber, lowerPromiseAllTupleCall, lowerPromiseRejectCall, lowerToNumberArgument, stringWrapperToString, symbolFieldInfo, templateRawTextOf, } from "./lower-exprs.js";
@@ -45,8 +48,9 @@ import { httpClientFnBindingOf, lowerCompatReqStreamOptionalCall, lowerHttpClien
 import { EMITTER_API_MEMBERS, exactClassOfReceiver, exactInstanceClassOf, findGenericMethodOn, lowerClassGenericMethodCall, lowerStaticMethodCall, lowerStaticFieldRead, returnsOnlyThis, storedClassValueType, } from "./lower-classes.js";
 import { classCallbackCall, isClassCallback } from "./class-callbacks.js";
 import { emitterRooted, lowerEmitterMethodCall } from "./lower-event-emitter.js";
+import { eventTargetApiMethod, lowerEventTargetMethodCall } from "./lower-event-target.js";
 import { lowerConsoleInstanceCall, lowerConsoleMethodCall, lowerConsoleOutput, } from "./lower-console.js";
-import { STREAM_API_MEMBERS, lowerStreamMethodCall, lowerStreamStaticCall, streamSidesOf, } from "./lower-stream.js";
+import { STREAM_API_MEMBERS, STREAM_OPERATORS, lowerStreamMethodCall, lowerStreamStaticCall, streamSidesOf, } from "./lower-stream.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
 import { expandoMemberRead } from "./lower-expando.js";
 import { fenceNodeModuleMutationCall, lowerRequireCacheKeys } from "./lower-node-module.js";
@@ -60,6 +64,7 @@ import { spreadNeedsRuntimeArity, completeFuncValueArgs, lowerSpreadArgsCall, co
 import { isThisParameter } from "./call-signatures.js";
 import { checkedArmExtraction } from "./coercions/unions.js";
 import { requireObjLitGenericReceiver, objLitGenericFnNodeOf, objLitGenericFnInfoOf, genericCallInstance, } from "./generic-functions.js";
+const ZLIB_STREAM_METHODS = new Set(["flush", "params", "close", "reset"]);
 export function lowerCall(lowerer, expr) {
     const loc = locOf(expr);
     // Object's checker return type is `any`. Claim known object inputs
@@ -961,6 +966,8 @@ export function lowerCall(lowerer, expr) {
             // as named builtin imports — before anything below tries to lower
             // the namespace object itself as a receiver.
             lowerer.lowerNamespaceBuiltinCall(expr, expr.expression) ??
+            // Method calls on a static node:assert Assert instance.
+            lowerAssertInstanceCall(lowerer, expr, expr.expression, locOf(expr)) ??
             // The node:perf_hooks spoke: performance.now() and its
             // .bind(performance) function value over the runtime's
             // process-start-anchored monotonic clock.
@@ -992,7 +999,9 @@ export function lowerCall(lowerer, expr) {
             lowerer.lowerSearchParamsMethodCall(expr, expr.expression) ??
             lowerer.lowerStatsMethodCall(expr, expr.expression) ??
             lowerCryptoHashMethodCall(lowerer, expr, expr.expression) ??
+            lowerCipherMethodCall(lowerer, expr, expr.expression) ??
             lowerFileHandleMethodCall(lowerer, expr, expr.expression) ??
+            lowerDirMethodCall(lowerer, expr, expr.expression) ??
             lowerer.lowerChildMethodCall(expr, expr.expression) ??
             // Piped child-output stream receivers — on/once("data" | "end").
             lowerChildStreamMethodCall(lowerer, expr, expr.expression) ??
@@ -2048,6 +2057,7 @@ function lowerObjectOwnCall(lowerer, call, receiverNode, keyNode, extraNodes, me
     }
     else if (type.kind === "record") {
         const shape = lowerer.shapes.get(type.shapeId);
+        fencePerfEntryKeyWalk(lowerer, type, receiverNode ?? call, `Object.prototype.${method}`);
         if (!shape || shape.tuple || shapeHasAccessorSlots(shape)) {
             lowerer.noLowering("Object.prototype." + method + " over this record shape", receiverNode ?? call);
         }
@@ -2763,7 +2773,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     // representable prototype declares (test/common's mustCall internals:
     // mustCallChecks.push(context), failed.forEach(fn), fn.apply(this,
     // args)). Implemented (kind, name) pairs run JS-exact; real-but-
-    // unimplemented methods throw a LOUD not-supported Error; names the
+    // unimplemented methods throw the 'not supported yet' Error; names the
     // kind's prototype lacks throw Node's "x.y is not a function"; OBJ
     // receivers call the own member.
     // A stored callback must be read before argument effects, and called
@@ -2782,6 +2792,13 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
                 .declarationsOf(prop)
                 .some((decl) => ts.isPropertyDeclaration(decl) || ts.isPropertySignature(decl)));
     })();
+    // Protocol methods keep their static signature: instances of the
+    // implementing classes call the native method.
+    const protocolCall = !callbackProperty && lowerer.classImplementedProtocol(recvTs)
+        ? lowerProtocolMethodCall(lowerer, call, access, recv)
+        : null;
+    if (protocolCall)
+        return protocolCall;
     const dispatched = callbackProperty
         ? null
         : lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayReceiver);
@@ -2851,7 +2868,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
 /** Prototype method names of the checked-dynamic tree-representable kinds (String, Array,
  * Object, Function, Number prototypes): a dyn receiver call on one of
  * these could be a REAL method on a real value, which a stored-member
- * read would silently mis-answer — they keep the fence. Everything else
+ * read would answer incorrectly — they keep the fence. Everything else
  * is own-property-or-throw for every dyn value (the honest dynCall). */
 const DYN_PROTO_METHOD_NAMES = new Set([
     // Object.prototype
@@ -2934,7 +2951,7 @@ const DYN_PROTO_METHOD_NAMES = new Set([
  * subset of DYN_PROTO_METHOD_NAMES with a receiver-kind dispatch): the
  * runtime runs the real method for the receiver's kind, throws Node's
  * is-not-a-function where the kind's prototype lacks the name, and
- * fences LOUDLY on real-but-unimplemented pairs. */
+ * throws the 'not supported yet' Error on real-but-unimplemented pairs. */
 const DYN_DISPATCH_METHODS = new Set([
     "toFixed",
     "toExponential",
@@ -2970,7 +2987,7 @@ const DYN_DISPATCH_METHODS = new Set([
     // boxed through the checked-dynamic boundary): these names dispatch on
     // the runtime kind so a boxed IncomingMessage/ServerResponse/Socket
     // routes onto the same entry points the static lowerings use (modeled
-    // members) or the loud not-supported ladder (real-but-unmodeled ones).
+    // members) or the 'not supported yet' error path (real-but-unmodeled ones).
     // On every other dyn kind they answer exactly what the stored-member
     // path answered (OBJ own members call; the rest throw Node's
     // is-not-a-function).
@@ -3414,7 +3431,7 @@ function lowerNumberToStringCall(lowerer, call, access) {
  * helper dispatches on the tag, so `chunk.toString()` over the ngrok
  * `Buffer | string` listener param needs no narrowing. Unit-armed
  * unions stay out — `(undefined).toString()` THROWS in JS, and
- * claiming it here would silently print "undefined" instead. Null for
+ * claiming it here would print "undefined" instead. Null for
  * other receivers/arms (the narrow-first fences stay). */
 function lowerUnionToStringCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
@@ -3474,6 +3491,9 @@ function lowerDefaultToStringCall(lowerer, call, access) {
         return null;
     }
     const loc = locOf(call);
+    if (recvT.kind === "record" && isPerfEntryType(lowerer, recvT)) {
+        return perfEntryTag(lowerer, lowerer.lowerExpr(access.expression), recvT, loc);
+    }
     const constant = { kind: "strLit", value: "[object Object]", type: STRING, loc };
     // `(<A>{}).toString()` — assertion-wrapped literals and plain reads
     // have nothing to evaluate; pureObjectToStringReceiver widens
@@ -6425,6 +6445,31 @@ function lowerObjectStaticCall(lowerer, call, access) {
     if (call.arguments.length !== 1 || ts.isSpreadElement(call.arguments[0]))
         return null;
     const argNode = call.arguments[0];
+    // util.types and node:util/types list Node's pinned key census
+    // (UTIL_TYPES_KEYS): the object's own keys in Node's order, or the module
+    // namespace's export names sorted with "default". values/entries would
+    // include members that do not compile yet.
+    const probedModule = tryLowerExpression(lowerer, argNode);
+    if (lowerer.builtinNamespaceModuleOf(argNode) === "util/types" ||
+        (probedModule?.type.kind === "moduleNs" && probedModule.type.moduleId === "builtin:util/types")) {
+        if (member !== "keys") {
+            lowerer.noLowering(`Object.${member} over util.types`, call, "call the util.types predicates by name");
+        }
+        const symbol = ts.isIdentifier(argNode)
+            ? lowerer.checker.getSymbolAtLocation(argNode)
+            : undefined;
+        const namespace = symbol
+            ? lowerer.checker.declarationsOf(symbol).some((decl) => ts.isNamespaceImport(decl))
+            : false;
+        const names = namespace ? [...UTIL_TYPES_KEYS, "default"].sort() : UTIL_TYPES_KEYS;
+        const loc = locOf(call);
+        return {
+            kind: "arrayLit",
+            elems: names.map((name) => ({ kind: "strLit", value: name, type: STRING, loc })),
+            type: arrayOf(STRING),
+            loc,
+        };
+    }
     // A compiled PROGRAM module namespace is a nominal token whose members
     // remain live bindings, but its enumerable key set is static and Node
     // sorts it in code-unit order. Materialize exactly those value-export
@@ -6527,6 +6572,18 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     type: resultT,
                     loc: locOf(call),
                 };
+            // Values are `any[]`, which is the checked-dynamic array. When the
+            // program only iterates or indexes the result, or passes it to a
+            // read-only array method, a native vector of the checked values skips
+            // building that array and, for for-of, the iterator protocol.
+            if (member === "values" && !isJsSourceFile(call.getSourceFile()) && consumesValueList(call))
+                return {
+                    kind: "libCall",
+                    fn: "dyn.objValueList",
+                    args: [v],
+                    type: arrayOf(DYN),
+                    loc: locOf(call),
+                };
             return { kind: "libCall", fn, args: [v], type: DYN, loc: locOf(call) };
         }
     }
@@ -6545,6 +6602,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // (own enumerable properties) and — for values/entries — the getter
     // RESULTS, invoked in key order. The static field walk models neither
     // (accessor slots live outside declaredOrder), so the surface fences.
+    fencePerfEntryKeyWalk(lowerer, argIr, call, `Object.${member}`);
     if (shapeHasAccessorSlots(shape)) {
         lowerer.unsupported("SC1090", call, `Object.${member} over a shape carrying get/set accessor properties (Node lists the accessor names${member === "keys" ? "" : " and invokes the getters"} — the static key walk cannot; read the properties explicitly)`);
     }
@@ -6816,6 +6874,41 @@ function consumesEntryPairs(call) {
         ts.isCallExpression(parent.parent) &&
         parent.parent.expression === parent);
 }
+/** Whether an Object.values result is only iterated, indexed or passed to
+ * a read-only array method, so no code observes or changes its array
+ * representation. A bare `.length` read keeps the checked-dynamic array,
+ * which measures as fast. */
+function consumesValueList(call) {
+    let node = call;
+    while (ts.isParenthesizedExpression(node.parent))
+        node = node.parent;
+    const parent = node.parent;
+    if (ts.isForOfStatement(parent))
+        return parent.expression === node && !parent.awaitModifier;
+    if (ts.isElementAccessExpression(parent))
+        return parent.expression === node && !isWriteTarget(parent);
+    if (!ts.isPropertyAccessExpression(parent) || parent.expression !== node)
+        return false;
+    return (VALUE_LIST_METHODS.has(parent.name.text) &&
+        ts.isCallExpression(parent.parent) &&
+        parent.parent.expression === parent);
+}
+/** Whether an access is assigned, updated or deleted. */
+function isWriteTarget(access) {
+    let node = access;
+    while (ts.isParenthesizedExpression(node.parent))
+        node = node.parent;
+    const parent = node.parent;
+    if (ts.isBinaryExpression(parent))
+        return (parent.left === node &&
+            parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+            parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment);
+    if (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent))
+        return (parent.operator === ts.SyntaxKind.PlusPlusToken ||
+            parent.operator === ts.SyntaxKind.MinusMinusToken);
+    return ts.isDeleteExpression(parent);
+}
+const VALUE_LIST_METHODS = new Set(["every", "findIndex", "forEach", "join", "reduce", "some"]);
 const ENTRY_PAIR_CALLBACK_METHODS = new Set([
     "every",
     "filter",
@@ -7015,7 +7108,7 @@ export function lowerRecordFieldCall(lowerer, call, access) {
  * URL.revokeObjectURL() with NO argument: Node's ERR_MISSING_ARGS
  * throws before the registry lookup, so the zero-argument contract is
  * exact without any blob machinery. The one-argument form (Node's
- * silent no-op for unregistered ids) and createObjectURL keep their
+ * no-op for unregistered ids) and createObjectURL keep their
  * fences — a compiled program has no blob registry to consult. */
 function lowerUrlStaticCall(lowerer, call, callee) {
     if (!ts.isPropertyAccessExpression(callee) || callee.questionDotToken !== undefined)
@@ -7444,13 +7537,21 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     if (!info)
         lowerer.flushDeferredClass(receiverIr.className);
     const found = info ? lowerer.findMethodOn(info, access.name.text) : null;
+    // The zlib stream members (flush/params/close/reset) are declared on
+    // the zlib classes; their receivers are runtime Transform streams.
+    if (info &&
+        !found &&
+        ZLIB_STREAM_METHODS.has(access.name.text) &&
+        isZlibStreamMember(lowerer, access)) {
+        return lowerZlibStreamMethodCall(lowerer, call, access);
+    }
     // The stream surface: API-named calls on stream-rooted receivers
     // lower through the stream spoke (checked before the emitter surface
     // — the two member sets are disjoint, but streams root at the emitter
     // so both guards would pass an emitter-named call).
     if (info &&
         !found &&
-        STREAM_API_MEMBERS.has(access.name.text) &&
+        (STREAM_API_MEMBERS.has(access.name.text) || STREAM_OPERATORS.has(access.name.text)) &&
         streamSidesOf(lowerer, info) !== null) {
         const stream = lowerStreamMethodCall(lowerer, call, access, info);
         if (stream)
@@ -7462,6 +7563,11 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     if (info && !found && EMITTER_API_MEMBERS.has(access.name.text) && emitterRooted(lowerer, info)) {
         return lowerEmitterMethodCall(lowerer, call, access, info);
     }
+    // The inherited EventTarget/Event methods of a class rooted at those
+    // runtime bases (subclass members with these names are fenced).
+    if (info && !found && eventTargetApiMethod(info, access.name.text)) {
+        return lowerEventTargetMethodCall(lowerer, call, access, info, lowerReceiver());
+    }
     // GENERIC methods (own type parameters) never enter the methods table:
     // they monomorphize per call site and dispatch statically
     // (lowerClassGenericMethodCall has the exactness rules).