@scriptc/compiler 0.4.6 → 0.4.7

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

@@ -1,4 +1,5 @@
 /* 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";
@@ -6,7 +7,7 @@ import { cleanFuncAdaptable } from "../coercions/function-adapters.js";
 import { jsFuncNameOf } from "../lowerer.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";
@@ -18,10 +19,11 @@ 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 { noteDynamicIdentityComparison } 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 +34,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
@@ -360,6 +364,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
@@ -508,7 +528,9 @@ 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)) {
+    if (staticClass &&
+        hasRuntimeStatics(staticClass) &&
+        !(ts.isPropertyAccessExpression(target) && ts.isPrivateIdentifier(target.name))) {
         return lowerDynMemberAssignment(lowerer, expr, lowerer.lowerExprExpecting(target.expression, DYN));
     }
     // Other class statics and prototype tables have their own paths.
@@ -551,6 +573,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")
@@ -797,8 +823,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 +940,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 +1254,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 +1432,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 +1446,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 +1457,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 +1499,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 +1758,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";
@@ -2299,6 +2348,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 +2400,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 +2702,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;