@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -6,7 +6,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, lowerOptionalNumber, lowerPresenceOperand, nullishBranches, operandPairs, operatorUnsupported, runtimeOptionalStorageOperand, symbolFieldInfo, typeofAnswer, } from "../lower-exprs.js";
+import { bigintCompoundValue, compoundUnsupported, concatOperand, constructorGlobalTypeof, deferredSlotOr, dynCompoundValue, lowerAbsenceProbe, lowerDynMemberAssignment, lowerDereferencedElementAssignment, lowerOptionalNumber, 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";
@@ -278,6 +278,48 @@ function isMemberReceiver(node) {
         parent.expression === child) ||
         (ts.isTaggedTemplateExpression(parent) && parent.tag === child));
 }
+/** A literal default (`0`, `-1`, `""`, `true`): it always has its own type.
+ * Other defaults, such as an element read that can be undefined, keep the
+ * dynamic path. */
+function literalDefault(node) {
+    while (ts.isParenthesizedExpression(node))
+        node = node.expression;
+    if (ts.isPrefixUnaryExpression(node) &&
+        (node.operator === ts.SyntaxKind.MinusToken || node.operator === ts.SyntaxKind.PlusToken))
+        node = node.operand;
+    return (ts.isNumericLiteral(node) ||
+        ts.isStringLiteral(node) ||
+        ts.isNoSubstitutionTemplateLiteral(node) ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.FalseKeyword);
+}
+/** A fresh object literal (parentheses allowed) one of whose property
+ * values, at any literal depth, is `new Map()` or `new Set()` of the
+ * standard library with neither arguments nor type arguments. */
+function untypedCollectionFallback(lowerer, node) {
+    let value = node;
+    while (ts.isParenthesizedExpression(value))
+        value = value.expression;
+    if (!ts.isObjectLiteralExpression(value))
+        return false;
+    return value.properties.nodes.some((property) => {
+        if (!ts.isPropertyAssignment(property))
+            return false;
+        let inner = property.initializer;
+        while (ts.isParenthesizedExpression(inner))
+            inner = inner.expression;
+        if (ts.isObjectLiteralExpression(inner))
+            return untypedCollectionFallback(lowerer, inner);
+        if (!ts.isNewExpression(inner) ||
+            !ts.isIdentifier(inner.expression) ||
+            (inner.arguments?.nodes.length ?? 0) !== 0 ||
+            (inner.typeArguments?.nodes.length ?? 0) !== 0)
+            return false;
+        const symbol = lowerer.resolveValueSymbol(inner.expression);
+        const name = symbol ? ts.symbolName(symbol) : "";
+        return symbol !== null && lowerer.isStdlibSymbol(symbol) && (name === "Map" || name === "Set");
+    });
+}
 export function lowerNullishPair(lowerer, expr, loc, left) {
     if (left.type.kind === "dyn") {
         // `a ?? b` on a CHECKED-DYNAMIC left: the deciding test is the
@@ -305,6 +347,19 @@ export function lowerNullishPair(lowerer, expr, loc, left) {
     const fresh = rest.length === 1 ? lowerer.emptyCollectionFor(expr.right, rest[0]) : null;
     if (fresh)
         return { kind: "nullish", left, right: fresh, type: fresh.type, loc };
+    // `optionalRecord ?? { a: 1, items: new Map() }`: a fresh fallback literal
+    // whose untyped empty collections (`new Map()`, `new Set()` without type
+    // arguments, which the checker types `Map<any, any>`) leave the checker's
+    // join as a second record arm. When the literal is assignable to the
+    // left's record, it builds as that record, so the collections take its
+    // element types and the result keeps one layout.
+    if (rest.length === 1 &&
+        rest[0].kind === "record" &&
+        untypedCollectionFallback(lowerer, expr.right) &&
+        lowerer.checker.isTypeAssignableTo(lowerer.typeOf(expr.right), lowerer.checker.getNonNullableType(lowerer.typeOf(expr.left)))) {
+        const right = lowerer.lowerExprExpecting(expr.right, rest[0]);
+        return { kind: "nullish", left, right, type: rest[0], 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
@@ -324,6 +379,24 @@ export function lowerNullishPair(lowerer, expr, loc, left) {
         lowerer.runtimeOptionalArithmeticTypes.set(expr, type);
     }
     if (type.kind === "dyn" && lowerer.dynConvertible(left.type)) {
+        // `counts.get(k) ?? 0` in JavaScript: a scalar optional left and a
+        // default of its value's type give a scalar, so the test and the default
+        // run on the typed path and only the result converts. Converting the
+        // optional left itself would allocate a union for every read.
+        if (rest.length === 1 &&
+            primitive(rest[0]) &&
+            rightType &&
+            typeEquals(rightType, rest[0]) &&
+            literalDefault(expr.right)) {
+            const typed = {
+                kind: "nullish",
+                left,
+                right: lowerer.lowerExprExpecting(expr.right, rest[0]),
+                type: rest[0],
+                loc,
+            };
+            return lowerer.coerceToExpected(typed, DYN);
+        }
         return {
             kind: "nullish",
             left: lowerer.coerceToExpected(left, DYN),
@@ -615,6 +688,12 @@ export function ensureString(lowerer, e, node) {
                 a.kind === "date" ||
                 isUnitType(a)) ??
                 false);
+        // Checked-dynamic elements: the runtime's String() over the array's
+        // dyn form (its join, element by element).
+        if (elem.kind === "dyn") {
+            const boxed = { kind: "dynFrom", value: e, type: DYN, loc: e.loc };
+            return { kind: "toString", operand: boxed, type: STRING, loc: e.loc };
+        }
         if (elem.kind === "f64" ||
             elem.kind === "string" ||
             elem.kind === "bool" ||
@@ -838,6 +917,9 @@ export function lowerBinary(lowerer, expr) {
             const callableWrite = lowerNativeFunctionAssignment(lowerer, expr);
             if (callableWrite)
                 return callableWrite;
+            const dereferenced = lowerDereferencedElementAssignment(lowerer, expr);
+            if (dereferenced)
+                return dereferenced;
         }
         if (op === ts.SyntaxKind.QuestionQuestionEqualsToken ||
             op === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
@@ -1300,6 +1382,9 @@ export function lowerBinary(lowerer, expr) {
                 reference.kind === "map" ||
                 reference.kind === "set" ||
                 reference.kind === "union" ||
+                // A promise of dyn boxes its own promise; other promise types
+                // box an adapter that shares the promise's identity.
+                reference.kind === "promise" ||
                 DYN_HANDLE_KINDS.has(reference.kind)) &&
                 lowerer.dynConvertible(reference)) {
                 // Records, arrays and byte views compare by the capsule identity
@@ -2006,6 +2091,31 @@ export function lowerBinary(lowerer, expr) {
  * equality for every pair of static kinds the program can compare.
  * `node` anchors diagnostics, and `leftNode`/`rightNode` the coercions. */
 export function lowerStrictEquality(lowerer, node, leftNode, rightNode, left, right, negated, loc) {
+    // JavaScript: a checked-dynamic name the checker's flow analysis narrowed
+    // (`let c; ... (c = s[i]) === " "`) is compared unchecked. Strict
+    // equality never throws, and the flow type is the checker's inference
+    // (an indexed read past the end is undefined whatever it says).
+    const flowNarrowed = (n, e) => ts.isIdentifier(n) &&
+        e.kind === "dynCheck" &&
+        e.value.type.kind === "dyn" &&
+        isJsSourceFile(ts.getSourceFileOfNode(n))
+        ? e.value
+        : null;
+    const scalar = (e) => e.type.kind === "string" || e.type.kind === "f64" || e.type.kind === "bool";
+    {
+        const l = flowNarrowed(leftNode, left);
+        const r = flowNarrowed(rightNode, right);
+        if ((l !== null && (scalar(right) || r !== null)) || (r !== null && scalar(left))) {
+            const cmp = {
+                kind: "dynScalarEq",
+                left: l ?? lowerer.coerceInto(leftNode, left, DYN),
+                right: r ?? lowerer.coerceInto(rightNode, right, DYN),
+                type: BOOL,
+                loc,
+            };
+            return negated ? { kind: "unary", op: "!", operand: cmp, type: BOOL, loc } : cmp;
+        }
+    }
     const plainBothNum = left.type.kind === "f64" && right.type.kind === "f64";
     const bothStr = left.type.kind === "string" && right.type.kind === "string";
     const indexed = tryLowerIndexedComparison(lowerer, left, right, negated, loc);
@@ -2073,6 +2183,31 @@ export function lowerStrictEquality(lowerer, node, leftNode, rightNode, left, ri
                 loc,
             };
         }
+        // A promise against a union with a promise arm, or two such unions:
+        // converting a promise into a union's promise arm of another payload
+        // (`chains.get(id) === tail` with a `Map<K, Promise<unknown>>`, or
+        // `a.pending === b.pending` after both were set to one promise) builds a
+        // new promise, so either side may hold a conversion of the other's
+        // promise, and a value narrowed out of the union may be one too.
+        // Promises are objects to ===, so compare both sides as untyped values,
+        // where a converted promise answers with its origin's identity (the plain
+        // promise-vs-promise rule below).
+        const holdsPromise = (type) => type.kind === "promise" ||
+            (type.kind === "union" &&
+                (lowerer.unions.get(type.unionId)?.arms ?? []).some((arm) => arm.kind === "promise"));
+        if (holdsPromise(left.type) &&
+            holdsPromise(right.type) &&
+            lowerer.dynConvertible(left.type) &&
+            lowerer.dynConvertible(right.type)) {
+            return {
+                kind: "dynScalarEq",
+                left: lowerer.coerceToExpected(left, DYN),
+                right: lowerer.coerceToExpected(right, DYN),
+                ...(negated ? { negated: true } : {}),
+                type: BOOL,
+                loc,
+            };
+        }
         if ((sameUnion || !bothUnion) && lowerer.eqComparableUnion(ut.unionId)) {
             aliasRefusal(ut);
             return {