@scriptc/compiler 0.4.6 → 0.4.8

package/dist/frontend/lowering/expressions/binary.js

@@ -1,27 +1,31 @@
 /* Binary operators: arithmetic, comparisons and equality, logical and nullish pairs, and string conversion for concatenation. */
+import { lowerStaticPrivateAssignment } from "../private-statics.js";
 import { keyedHelperName } from "../stable-names.js";
 import * as ts from "../../ts7/adapter.js";
 import { lowerOptionalIndex, splitUndefinedIndex, undefinedTypedArrayKeyFence, } from "../undefined-index.js";
 import { cleanFuncAdaptable } from "../coercions/function-adapters.js";
 import { jsFuncNameOf } from "../lowerer.js";
+import { recordMayKeepSource } from "../record-sources.js";
+import { recordStringCall } from "../record-links.js";
 import { BIGINT_T, BOOL, DYN, DYN_HANDLE_KINDS, F64, REF_TRUTHY_KINDS, STRING, UNDEFINED_T, VOID, canBoxFuncIntoDyn, isUnitType, typeEquals, typeKey, } from "../../../ir/ir.js";
 import { isSafeToDiscard, isSafeToRepeat } from "./evaluation-safety.js";
-import { bigintCompoundValue, compoundUnsupported, concatOperand, constructorGlobalTypeof, deferredSlotOr, dynCompoundValue, lowerAbsenceProbe, lowerDynMemberAssignment, lowerDereferencedElementAssignment, lowerOptionalNumber, lowerPresenceOperand, nullishBranches, operandPairs, operatorUnsupported, runtimeOptionalStorageOperand, symbolFieldInfo, typeofAnswer, } from "../lower-exprs.js";
+import { bigintCompoundValue, compoundUnsupported, concatOperand, constructorGlobalTypeof, deferredSlotOr, dynCompoundValue, lowerAbsenceProbe, lowerDynMemberAssignment, lowerDereferencedElementAssignment, lowerOperatorNumber, lowerPresenceOperand, nullishBranches, operandPairs, operatorUnsupported, runtimeOptionalStorageOperand, symbolFieldInfo, typeofAnswer, } from "../lower-exprs.js";
 import { COMPOUND_ASSIGN_OPS, NARROW_FIRST } from "../surfaces.js";
 import { lowerElementCompoundParts } from "./element-access.js";
 import { InternalCompilerError } from "../../../errors.js";
 import { isJsSourceFile, locOf } from "../../program.js";
-import { storedClassValueType } from "../lower-classes.js";
+import { findStaticOn, storedClassValueType } from "../lower-classes.js";
 import { builtinClassKind } from "../builtins/builtin-class-dyn.js";
-import { hasRuntimeStatics } from "../class-runtime-statics.js";
+import { hasRuntimeStatics, runtimeStaticDefines } from "../class-runtime-statics.js";
 import { tryLowerExpression } from "./try-lower-expression.js";
 import { fenceNodeModuleMutation, lowerRequireCacheHas } from "../lower-node-module.js";
 import { errorToStringCall } from "../error-methods.js";
 import { classToStringConversion, classUnionToString } from "../class-to-primitive.js";
+import { genericDeclarationBehindValue, noteDynamicIdentityComparison, notePinnedIdentityComparison, } from "../generic-functions.js";
 import { isPerfEntryType, perfEntryTag } from "../builtins/performance.js";
 import { isX509Type, x509ToString } from "../builtins/x509.js";
 import { guardNullProto, nullProtoRecordShape } from "../null-prototype.js";
-import { numLit, varRef } from "../../../ir/build.js";
+import { boolLit, numLit, varRef } from "../../../ir/build.js";
 import { lowerUrlAssignment } from "../builtins/url.js";
 import { lowerClassPrototypeComputedAssignment } from "../class-prototypes.js";
 import { lowerShortCircuitAssignment } from "./nullish-assignment.js";
@@ -32,16 +36,18 @@ import { nsWritableTarget } from "../lower-namespaces.js";
 import { arrayValueStore, tryLowerBytesReadNumberEquality } from "../array-values.js";
 import { cjsExportMemberWriteGlobalOf, cjsInFileExportGlobalOf } from "../cjs-exports-object.js";
 import { lowerUnionFieldWrite } from "./union-fields.js";
+import { emptyArrayLiteralArm } from "./array-literals.js";
 import { lowerAbstractEquality } from "../abstract-equality.js";
 import { lowerInExpression } from "./relational.js";
 import { lowerDynTypeofTest, lowerErrorCodeTypeofTest } from "./typeof.js";
 import { builtinClassRefOf, sameBuiltinClass } from "../builtins/class-values.js";
 import { lowerRuntimeConstructorIs, runtimeConstructorReceiver, } from "../builtins/runtime-constructor.js";
 import { tryLowerIndexedComparison } from "../indexed-comparison.js";
-import { lowerUnionEquality, tagEqualityMayMissAlias } from "../strict-equality.js";
+import { lowerUnionEquality, sameNamespace, tagEqualityMayMissAlias } from "../strict-equality.js";
 import { withUnitArm } from "../../type-mapper.js";
 import { npmStaticPackageOfPath } from "../../npm-static.js";
 import { lowerWebAssemblyTypeof } from "../builtins/webassembly.js";
+import { lowerEnvironmentIdentity } from "../builtins/environment.js";
 /** `v === undefined` / `v !== null` — the narrowing tests for unit-armed
  * unions. A union operand compared with a unit literal lowers to a
  * runtime TAG test (unionIsTag); afterwards tsc's control-flow narrowing
@@ -252,6 +258,36 @@ function lowerLooseNullCompare(lowerer, expr, loc) {
     // `== null` is statically false, `!= null` statically true.
     return { kind: "boolLit", value: negated, type: BOOL, loc };
 }
+/** A plain value read whose storage can carry undefined while the checker
+ * types the read at its declared type: an element access on an array or a
+ * keyed record, a property name only the receiver's index signature answers,
+ * a binding or a call the runtime-optional analysis widened. Checker and
+ * analysis state only: the read is lowered once, where it is used. */
+function mayLowerAbsent(lowerer, node) {
+    let expr = node;
+    while (ts.isParenthesizedExpression(expr) || ts.isAsExpression(expr) || ts.isTypeAssertion(expr))
+        expr = expr.expression;
+    if (ts.isIdentifier(expr))
+        return runtimeOptionalStorageOperand(lowerer, expr) !== null;
+    if (ts.isCallExpression(expr))
+        return lowerer.isRuntimeOptionalOrigin(expr);
+    if (ts.isElementAccessExpression(expr)) {
+        let receiver = expr.expression;
+        while (ts.isParenthesizedExpression(receiver))
+            receiver = receiver.expression;
+        const type = lowerer.checker.getTypeAtLocation(receiver);
+        return (lowerer.checker.isArrayType(type) ||
+            lowerer.checker.isTupleType(type) ||
+            lowerer.checker.getIndexInfosOfType(type).length > 0);
+    }
+    if (ts.isPropertyAccessExpression(expr)) {
+        const type = lowerer.checker.getTypeAtLocation(expr.expression);
+        if (lowerer.checker.getPropertyOfType(type, expr.name.text))
+            return false;
+        return lowerer.checker.getIndexInfosOfType(type).length > 0;
+    }
+    return false;
+}
 /** A plain value read that may be runtime-optional: an unchecked element
  * read, or a binding, member or call that carries one. Lowering these
  * without a destination type is the same as lowering them into one. */
@@ -335,6 +371,7 @@ export function lowerNullishPair(lowerer, expr, loc, left) {
     }
     if (left.type.kind !== "union")
         return left;
+    const leftUnion = left.type;
     const def = lowerer.unions.get(left.type.unionId);
     if (!def)
         lowerer.badType(expr.left, lowerer.typeOf(expr.left));
@@ -360,6 +397,22 @@ export function lowerNullishPair(lowerer, expr, loc, left) {
         const right = lowerer.lowerExprExpecting(expr.right, rest[0]);
         return { kind: "nullish", left, right, type: rest[0], loc };
     }
+    // An EMPTY array-literal default (`''.match(re) ?? []`) has no element of
+    // its own, so it builds as the left's array arm (the emptyArrayLiteralArm
+    // rule the union slot and the contextual union share) and the whole
+    // expression answers the left's array type instead of the checker's
+    // `never[]`-flavored second arm. A JavaScript `[]` is `any[]` and keeps
+    // the dynamic path.
+    if (rest.length === 1 &&
+        rest[0].kind === "array" &&
+        !isJsSourceFile(ts.getSourceFileOfNode(expr.right))) {
+        const arm = emptyArrayLiteralArm(expr.right, rest);
+        if (arm) {
+            const right = lowerer.lowerExprExpecting(expr.right, arm);
+            if (typeEquals(right.type, arm))
+                return { kind: "nullish", left, right, type: arm, loc };
+        }
+    }
     let type = lowerer.irTypeOf(expr);
     // A runtime-optional read can reach the default even when declarations
     // call the left side present. Preserve a differently typed primitive
@@ -405,6 +458,37 @@ export function lowerNullishPair(lowerer, expr, loc, left) {
             loc,
         };
     }
+    const admitsUndefined = (t) => t.kind === "union" && lowerer.armTag(t.unionId, UNDEFINED_T) >= 0;
+    // A runtime-optional read can be the DEFAULT too (`empty.a ?? empty.b`,
+    // `names[0] ?? names[1]`): the checker types a keyed read at the record's
+    // value type, but a missing key or index is undefined at run time. The
+    // default's own lowering already carries that absent arm, so the result
+    // keeps it — the left's storage when both sides share it, the checker's
+    // type plus an undefined arm otherwise — instead of coercing the absence
+    // back into the checker's narrower union.
+    if (isPlainValueRead(expr.right) &&
+        !isMemberReceiver(expr) &&
+        !admitsUndefined(type) &&
+        mayLowerAbsent(lowerer, expr.right)) {
+        const raw = lowerer.lowerExpr(expr.right);
+        if (admitsUndefined(raw.type)) {
+            if (typeEquals(raw.type, leftUnion))
+                return { kind: "nullish", left, right: raw, type: leftUnion, loc };
+            const widened = lowerer.runtimeOptionalType(type);
+            if (widened.kind === "union" && admitsUndefined(widened)) {
+                if (typeEquals(widened, leftUnion)) {
+                    const right = lowerer.coerceInto(expr.right, raw, widened);
+                    return { kind: "nullish", left, right, type: widened, loc };
+                }
+                const retag = lowerer.unionRetagHelper(leftUnion.unionId, widened.unionId, loc) ??
+                    lowerer.narrowedRetagHelper(expr.left, leftUnion.unionId, widened.unionId, loc);
+                if (retag !== null) {
+                    const right = lowerer.coerceInto(expr.right, raw, widened);
+                    return nullishBranches(lowerer, left, leftUnion, def.arms, widened, loc, () => right, (stable) => ({ kind: "call", callee: retag, args: [stable], type: widened, loc }));
+                }
+            }
+        }
+    }
     // A runtime-optional default (`name ?? names[0]`): the checker types an
     // unchecked element read as the bare element type, but an out-of-range
     // read is undefined at runtime. When the default shares the left's
@@ -508,7 +592,25 @@ export function lowerNativeFunctionAssignment(lowerer, expr) {
     // Checked constructors share the callable's live property descriptors.
     const classType = storedClassValueType(lowerer, target.expression);
     const staticClass = classType?.kind === "classval" ? lowerer.classes.get(classType.className) : undefined;
-    if (staticClass && hasRuntimeStatics(staticClass)) {
+    // The member named by a statically known key: a class whose property
+    // table does not carry it (a class whose only runtime static is its
+    // `Symbol.hasInstance` hook) writes its own storage instead, exactly as
+    // it reads it. A member the class does not declare at all is a property
+    // of the class object, wherever the key comes from.
+    const staticName = ts.isPropertyAccessExpression(target)
+        ? ts.isPrivateIdentifier(target.name)
+            ? null
+            : target.name.text
+        : ts.isStringLiteral(target.argumentExpression)
+            ? target.argumentExpression.text
+            : undefined;
+    const writesThroughTable = staticClass !== undefined &&
+        hasRuntimeStatics(staticClass) &&
+        staticName !== null &&
+        (staticName === undefined ||
+            findStaticOn(lowerer, staticClass, staticName) === null ||
+            runtimeStaticDefines(lowerer, staticClass, staticName));
+    if (writesThroughTable) {
         return lowerDynMemberAssignment(lowerer, expr, lowerer.lowerExprExpecting(target.expression, DYN));
     }
     // Other class statics and prototype tables have their own paths.
@@ -551,6 +653,10 @@ export function ensureString(lowerer, e, node) {
         return e;
     if (e.type.kind === "url")
         return { kind: "libCall", fn: "url.href", args: [e], type: STRING, loc: e.loc };
+    // String(sp) / `${new URLSearchParams(...)}`: URLSearchParams.toString,
+    // the serialized list (`?` stripped, pairs encoded).
+    if (e.type.kind === "searchParams")
+        return { kind: "libCall", fn: "sp.toString", args: [e], type: STRING, loc: e.loc };
     // String(date) / `${date}` / "" + date: Date's ToPrimitive prefers
     // toString().
     if (e.type.kind === "date")
@@ -727,6 +833,10 @@ export function ensureString(lowerer, e, node) {
             const nullProtoT = nullProtoRecordShape(lowerer, e.type);
             if (nullProtoT)
                 return nullProtoToString(lowerer, e, nullProtoT);
+            // A linked copy or a record with a kept source converts as its
+            // source does (record-links.ts).
+            if (recordMayKeepSource(lowerer, e.type))
+                return recordStringCall(lowerer, e, "string", e.loc, "toString");
             return { kind: "toString", operand: e, type: STRING, loc: e.loc };
         }
     }
@@ -797,8 +907,8 @@ export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
         loc: locOf(expr.left),
     };
     const rhs = lowerer.lowerExpr(expr.right);
-    const numericRead = lowerOptionalNumber(lowerer, read, loc);
-    const numericRhs = lowerOptionalNumber(lowerer, rhs, loc);
+    const numericRead = lowerOperatorNumber(lowerer, read, loc);
+    const numericRhs = lowerOperatorNumber(lowerer, rhs, loc);
     if (compound === "+" &&
         (target.type.kind === "string" ||
             (target.type.kind === "union" &&
@@ -914,6 +1024,9 @@ export function lowerBinary(lowerer, expr) {
             const prototypeWrite = lowerClassPrototypeComputedAssignment(lowerer, expr);
             if (prototypeWrite)
                 return prototypeWrite;
+            const staticPrivateWrite = lowerStaticPrivateAssignment(lowerer, expr);
+            if (staticPrivateWrite)
+                return staticPrivateWrite;
             const callableWrite = lowerNativeFunctionAssignment(lowerer, expr);
             if (callableWrite)
                 return callableWrite;
@@ -1225,6 +1338,13 @@ export function lowerBinary(lowerer, expr) {
             ? "assignment to non-variables as an expression (only `x = e` over a variable yields a value; write property/destructuring assignments as statements)"
             : "compound assignment as an expression (write `x op= e` as a statement, or spell out `x = x op e`)");
     }
+    // An identity comparison with process.env or a value held from it
+    // compares the one environment object, which no snapshot can stand for.
+    {
+        const identity = lowerEnvironmentIdentity(lowerer, expr, loc);
+        if (identity)
+            return identity;
+    }
     if (op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsToken) {
         const nullTest = lowerLooseNullCompare(lowerer, expr, loc);
         if (nullTest)
@@ -1396,9 +1516,11 @@ export function lowerBinary(lowerer, expr) {
                     const shape = type.kind === "record" ? lowerer.shapes.get(type.shapeId) : undefined;
                     return !!shape && (shape.fields.length > 0 || shape.indexValue !== undefined);
                 };
+                // A builtin function boxes as its checked twin, the value its
+                // module handle answers, so the two compare equal.
                 const boxed = {
                     kind: "dynFrom",
-                    value: scalarSide,
+                    value: lowerer.checkedBuiltinValue(scalarSide),
                     type: DYN,
                     loc: scalarSide.loc,
                     ...(reference.kind === "record" ||
@@ -1408,6 +1530,8 @@ export function lowerBinary(lowerer, expr) {
                         ? { liveRef: true }
                         : {}),
                 };
+                if (reference.kind === "func")
+                    noteDynamicIdentityComparison(lowerer, expr, expr.left, expr.right);
                 return {
                     kind: "dynScalarEq",
                     left: scalarSide === left ? boxed : left,
@@ -1417,12 +1541,15 @@ export function lowerBinary(lowerer, expr) {
                     loc,
                 };
             }
-            // EventEmitter or a stream class against an untyped value in
-            // JavaScript: the untyped value can hold the class's untyped
-            // constructor (coerceToExpected), which compares by identity.
+            // EventEmitter, a stream class or a node:path family against an
+            // untyped value in JavaScript: the untyped value can hold the class's
+            // untyped constructor or the module object (coerceToExpected), which
+            // compare by identity.
             if (dynSide.type.kind === "dyn" &&
                 isJsSourceFile(expr.getSourceFile()) &&
-                ((scalarSide.type.kind === "moduleNs" && scalarSide.type.moduleId === "builtin:events") ||
+                ((scalarSide.type.kind === "moduleNs" &&
+                    (scalarSide.type.moduleId === "builtin:events" ||
+                        scalarSide.type.moduleId.startsWith("builtin:path"))) ||
                     (scalarSide.kind === "classRef" && builtinClassKind(scalarSide.className) !== null))) {
                 const boxed = lowerer.coerceToExpected(scalarSide, DYN);
                 return {
@@ -1456,6 +1583,12 @@ export function lowerBinary(lowerer, expr) {
                     // strict equality — scalars by value, units by kind,
                     // reference kinds by identity (scr_dyn_strict_eq).
                     scalarSide.type.kind === "dyn")) {
+                // A generic declaration read through `unknown` compares as the
+                // function object it names, which is one object in JavaScript but
+                // one closed instance per signature here: the whole-program check
+                // refuses it when the program holds the declaration at more than
+                // one signature.
+                noteDynamicIdentityComparison(lowerer, expr, expr.left, expr.right);
                 return {
                     kind: "dynScalarEq",
                     left,
@@ -1709,7 +1842,7 @@ export function lowerBinary(lowerer, expr) {
             arms.some((arm) => arm.kind === "string") &&
             arms.some((arm) => arm.kind === "undefinedT"));
     };
-    const arithmeticNumber = (operand, node) => lowerOptionalNumber(lowerer, operand, loc, node);
+    const arithmeticNumber = (operand, node) => lowerOperatorNumber(lowerer, operand, loc, node);
     const arithmeticLeft = strictEquality ? left : arithmeticNumber(left, expr.left);
     const arithmeticRight = strictEquality ? right : arithmeticNumber(right, expr.right);
     const bothNum = arithmeticLeft.type.kind === "f64" && arithmeticRight.type.kind === "f64";
@@ -2275,6 +2408,32 @@ export function lowerStrictEquality(lowerer, node, leftNode, rightNode, left, ri
     // assignable to the other — a tuple-typed listeners() element
     // against a prefix-declared handler): the pointer answers it.
     if (idLeft.type.kind === "func" && idRight.type.kind === "func") {
+        // Two VALUE INSTANCES of one generic declaration are the SAME function
+        // object in JavaScript — the erased closure every unpinned value reads
+        // and each pinned signature's compiled closure are separate functions
+        // here, so the pointer would answer false against Node's true. The
+        // operands' declarations decide it, not their compiled instances.
+        const leftDecl = genericDeclarationBehindValue(lowerer, leftNode, true);
+        if (leftDecl !== null && leftDecl === genericDeclarationBehindValue(lowerer, rightNode, true)) {
+            // JavaScript evaluates both operands, left first, before it compares
+            // them — and a read of a binding still in its temporal dead zone
+            // throws there. The declaration decides the answer, but the reads
+            // keep their place, in that order.
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    { kind: "exprStmt", expr: idLeft, loc },
+                    { kind: "exprStmt", expr: idRight, loc },
+                ],
+                result: boolLit(!negated, loc),
+                type: BOOL,
+                loc,
+            };
+        }
+        // Two pins of ONE generic declaration at different signatures are
+        // different compiled closures; the whole-program check refuses the
+        // compare (checkGenericIdentityPins).
+        notePinnedIdentityComparison(lowerer, node, leftNode, rightNode, idLeft.kind === "closure" ? idLeft.fnName : undefined, idRight.kind === "closure" ? idRight.fnName : undefined);
         return {
             kind: "bin",
             op: negated ? "!==" : "===",
@@ -2299,6 +2458,8 @@ export function lowerStrictEquality(lowerer, node, leftNode, rightNode, left, ri
         };
     }
     if (idLeft.type.kind === "moduleNs" && idRight.type.kind === "moduleNs") {
+        if (idLeft.kind === "moduleNsRef" && idRight.kind === "moduleNsRef")
+            return boolLit(sameNamespace(lowerer, idLeft.moduleId, idRight.moduleId) !== negated, loc);
         return {
             kind: "bin",
             op: negated ? "!==" : "===",
@@ -2349,6 +2510,11 @@ export function lowerStrictEquality(lowerer, node, leftNode, rightNode, left, ri
         };
     }
     if (lowerer.dynConvertible(idLeft.type) && lowerer.dynConvertible(idRight.type)) {
+        // A generic declaration read through `unknown` compares as the function
+        // object it names, which is one object in JavaScript but one closed
+        // instance per signature here: the whole-program check refuses it when
+        // the program holds the declaration at more than one signature.
+        noteDynamicIdentityComparison(lowerer, node, leftNode, rightNode);
         return {
             kind: "dynScalarEq",
             left: lowerer.coerceToExpected(idLeft, DYN),
@@ -2646,6 +2812,42 @@ function lowerLogicalPair(lowerer, expr, left) {
                 loc,
             };
         }
+        // `u || d` whose checker result is one of u's own arms while u keeps
+        // arms flow narrowing ruled out (`typeof o === "string" ? ... : o ||
+        // {}` leaves the string arm in the stored union). Test u in its own
+        // union and extract the result arm through the checked narrowing: a
+        // value of a ruled-out arm traps rather than masquerading as the
+        // result type.
+        if (op === ts.SyntaxKind.BarBarToken && left.type.kind === "union") {
+            const def = lowerer.unions.get(left.type.unionId);
+            if (target !== null &&
+                def !== undefined &&
+                def.arms.some(isUnitType) &&
+                lowerer.armTag(left.type.unionId, target) >= 0) {
+                const helper = lowerer.narrowedArmHelper(left.type.unionId, target, loc);
+                if (helper) {
+                    lowerer.requireTruthyUnion(left.type.unionId, expr);
+                    const stmts = [];
+                    let stable = left;
+                    if (!isSafeToRepeat(left)) {
+                        const local = lowerer.declareHiddenLocal("%or", left.type);
+                        stmts.push({ kind: "varDecl", localId: local.id, init: left, loc });
+                        stable = varRef(local.id, left.type, loc);
+                    }
+                    const result = {
+                        kind: "ternary",
+                        cond: lowerer.ensureBool(stable, expr.left),
+                        then: { kind: "call", callee: helper, args: [stable], type: target, loc },
+                        else_: lowerer.lowerExprExpecting(expr.right, target),
+                        type: target,
+                        loc,
+                    };
+                    return stmts.length === 0
+                        ? result
+                        : { kind: "seqExpr", stmts, result, type: target, loc };
+                }
+            }
+        }
         lowerer.unsupported("SC1090", expr, `logical operators on union-typed values outside conditions (${NARROW_FIRST})`);
     }
     const kind = left.type.kind;