@scriptc/compiler 0.4.0 → 0.4.1

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

@@ -62,6 +62,7 @@ import { lowerReflectCall } from "./builtins/reflection.js";
 import { lowerAbsenceProbe, v8CalleeText, lowerOptionalNumber, lowerPromiseAllTupleCall, lowerPromiseRejectCall, lowerToNumberArgument, stringWrapperToString, symbolFieldInfo, templateRawTextOf, } from "./lower-exprs.js";
 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 { hasRuntimeStatics } from "./class-runtime-statics.js";
 import { structuralReadType } from "./class-unions.js";
@@ -1160,6 +1161,7 @@ export function lowerCall(lowerer, expr) {
             lowerCipherMethodCall(lowerer, expr, expr.expression) ??
             lowerFileHandleMethodCall(lowerer, expr, expr.expression) ??
             lowerDirMethodCall(lowerer, expr, expr.expression) ??
+            lowerChildPropertyCall(lowerer, expr, expr.expression) ??
             lowerer.lowerChildMethodCall(expr, expr.expression) ??
             // Piped child-output stream receivers — on/once("data" | "end").
             lowerChildStreamMethodCall(lowerer, expr, expr.expression) ??
@@ -1335,6 +1337,11 @@ export function lowerCall(lowerer, expr) {
                     return nsUndefRead(lowerer, ambientRoot.text, expr, t);
             }
         }
+        {
+            const childCall = lowerChildPropertyCall(lowerer, expr, expr.expression, true);
+            if (childCall)
+                return childCall;
+        }
         // The lib fence's METHOD-CALL chokepoint: a stdlib-declared member
         // that every lowering above declined — an unlowered member
         // (m.keys(), p.then(f), Object.keys(o)) or an unlowered call FORM of
@@ -1774,6 +1781,59 @@ function lowerStringMethodCallWithOptionalArgs(lowerer, call, access, receiver,
     }
     return changed ? { ...lowered, args } : lowered;
 }
+/** `.then(String)` / `.then(Number)` / `.then(Boolean)` over a promise of
+ * a number, string or boolean: the ambient constructor converts its first
+ * argument (the settled value), so the handler is an interned closure over
+ * the settled type applying that conversion. The constructors' own value
+ * form takes a string, which a number or boolean settled value is not.
+ * Null for every other handler. */
+function primitiveConversionHandler(lowerer, node, inner) {
+    if (!ts.isIdentifier(node))
+        return null;
+    const name = node.text;
+    if (name !== "String" && name !== "Number" && name !== "Boolean")
+        return null;
+    // A string settled value already fits the constructors' value form.
+    if (inner.kind !== "f64" && inner.kind !== "bool")
+        return null;
+    if (!lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(node) ?? undefined))
+        return null;
+    const loc = locOf(node);
+    const ret = name === "String" ? STRING : name === "Number" ? F64 : BOOL;
+    const fnT = funcOf([inner], ret);
+    const key = `then.${name}:${typeKey(inner)}`;
+    let fnName = lowerer.arrHofHelpers.get(key);
+    if (fnName === undefined) {
+        fnName = `%then.${name}.${lowerer.arrHofHelpers.size}`;
+        lowerer.arrHofHelpers.set(key, fnName);
+        const value = varRef("v.0", inner, loc);
+        let body;
+        if (name === "Boolean")
+            body = { kind: "toBool", operand: value, type: BOOL, loc };
+        else if (name === "String")
+            body = { kind: "toString", operand: value, type: STRING, loc };
+        else if (inner.kind === "f64")
+            body = value;
+        else
+            body = {
+                kind: "ternary",
+                cond: value,
+                then: { kind: "numLit", value: 1, type: F64, loc },
+                else_: { kind: "numLit", value: 0, type: F64, loc },
+                type: F64,
+                loc,
+            };
+        lowerer.liftedFns.push({
+            name: fnName,
+            params: [{ localId: "v.0", name: "v", type: inner }],
+            returnType: ret,
+            locals: [{ id: "v.0", name: "v", type: inner, mutable: false }],
+            body: [{ kind: "return", value: body, loc }],
+            loc,
+        });
+    }
+    return { kind: "closure", fnName, captures: [], type: fnT, loc };
+}
 function lowerNumberConstructorValue(lowerer, argNode, loc) {
     const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, argNode);
     if (undefinedArg) {
@@ -2781,6 +2841,9 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
         ? lowerer.checker.getNonNullableType(rawRecvTs)
         : rawRecvTs;
     if (lowerer.classImplementedProtocol(recvTs)) {
+        const viewed = pickViewGenericMethodCall(lowerer, call, access, recvTs);
+        if (viewed)
+            return viewed;
         const property = lowerer.checker.getPropertyOfType(recvTs, access.name.text);
         if (property &&
             isGenericCallableMemberType(lowerer.checker.getTypeOfSymbol(property), lowerer.checker))
@@ -3116,7 +3179,18 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
                 ?.arms.every((arm) => arm.kind === "object" &&
                 lowerer.classes.get(arm.className)?.fields.has(access.name.text)))
             return true;
+        // A standard-library member spelled as a function-typed property
+        // (undici-types declares Headers.append/forEach/... and the body mixin
+        // as `readonly append: (...) => void`; scriptc's own declarations use
+        // methods) is still the handle's native method: it takes the shared
+        // receiver dispatch below either way (which also calls a plain object's
+        // own member), so the lowering does not depend on which declaration
+        // file supplies the type.
+        const libMethod = prop !== undefined &&
+            prop.declarations.length > 0 &&
+            prop.declarations.every((decl) => lowerer.isStdlibFile(decl.getSourceFile()));
         return (prop !== undefined &&
+            !libMethod &&
             prop.declarations.some((decl) => ts.isPropertyDeclaration(decl) || ts.isPropertySignature(decl)));
     })();
     // Protocol methods keep their static signature: instances of the
@@ -3656,8 +3730,14 @@ function lowerArrayIsArrayCall(lowerer, call, access) {
     if (call.arguments.nodes.length !== 1)
         return null; // the stdlib chokepoint fences
     const argNode = call.arguments.nodes[0];
-    const arg = lowerer.lowerExpr(argNode);
+    let arg = lowerer.lowerExpr(argNode);
     const loc = locOf(call);
+    // A checker-narrowed dyn read arrives as a validated extraction (the
+    // dynCheck bridge). The runtime value may be wider than the flow type
+    // claims (an overload narrower than what arrives), so test the dyn value
+    // itself instead of folding on the extracted type (typeof's rule).
+    if (arg.kind === "dynCheck" && arg.value.type.kind === "dyn")
+        arg = arg.value;
     if (arg.type.kind === "dyn") {
         return { kind: "dynTest", test: "array", value: arg, type: BOOL, loc };
     }
@@ -4982,7 +5062,8 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         // the handle is the value's only story, isIslandExpr's local rule).
         if (inner.kind === "moduleNs")
             markModuleNsHandlerParams(lowerer, call.arguments.nodes[0], inner);
-        let cb = lowerer.lowerExpr(call.arguments.nodes[0]);
+        let cb = primitiveConversionHandler(lowerer, call.arguments.nodes[0], inner) ??
+            lowerer.lowerExpr(call.arguments.nodes[0]);
         // A TYPED handler on a DYN-settling promise (the tracePromise
         // result's `.then((value) => ...)` — the checker's generic
         // instantiation typed the parameter, but the settled value is a
@@ -8174,13 +8255,31 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
         if ((name === "apply" || name === "call" || name === "bind") &&
             lowerer.checker.getCallSignatures(recvT).length > 0) {
             const value = tryLowerExpression(lowerer, access.expression);
-            if (value?.type.kind === "func" &&
-                lowerer.dynConvertible(value.type) &&
+            // Builtin function values held as checked-dynamic functions
+            // (String.fromCharCode, JSON.stringify) bind the same way, and so
+            // does a member that lowers to a checked-dynamic value (a native
+            // handle's method read in JavaScript).
+            if (value &&
+                (value.type.kind === "dyn" ||
+                    (value.type.kind === "func" && lowerer.dynConvertible(value.type))) &&
                 !call.arguments.nodes.some(ts.isSpreadElement)) {
                 const loc = locOf(call);
                 return {
                     kind: "dynInvoke",
-                    recv: { kind: "dynFrom", value, type: DYN, loc },
+                    recv: value.type.kind === "dyn" ? value : { kind: "dynFrom", value, type: DYN, loc },
+                    method: name,
+                    calleeName: ts.getTextOfNode(access),
+                    args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                    type: DYN,
+                    loc,
+                };
+            }
+            const childMethod = lowerChildMethodValue(lowerer, access.expression);
+            if (childMethod && !call.arguments.nodes.some(ts.isSpreadElement)) {
+                const loc = locOf(call);
+                return {
+                    kind: "dynInvoke",
+                    recv: childMethod,
                     method: name,
                     calleeName: ts.getTextOfNode(access),
                     args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
@@ -8919,7 +9018,28 @@ export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
         const radix = args[1]
             ? lowerer.lowerExprExpecting(args[1], F64)
             : { kind: "numLit", value: 0, type: F64, loc };
-        const optional = optionalCallValue(lowerer, args[0]);
+        let optional = optionalCallValue(lowerer, args[0]);
+        let lowered = null;
+        // A possibly-missing or untyped text in JavaScript (`parseInt(process.
+        // env.PORT, 10)`): TypeScript rejects the call, Node parses the text
+        // of whatever arrives ("undefined").
+        if (optional === null && isJsSourceFile(ts.getSourceFileOfNode(call))) {
+            const argT = lowerer.typeOf(args[0]);
+            const parts = argT.isUnionType() ? ts.constituentTypes(argT) : [argT];
+            if (parts.some((part) => (part.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Any)) !== 0)) {
+                const raw = lowerer.lowerExpr(args[0]);
+                if (raw.type.kind === "union") {
+                    optional = raw;
+                    lowered = raw;
+                }
+                else {
+                    const text = raw.type.kind === "dyn"
+                        ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [raw], type: STRING, loc }
+                        : lowerer.coerceInto(args[0], raw, STRING);
+                    return { kind: "libCall", fn: "num.parseInt", args: [text, radix], type: F64, loc };
+                }
+            }
+        }
         if (optional?.type.kind === "union") {
             const def = lowerer.unions.get(optional.type.unionId);
             const stringTag = def?.arms.findIndex((arm) => arm.kind === "string") ?? -1;
@@ -9014,7 +9134,9 @@ export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
                 return { kind: "call", callee: helper, args: [optional, radix], type: F64, loc };
             }
         }
-        const s = lowerer.lowerExprExpecting(args[0], STRING);
+        const s = lowered !== null
+            ? lowerer.coerceInto(args[0], lowered, STRING)
+            : lowerer.lowerExprExpecting(args[0], STRING);
         return { kind: "libCall", fn: "num.parseInt", args: [s, radix], type: F64, loc };
     }
     // STATIC parseFloat/isFinite over exactly-typed arguments —
@@ -9084,6 +9206,43 @@ function maybePromiseHandlerResult(lowerer, call, value, R) {
     }
     return stmt;
 }
+/** `view.m(args)` where `view` is a `Pick<C, K>` / `Omit<C, K>` view of a
+ * program class C and `m` is one of C's GENERIC methods (its overloads
+ * included): generic methods have no dispatchable method value, so the
+ * view's live receiver is extracted as the C instance it holds (a checked
+ * extraction — a value of another class throws Node-style TypeError
+ * text naming C) and the call monomorphizes statically against C, the
+ * same lowering a C-typed receiver gets. Null for other receivers. */
+function pickViewGenericMethodCall(lowerer, call, access, recvTs) {
+    const alias = recvTs.getAliasSymbol();
+    if (alias === undefined || (ts.symbolName(alias) !== "Pick" && ts.symbolName(alias) !== "Omit"))
+        return null;
+    if (!alias.declarations.every((d) => ts.getSourceFileOfNode(d).isDeclarationFile))
+        return null;
+    const source = recvTs.getAliasTypeArguments()[0];
+    const symbol = source?.getSymbol();
+    const info = symbol ? lowerer.classBySymbol.get(symbol) : undefined;
+    if (!info || call.questionDotToken || access.questionDotToken)
+        return null;
+    const found = findGenericMethodOn(lowerer, info, access.name.text);
+    if (!found)
+        return null;
+    const loc = locOf(access.expression);
+    const lowered = lowerer.lowerExpr(access.expression);
+    const instance = { kind: "object", className: info.def.name };
+    // A view that statically holds an instance of another class (a
+    // structurally compatible one) calls that class's method in Node, not
+    // C's: the call is refused rather than extracted as a C instance.
+    if (lowered.type.kind === "object" &&
+        lowered.type.className !== info.def.name &&
+        !lowerer.isSubclassOf(lowered.type.className, info.def.name)) {
+        lowerer.unsupported("SC1090", access, `calling the generic method '${access.name.text}' through a '${ts.symbolName(alias)}' view of '${info.def.name}' that holds a '${lowerer.fmt(lowered.type)}'`);
+    }
+    const receiver = lowered.type.kind === "object"
+        ? lowered
+        : { kind: "dynCheck", value: lowerer.coerceToExpected(lowered, DYN), type: instance, loc };
+    return lowerClassGenericMethodCall(lowerer, call, access, info, found, receiver);
+}
 /** `Object.assign(err, ...sources)` in TypeScript onto an error-hierarchy
  * target (`Object.assign(new Error(message), details)`): the sources'
  * own members land on the error — the runtime copy over its