@scriptc/compiler 0.4.4 → 0.4.5

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

@@ -1,5 +1,8 @@
+import { checkedPrivateMethodReceiver, privateNameClass } from "./private-brands.js";
+import { assertFunctionAliasOf } from "./lower-assert.js";
 import { keyedHelperName } from "./stable-names.js";
 import { perKeyOrder } from "./key-order-witness.js";
+import { lowerDateToPrimitiveCall } from "./builtins/dates.js";
 import { isForwardedTupleSpread, lowerForwardingApply } from "./typed-arguments.js";
 import { guardNullProto, nullProtoRecordShape } from "./null-prototype.js";
 import { lowerDynStreamMemberCall } from "./dyn-streams.js";
@@ -20,7 +23,7 @@ import { adaptZeroArgTimerCallback, lowerTimersMemberCall, TIMER_MODULE_MEMBERS,
 import { lowerMockTimersElementCall } from "./lower-test.js";
 import { objectEnumerationReceiver } from "./object-enumeration-receiver.js";
 import { InternalCompilerError } from "../../errors.js";
-import { isFsStreamMember, lowerFsStreamMethodCall } from "./builtins/fs-streams.js";
+import { isFsStreamMember, lowerFsStreamCall, lowerFsStreamMethodCall, } from "./builtins/fs-streams.js";
 import * as ts from "../ts7/adapter.js";
 import { isZlibStreamMember, lowerPromisifiedZlibCall, lowerZlibStreamMethodCall, } from "./builtins/compression.js";
 import { inlineNamespaceRequireOf, lowerInlineRequireValue, lowerUncompiledRequireCall, lowerWithInlineRequireInit, } from "./cjs-inline-require.js";
@@ -59,6 +62,7 @@ import { lowerPromisifiedDnsCall } from "./lower-dgram.js";
 import { lowerDisposableStackUseCall } from "./builtins/disposable-stack.js";
 import { lowerDirentMethodCall, lowerFileHandleMethodCall, lowerDirMethodCall, lowerWatcherMethodCall, } from "./builtins/filesystem.js";
 import { fencePerfEntryKeyWalk, isPerfEntryType, lowerHistogramMethodCall, lowerPerfHooksCall, perfEntryTag, } from "./builtins/performance.js";
+import { fenceX509KeyWalk } from "./builtins/x509.js";
 import { lowerProcStreamMethodCall, lowerProcessBuiltinModuleNamespace, } from "./builtins/process.js";
 import { recordMayKeepSource, throughRecordSource } from "./record-sources.js";
 import { lowerReflectCall } from "./builtins/reflection.js";
@@ -66,7 +70,7 @@ import { lowerAbsenceProbe, v8CalleeText, lowerPromiseAllTupleCall, lowerPromise
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerChildMethodValue, lowerChildPropertyCall } from "./handle-properties.js";
-import { classToNumberConversion } from "./class-to-primitive.js";
+import { classObjectTag, classToNumberConversion } from "./class-to-primitive.js";
 import { hasRuntimeStatics } from "./class-runtime-statics.js";
 import { structuralReadType } from "./class-unions.js";
 import { httpClientFnBindingOf, lowerCompatReqStreamOptionalCall, lowerHttpClientFnCall, } from "./lower-server.js";
@@ -84,7 +88,7 @@ import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedA
 import { fenceSymbolFieldCopy } from "./symbol-fields.js";
 import { lowerClassDataDescriptor, lowerClassDescriptorRead } from "./class-descriptors.js";
 import { lowerClassFieldDefine, lowerClassIntegrity } from "./class-attributes.js";
-import { freezableRecordType, lowerNativeFreeze } from "./frozen-records.js";
+import { freezableRecordType, lowerNativeFreeze, noteUntypedIntegrity } from "./frozen-records.js";
 import { classStaticDataFor } from "./class-static-data.js";
 import { lowerUrlFactory } from "./lower-url.js";
 import { nullishValueUnitOf } from "./binding-analysis.js";
@@ -194,6 +198,11 @@ export function lowerCall(lowerer, expr) {
         if (buffer)
             return { kind: "dynFrom", value: buffer, type: DYN, loc };
     }
+    {
+        const stream = lowerFsStreamCall(lowerer, expr);
+        if (stream)
+            return stream;
+    }
     // A package shim's runtime intrinsic (a bodiless `declare function`
     // named scriptcUnixDgram* in a shipped shim): a direct runtime call.
     if (ts.isIdentifier(expr.expression) && isShimIntrinsicName(expr.expression.text)) {
@@ -374,6 +383,16 @@ export function lowerCall(lowerer, expr) {
         expr.expression.expression.kind === ts.SyntaxKind.SuperKeyword) {
         return lowerer.lowerSuperMethodCall(expr, expr.expression);
     }
+    // `value.#m(...)` on a checked-dynamic value (`this` in a JavaScript
+    // class's receiver-independent method): the private method of the
+    // brand-checked receiver.
+    if (ts.isPropertyAccessExpression(expr.expression) &&
+        ts.isPrivateIdentifier(expr.expression.name) &&
+        !expr.expression.questionDotToken) {
+        const privateCall = lowerCheckedPrivateMethodCall(lowerer, expr, expr.expression);
+        if (privateCall)
+            return privateCall;
+    }
     const consoleMember = lowerer.consoleCallMember(expr);
     const consoleMethod = consoleMember === null ? lowerer.consoleMethodMember(expr) : null;
     if (consoleMember !== null || consoleMethod !== null) {
@@ -775,6 +794,14 @@ export function lowerCall(lowerer, expr) {
         const bi = lowerer.builtinImportOf(expr.expression);
         if (bi)
             return lowerBuiltinCall(lowerer, expr, bi, loc);
+        // A constant bound to an assert method (`const ok = assert.ok`) called
+        // directly is that assertion, with the message Node quotes the call for.
+        {
+            const alias = assertFunctionAliasOf(lowerer, expr.expression);
+            const served = alias ? lowerer.lowerAssertModuleCall(expr, alias, loc) : null;
+            if (served)
+                return served;
+        }
         // The assert module binding called DIRECTLY (`assert(x)` — a default
         // import or the CJS `const assert = require("assert")`): Node's
         // module object IS assert.ok; namespace-import bindings fence inside
@@ -810,7 +837,10 @@ export function lowerCall(lowerer, expr) {
             if (!argNode || (ts.isIdentifier(argNode) && argNode.text === "undefined")) {
                 return { kind: "libCall", fn: "sym.newAnon", args: [], type: SYMBOL_T, loc };
             }
-            const desc = lowerer.lowerExpr(argNode);
+            let desc = lowerer.lowerExpr(argNode);
+            // A number or boolean description is its ToString.
+            if (desc.type.kind === "f64" || desc.type.kind === "bool")
+                desc = lowerer.ensureString(desc, argNode);
             if (desc.type.kind !== "string") {
                 lowerer.noLowering(`Symbol with a '${lowerer.fmt(desc.type)}' description`, argNode, "only string descriptions lower (Node would ToString the value — convert it explicitly)");
             }
@@ -1479,6 +1509,9 @@ export function lowerCall(lowerer, expr) {
     // The element spelling of an unsupported native Web method must fence
     // before lowering the callee into a checked-dynamic keyed read.
     if (ts.isElementAccessExpression(expr.expression)) {
+        const datePrimitive = lowerDateToPrimitiveCall(lowerer, expr, expr.expression);
+        if (datePrimitive)
+            return datePrimitive;
         const timersDispose = lowerMockTimersElementCall(lowerer, expr, expr.expression);
         if (timersDispose)
             return timersDispose;
@@ -2025,6 +2058,9 @@ function lowerNumberConstructorValue(lowerer, argNode, loc) {
     const optionalNumber = lowerOptionalStringNumber(lowerer, arg, loc);
     if (optionalNumber)
         return optionalNumber;
+    // A Date's number hint answers its time value.
+    if (arg.type.kind === "date")
+        return { kind: "libCall", fn: "date.valueOf", args: [arg], type: F64, loc };
     // A program class instance converts through its own methods.
     const classNumber = classToNumberConversion(lowerer, arg, argNode);
     if (classNumber)
@@ -2469,6 +2505,7 @@ methodAccess = null) {
     else if (type.kind === "record") {
         const shape = lowerer.shapes.get(type.shapeId);
         fencePerfEntryKeyWalk(lowerer, type, receiverNode ?? call, `Object.prototype.${method}`);
+        fenceX509KeyWalk(lowerer, type, receiverNode ?? call, `Object.prototype.${method}`);
         if (!shape || shape.tuple || shapeHasAccessorSlots(shape)) {
             lowerer.noLowering("Object.prototype." + method + " over this record shape", receiverNode ?? call);
         }
@@ -2606,6 +2643,11 @@ function lowerObjectPrototypeCall(lowerer, call, access) {
     const immediate = immediateObjectTagReceiver(lowerer, receiverNode);
     const receiver = immediate?.effect ?? lowerer.lowerExpr(receiverNode);
     const tag = immediate?.tag ?? objectToStringTag(lowerer, receiver.type);
+    if (tag === null && immediate === null && call.arguments.nodes.length === 1) {
+        const classTag = classObjectTag(lowerer, receiver, receiverNode);
+        if (classTag)
+            return classTag;
+    }
     // A generator object answers its tag through its checked capsule.
     if (tag === null && receiver.type.kind !== "dyn" && receiver.type.kind !== "generator") {
         lowerer.noLowering("Object.prototype.toString.call over a " + lowerer.fmt(receiver.type) + " receiver", receiverNode);
@@ -7382,7 +7424,14 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 ...(fnName !== null ? { fnName } : {}),
             };
         }
-        if (target && isUnitType(target.type)) {
+        // A class value whose statics are runtime properties of its constructor
+        // boxes to that constructor function, as for Object.defineProperty above.
+        const runtimeStaticClass = target?.type.kind === "classval" ? lowerer.classes.get(target.type.className) : undefined;
+        if (target &&
+            (isUnitType(target.type) ||
+                (runtimeStaticClass !== undefined &&
+                    hasRuntimeStatics(runtimeStaticClass) &&
+                    lowerer.dynConvertible(target.type)))) {
             target = { kind: "dynFrom", value: target, type: DYN, loc: locOf(call.arguments.nodes[0]) };
         }
         if (target?.type.kind === "dyn") {
@@ -7464,6 +7513,8 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 isSealed: "dyn.isSealed",
             };
             const fn = operation[member];
+            if (!member.startsWith("is"))
+                noteUntypedIntegrity(lowerer, call.arguments.nodes[0]);
             return {
                 kind: "libCall",
                 fn,
@@ -7527,8 +7578,10 @@ function lowerObjectStaticCall(lowerer, call, access) {
             (ts.isObjectLiteralExpression(inner) || ts.isArrayLiteralExpression(inner))
             ? lowerer.lowerExprExpecting(argNode, DYN)
             : lowerer.lowerExpr(argNode);
-        if (value.type.kind === "dyn")
+        if (value.type.kind === "dyn") {
+            noteUntypedIntegrity(lowerer, argNode);
             return { kind: "libCall", fn: "dyn.freeze", args: [value], type: DYN, loc: locOf(call) };
+        }
         if (ts.isObjectLiteralExpression(inner) || ts.isArrayLiteralExpression(inner)) {
             return value; // fresh — freeze is identity here, honestly
         }
@@ -7599,7 +7652,12 @@ function lowerObjectStaticCall(lowerer, call, access) {
             (probed && isDynTypedRefType(probed.type)) ||
             (probed?.type.kind === "object" && lowerer.errorHierarchyClassOf(probed.type.className)) ||
             (probed && constructor && (constructor.callableBase || hasRuntimeStatics(constructor))) ||
-            (probed?.type.kind === "func" && lowerer.dynConvertible(probed.type))) {
+            (probed?.type.kind === "func" && lowerer.dynConvertible(probed.type)) ||
+            // null, undefined and unions of untyped JavaScript values: the same
+            // probe, whose ToObject throws Node's TypeError on nullish.
+            (probed &&
+                (isUnitType(probed.type) || probed.type.kind === "union") &&
+                lowerer.dynConvertible(probed.type))) {
             const loc = locOf(call);
             const receiver = lowerer.coerceToExpected(probed, DYN);
             const rawKey = arrayKey ?? lowerer.lowerExpr(keyNode);
@@ -7810,6 +7868,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // 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}`);
+    fenceX509KeyWalk(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)`);
     }
@@ -9959,4 +10018,35 @@ function lowerShimIntrinsicCall(lowerer, expr, callee, loc) {
     const args = expr.arguments.nodes.map((arg, i) => lowerer.lowerExprExpecting(arg, intrinsic.args[i]));
     return { kind: "libCall", fn: intrinsic.fn, args, type: intrinsic.ret, loc };
 }
+/** `value.#m(args)` where `value` lowers to a checked-dynamic value and the
+ * declaration-level class whose body declares `#m` declares it as a method:
+ * the method called on the brand-checked receiver
+ * (checkedPrivateMethodReceiver). Null for any other private member call. */
+function lowerCheckedPrivateMethodCall(lowerer, call, access) {
+    if (!ts.isPrivateIdentifier(access.name))
+        return null;
+    const name = access.name.text;
+    const owner = privateNameClass(lowerer, access.name);
+    const found = owner ? lowerer.findMethodOn(owner, name) : null;
+    if (!owner || !found || found.declarer !== owner || found.sig.abstract === true)
+        return null;
+    const probed = tryLowerExpression(lowerer, access.expression);
+    if (!probed || !checkedDynamicOperand(probed))
+        return null;
+    const value = checkedDynamicOperand(lowerer.lowerExpr(access.expression));
+    if (!value)
+        return null;
+    const loc = locOf(call);
+    const callee = `%${owner.def.name}.${name}`;
+    lowerer.noteEdge(callee);
+    const receiver = checkedPrivateMethodReceiver(lowerer, owner, name, value, loc);
+    const args = lowerer.completeArgs(call.arguments.nodes, found.sig.params, loc, call);
+    return { kind: "call", callee, args: [receiver, ...args], type: found.sig.ret, loc };
+}
+/** A checked-dynamic value, or the dynamic value under a checked extraction. */
+function checkedDynamicOperand(expr) {
+    if (expr.type.kind === "dyn")
+        return expr;
+    return expr.kind === "dynCheck" && expr.value.type.kind === "dyn" ? expr.value : null;
+}
 //# sourceMappingURL=lower-calls.js.map