@scriptc/compiler 0.3.3 → 0.3.5

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

@@ -9,7 +9,9 @@ import { threadsImportOf } from "../threads-import.js";
 import { adaptZeroArgTimerCallback, lowerTimersMemberCall, TIMER_MODULE_MEMBERS, } from "./lower-timers.js";
 import { objectEnumerationReceiver } from "./object-enumeration-receiver.js";
 import { InternalCompilerError } from "../../errors.js";
+import { isFsStreamMember, lowerFsStreamMethodCall } from "./builtins/fs-streams.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";
@@ -17,6 +19,7 @@ import { lowerClassPrototypeAssign, lowerClassPrototypeDescriptors } from "./cla
 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, UTIL_TYPES_KEYS, stdlibGlobalNameOf, } from "./surfaces.js";
@@ -33,10 +36,11 @@ 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 { 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 { recordMayKeepSource, throughRecordSource } from "./record-sources.js";
 import { lowerReflectCall } from "./builtins/reflection.js";
 import { lowerAbsenceProbe, lowerOptionalNumber, lowerPromiseAllTupleCall, lowerPromiseRejectCall, lowerToNumberArgument, stringWrapperToString, symbolFieldInfo, templateRawTextOf, } from "./lower-exprs.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
@@ -48,7 +52,7 @@ 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";
@@ -62,6 +66,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
@@ -350,6 +355,29 @@ export function lowerCall(lowerer, expr) {
                 if (tr &&
                     ts.isArrayLiteralExpression(tr.initializer) &&
                     tr.initializer.elements.length > 0) {
+                    // An ArrayBuffer first member may be a Buffer pool slab, which
+                    // Node reports as untransferable.
+                    const first = tr.initializer.elements[0];
+                    const firstType = ts.isSpreadElement(first) ? undefined : lowerer.typeOf(first);
+                    const parts = !firstType
+                        ? []
+                        : firstType.isUnionType()
+                            ? ts.constituentTypes(firstType)
+                            : [firstType];
+                    const isStorage = parts.length > 0 &&
+                        parts.every((part) => {
+                            const name = part.getSymbol()?.name;
+                            return name === "ArrayBuffer" || name === "SharedArrayBuffer";
+                        });
+                    if (isStorage) {
+                        return {
+                            kind: "libCall",
+                            fn: "dyn.cloneTransferFailWith",
+                            args: [toDynArg(first)],
+                            type: DYN,
+                            loc,
+                        };
+                    }
                     return { kind: "libCall", fn: "dyn.cloneTransferFail", args: [], type: DYN, loc };
                 }
             }
@@ -539,6 +567,9 @@ export function lowerCall(lowerer, expr) {
             if (projection?.kind === "promisified-exec-file") {
                 return lowerer.lowerExecFileAsyncCall(expr, loc);
             }
+            if (projection?.kind === "promisified-exec") {
+                return lowerer.lowerExecFileAsyncCall(expr, loc, true);
+            }
             if (projection?.kind === "promisified-builtin") {
                 return lowerBuiltinCall(lowerer, expr, { module: projection.module, member: projection.member }, loc);
             }
@@ -963,6 +994,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.
@@ -994,6 +1027,7 @@ 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) ??
@@ -6632,11 +6666,30 @@ function lowerObjectStaticCall(lowerer, call, access) {
     const resultT = member === "entries" && consumesEntryPairs(call)
         ? runtimeOptionalEntriesType(lowerer, argIr, checkedT)
         : checkedT;
-    const receiver = objectEnumerationReceiver(lowerer, lowerer.lowerExpr(argNode), argIr, loc);
+    const enumerated = objectEnumerationReceiver(lowerer, lowerer.lowerExpr(argNode), argIr, loc);
+    // A record that kept undeclared properties of its checked source answers
+    // from its live checked view (values checked into the static result).
+    const recordT = argIr;
+    const sourced = (staticAnswer) => recordMayKeepSource(lowerer, recordT)
+        ? throughRecordSource(lowerer, enumerated, loc, staticAnswer, (view, type) => member === "keys"
+            ? { kind: "libCall", fn: "dyn.objKeyStrings", args: [view], type, loc }
+            : {
+                kind: "dynCheck",
+                value: {
+                    kind: "libCall",
+                    fn: member === "values" ? "dyn.objValues" : "dyn.objEntries",
+                    args: [view],
+                    type: DYN,
+                    loc,
+                },
+                type,
+                loc,
+            })
+        : staticAnswer(enumerated);
     if (member === "keys") {
         // The keys walk is shared with for-in (which iterates exactly the
         // keys Object.keys answers — one construction, one intern key).
-        return recordKeysArrayCall(lowerer, receiver, argIr, shape, loc);
+        return sourced((receiver) => recordKeysArrayCall(lowerer, receiver, argIr, shape, loc));
     }
     // The result-element type each field's value flows into: string for
     // keys, the checker's value union for values, the [string, V] tuple's
@@ -6849,7 +6902,8 @@ function lowerObjectStaticCall(lowerer, call, access) {
         lowerer.shapeOrderHelperFinalizers.push(finalize);
         lowerer.liftedFns.push(fn);
     }
-    return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
+    const callee = helper;
+    return sourced((receiver) => ({ kind: "call", callee, args: [receiver], type: resultT, loc }));
 }
 /** An entries array consumed pair by pair right where it is built: a
  * for-of loop or an array callback method. These consumers bind each pair
@@ -7531,13 +7585,28 @@ 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);
+    }
+    // fs.ReadStream / fs.WriteStream's close(cb?): declared on the fs
+    // classes; their receivers are runtime Readable / Writable streams.
+    if (info && !found && isFsStreamMember(lowerer, access)) {
+        const member = lowerFsStreamMethodCall(lowerer, call, access);
+        if (member)
+            return member;
+    }
     // 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)