@scriptc/compiler 0.4.1 → 0.4.3

package/dist/frontend/lowering/expressions/object-literals.js

@@ -1,3 +1,4 @@
+import { keyedHelperName } from "../stable-names.js";
 import { dateJsonType, isDateJsonSource } from "../builtins/dates.js";
 import { dynUndefinedExpr, numLit, strLit, varRef } from "../../../ir/build.js";
 import { pathModuleValue } from "../lower-builtin-values.js";
@@ -15,6 +16,8 @@ import { tryLowerExpression } from "./try-lower-expression.js";
 import { fenceSymbolFieldCopy } from "../symbol-fields.js";
 import { planUnionRetag } from "../union-retag.js";
 import { jsHoldsDynObject, runtimeOptionalStorageOperand } from "../lower-exprs.js";
+import { builtinGlobalValue } from "./property-access.js";
+import { holdsEvolvingArray } from "../lower-stmts.js";
 /** `{ a: 1, b: "x" }` → recordLit. The record type comes from the
  * contextual type when tsc has one (annotated declarations, arguments,
  * nested literals) and from the literal's own type otherwise — both intern
@@ -359,9 +362,14 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         try {
             const lowerValue = () => ts.isMethodDeclaration(prop)
                 ? lowerer.lowerLambda(prop, true)
-                : !boxValue && ts.isObjectLiteralExpression(valueExpr)
-                    ? lowerer.lowerExprExpecting(valueExpr, DYN)
-                    : lowerer.lowerExpr(valueExpr);
+                : ts.isShorthandPropertyAssignment(prop) && shorthandBuiltinValue(lowerer, prop)
+                    ? shorthandBuiltinValue(lowerer, prop)
+                    : !boxValue &&
+                        (ts.isObjectLiteralExpression(valueExpr) ||
+                            (ts.isArrayLiteralExpression(valueExpr) &&
+                                holdsEvolvingArray(lowerer, valueExpr)))
+                        ? lowerer.lowerExprExpecting(valueExpr, DYN)
+                        : lowerer.lowerExpr(valueExpr);
             raw = fenceClosureProbe(lowerer, valueExpr, undefined, lowerValue) ?? lowerValue();
         }
         catch (err) {
@@ -374,7 +382,7 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
                 throw err;
             const fence = lowerer.deferToRuntimeFence(propDiagsBefore, prop, {
                 kind: "closure",
-                name: () => `%fn${lowerer.lambdaCounter++}_dynfence`,
+                name: () => lowerer.closureName(loc, "_dynfence"),
                 returnType: VOID,
                 type: { kind: "func", params: [], ret: VOID },
             });
@@ -425,7 +433,7 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
                     throw err;
                 const fence = lowerer.deferToRuntimeFence(convDiagsBefore, prop, {
                     kind: "closure",
-                    name: () => `%fn${lowerer.lambdaCounter++}_dynfence`,
+                    name: () => lowerer.closureName(loc, "_dynfence"),
                     returnType: VOID,
                     type: { kind: "func", params: [], ret: VOID },
                 });
@@ -737,13 +745,27 @@ function lowerOptionalIndexSpreadSource(lowerer, source, loc) {
         : { kind: "seqExpr", stmts: prefix, result: selected, type: recordType, loc };
 }
 export function lowerObjectLiteral(lowerer, expr, expected) {
+    // A spread of an untyped (`any`) source into a typed slot: TypeScript
+    // types such a literal `any`, and the copy holds whatever own properties
+    // the source has at runtime. Build it as a checked-dynamic object, then
+    // check it into the expected record like any other `any` value assigned
+    // to that slot.
+    if (expected &&
+        !isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        expr.properties.nodes.some((prop) => ts.isSpreadAssignment(prop) &&
+            (lowerer.typeOf(prop.expression).flags & ts.TypeFlags.Any) !== 0)) {
+        return lowerer.coerceToExpected(lowerDynObjectLiteral(lowerer, expr), expected);
+    }
     // Unannotated JavaScript accumulator fields have no element contract.
     // Preserve their checked arrays instead of assigning never[] a numeric ABI.
+    // An empty object field is a map the program adds keys to.
     if (!expected &&
         isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
         expr.properties.nodes.some((prop) => ts.isPropertyAssignment(prop) &&
             ((ts.isArrayLiteralExpression(prop.initializer) &&
                 prop.initializer.elements.nodes.length === 0) ||
+                (ts.isObjectLiteralExpression(prop.initializer) &&
+                    prop.initializer.properties.nodes.length === 0) ||
                 neverTaintedJsType(lowerer, prop.initializer, lowerer.typeOf(prop.initializer))))) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
@@ -843,8 +865,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             // spread's own position (any position: they introduce one fresh
             // name, collision-fenced below). Everything else stays fenced.
             const cs = conditionalSpreadOf(prop.expression) ?? andSpreadOf(lowerer, prop.expression);
-            if (cs === "unsupported" || (cs && cs.props.length !== 1)) {
-                lowerer.unsupported("SC1090", prop, "conditional spreads beyond `...(c ? { field: v } : {})` (exactly one property against an empty arm — spell other shapes as optional fields)");
+            if (cs === "unsupported" && conditionalRecordSpreadOf(lowerer, prop.expression) === null) {
+                lowerer.unsupported("SC1090", prop, "conditional spreads beyond `...(c ? { field: v } : {})` and `...(c ? record : {})` (one arm must be empty — spell other shapes as optional fields)");
             }
             // Spread ORDER is fenced in the field-by-field desugar below, not
             // here: the index-signature merge path supports any order (keyed
@@ -1515,52 +1537,60 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         if (ts.isSpreadAssignment(prop)) {
             const cs = conditionalSpreadOf(prop.expression) ?? andSpreadOf(lowerer, prop.expression);
             if (cs && cs !== "unsupported") {
-                // `...(c ? { k: v } : {})` — ONE conditional field at the
-                // spread's own position: cond evaluates exactly once, `v` only
-                // when the non-empty arm is taken (ternary arms are lazy), and
-                // the empty arm holds the interned undefined arm — exactly the
-                // omitted-optional-field representation, which is also why the
-                // target field must be optional (tsc types the idiom that way).
-                const csProp = cs.props[0]; // single-prop-checked in the fence pass
-                const name = csProp.name.text;
-                const fieldType = fieldTypes.get(name);
-                if (!fieldType) {
-                    if (shape.indexValue) {
-                        lowerer.unsupported("SC1090", prop, "conditional spreads into index-signature keys (overflow entries model presence — write the key in an if statement instead)");
+                // `...(c ? { k: v } : {})` — one conditional field per carried
+                // property at the spread's own position: cond evaluates exactly
+                // once (into a hidden local when several fields test it), each
+                // `v` only when the non-empty arm is taken (ternary arms are
+                // lazy), in property order, and the empty arm holds the interned
+                // undefined arm — exactly the omitted-optional-field
+                // representation, which is also why the target fields must be
+                // optional (tsc types the idiom that way).
+                let cond = null;
+                for (const csProp of cs.props) {
+                    const name = csProp.name.text;
+                    const fieldType = fieldTypes.get(name);
+                    if (!fieldType) {
+                        if (shape.indexValue) {
+                            lowerer.unsupported("SC1090", prop, "conditional spreads into index-signature keys (overflow entries model presence — write the key in an if statement instead)");
+                        }
+                        shapeMismatch(prop);
                     }
-                    shapeMismatch(prop);
-                }
-                // An 'unknown' slot holds the checked-dynamic undefined for the
-                // empty arm, the absent-property read the width copy uses too.
-                const absent = lowerer.absentFieldValue(fieldType, locOf(prop)) ??
-                    (fieldType.kind === "dyn" ? dynUndefinedExpr(locOf(prop)) : null);
-                if (!absent) {
-                    lowerer.unsupported("SC1090", prop, `conditional spreads onto the required field '${name}' (the empty arm leaves it undefined — declare the field optional)`);
-                }
-                if (fields.some((f) => f.name === name)) {
-                    lowerer.unsupported("SC1090", prop, `conditional spread of '${name}' over an earlier '${name}' (the desugar keeps one entry per name — restructure so each name has one contributor)`);
+                    // An 'unknown' slot holds the checked-dynamic undefined for the
+                    // empty arm, the absent-property read the width copy uses too.
+                    const absent = lowerer.absentFieldValue(fieldType, locOf(prop)) ??
+                        (fieldType.kind === "dyn" ? dynUndefinedExpr(locOf(prop)) : null);
+                    if (!absent) {
+                        lowerer.unsupported("SC1090", prop, `conditional spreads onto the required field '${name}' (the empty arm leaves it undefined — declare the field optional)`);
+                    }
+                    if (fields.some((f) => f.name === name)) {
+                        lowerer.unsupported("SC1090", prop, `conditional spread of '${name}' over an earlier '${name}' (the desugar keeps one entry per name — restructure so each name has one contributor)`);
+                    }
+                    if (cond === null) {
+                        cond = lowerer.lowerCondition(cs.cond);
+                        if (cs.props.length > 1)
+                            cond = capture(cond);
+                    }
+                    const valueNode = ts.isPropertyAssignment(csProp) ? csProp.initializer : csProp;
+                    let v = ts.isPropertyAssignment(csProp)
+                        ? lowerer.lowerExpr(csProp.initializer)
+                        : lowerer.lowerShorthandValue(csProp);
+                    v = lowerer.coerceInto(valueNode, v, fieldType);
+                    if (!typeEquals(v.type, fieldType))
+                        lowerer.badType(valueNode, lowerer.typeOf(valueNode));
+                    conditionalNames.add(name);
+                    orderSegments.push({ kind: "key", name, definite: false });
+                    fields.push({
+                        name,
+                        value: {
+                            kind: "ternary",
+                            cond,
+                            then: cs.whenTrue ? v : absent,
+                            else_: cs.whenTrue ? absent : v,
+                            type: fieldType,
+                            loc: locOf(prop),
+                        },
+                    });
                 }
-                const cond = lowerer.lowerCondition(cs.cond);
-                const valueNode = ts.isPropertyAssignment(csProp) ? csProp.initializer : csProp;
-                let v = ts.isPropertyAssignment(csProp)
-                    ? lowerer.lowerExpr(csProp.initializer)
-                    : lowerer.lowerShorthandValue(csProp);
-                v = lowerer.coerceInto(valueNode, v, fieldType);
-                if (!typeEquals(v.type, fieldType))
-                    lowerer.badType(valueNode, lowerer.typeOf(valueNode));
-                conditionalNames.add(name);
-                orderSegments.push({ kind: "key", name, definite: false });
-                fields.push({
-                    name,
-                    value: {
-                        kind: "ternary",
-                        cond,
-                        then: cs.whenTrue ? v : absent,
-                        else_: cs.whenTrue ? absent : v,
-                        type: fieldType,
-                        loc: locOf(prop),
-                    },
-                });
                 continue;
             }
             // `{ ...base, ... }` — field-by-field copy of a known record
@@ -1573,9 +1603,12 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             let srcNode = prop.expression;
             while (ts.isParenthesizedExpression(srcNode))
                 srcNode = srcNode.expression;
-            const srcLowered = capture(prop === expr.properties.nodes[0] && leadingSpreadLowered !== null
-                ? leadingSpreadLowered
-                : lowerer.lowerExpr(srcNode));
+            const condRecord = conditionalRecordSpreadOf(lowerer, prop.expression);
+            const srcLowered = capture(condRecord !== null
+                ? lowerConditionalRecordSpread(lowerer, condRecord, locOf(prop))
+                : prop === expr.properties.nodes[0] && leadingSpreadLowered !== null
+                    ? leadingSpreadLowered
+                    : lowerer.lowerExpr(srcNode));
             // Array callbacks can receive a record-or-undefined ABI even when
             // TypeScript describes a required record. Select the copy strategy
             // from that stored representation so absent sources copy nothing.
@@ -1841,7 +1874,12 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             // A checked-dynamic source's keys are a run-time fact.
             orderSegments.push(srcLowered.type.kind === "dyn"
                 ? { kind: "opaque" }
-                : { kind: "spread", shapeId: srcType.shapeId, maybeAbsent: false });
+                : {
+                    kind: "spread",
+                    shapeId: srcType.shapeId,
+                    maybeAbsent: false,
+                    ...(srcLowered.kind === "varRef" ? { value: srcLowered } : {}),
+                });
             for (const f of srcShape.fields) {
                 if (laterNames.has(f.name))
                     continue;
@@ -2395,6 +2433,58 @@ function syntacticAndSpread(right, cond) {
     }
     return { cond, props, whenTrue: true };
 }
+/** `...(c ? source : {})` (either arm order; the empty arm may also be
+ * `undefined` or `null`) where `source` maps to a record and is not the
+ * literal the field desugar handles (conditionalSpreadOf). The spread
+ * copies the source's fields when the source arm is taken and nothing
+ * otherwise, which is the copy of a `Record | undefined` spread source. */
+export function conditionalRecordSpreadOf(lowerer, expr) {
+    let e = expr;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    if (!ts.isConditionalExpression(e))
+        return null;
+    const unwrap = (a) => {
+        let x = a;
+        while (ts.isParenthesizedExpression(x))
+            x = x.expression;
+        return x;
+    };
+    const isEmpty = (x) => (ts.isObjectLiteralExpression(x) && x.properties.nodes.length === 0) ||
+        x.kind === ts.SyntaxKind.NullKeyword ||
+        (ts.isIdentifier(x) &&
+            x.text === "undefined" &&
+            (lowerer.typeOf(x).flags & ts.TypeFlags.Undefined) !== 0);
+    const whenTrue = unwrap(e.whenTrue);
+    const whenFalse = unwrap(e.whenFalse);
+    const sourceIsTrue = isEmpty(whenFalse) && !isEmpty(whenTrue);
+    if (!sourceIsTrue && !(isEmpty(whenTrue) && !isEmpty(whenFalse)))
+        return null;
+    const source = sourceIsTrue ? whenTrue : whenFalse;
+    if (lowerer.mapTypeOf(lowerer.typeOf(source))?.kind !== "record")
+        return null;
+    return { cond: e.condition, source, whenTrue: sourceIsTrue };
+}
+/** The spread source of a conditionalRecordSpreadOf match: `c ? source :
+ * undefined` as a `Record | undefined` value (cond first, the source only
+ * when its arm is taken). */
+function lowerConditionalRecordSpread(lowerer, spread, loc) {
+    const cond = lowerer.lowerCondition(spread.cond);
+    const source = lowerer.lowerExpr(spread.source);
+    if (source.type.kind !== "record")
+        lowerer.badType(spread.source, lowerer.typeOf(spread.source));
+    const type = lowerer.withUndefinedArm(source.type);
+    const present = lowerer.coerceToExpected(source, type);
+    const absent = lowerer.wrappedUndefined(type, loc);
+    return {
+        kind: "ternary",
+        cond,
+        then: spread.whenTrue ? present : absent,
+        else_: spread.whenTrue ? absent : present,
+        type,
+        loc,
+    };
+}
 export function conditionalSpreadOf(expr) {
     let e = expr;
     while (ts.isParenthesizedExpression(e))
@@ -2593,7 +2683,7 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
         const key = `declmerge-source:${type.shapeId}:${source.shapeId}`;
         let helper = lowerer.valueHelpers.get(key);
         if (!helper) {
-            helper = `%rec.declmerge.${lowerer.valueHelpers.size}`;
+            helper = keyedHelperName(lowerer, "%rec.declmerge", key);
             const sourceType = source.value.type;
             const destination = varRef("out.0", type, loc);
             const receiver = varRef("source.0", sourceType, loc);
@@ -2780,6 +2870,17 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
 /** The value of a shorthand property (`{ x }`): the binding `x` refers to.
  * The property name's own symbol is the PROPERTY, so resolution goes
  * through getShorthandAssignmentValueSymbol. */
+/** `{ TypeError }`: a stdlib global in shorthand position reads as the value
+ * its name reads as elsewhere (the interned constructor or function value),
+ * or null when the global has no such value. The shorthand's name carries
+ * the property's symbol, so the identifier path cannot resolve it. */
+function shorthandBuiltinValue(lowerer, prop) {
+    const symbol = lowerer.checker.getShorthandAssignmentValueSymbol(prop);
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
+        return null;
+    const js = isJsSourceFile(ts.getSourceFileOfNode(prop));
+    return builtinGlobalValue(ts.symbolName(symbol), locOf(prop.name), js);
+}
 export function lowerShorthandValue(lowerer, prop) {
     // 7 types the shorthand's name as PropertyName; it is always an
     // Identifier (the grammar allows nothing else in shorthand position).
@@ -2794,6 +2895,9 @@ export function lowerShorthandValue(lowerer, prop) {
         if (callable)
             return callable;
     }
+    const builtinValue = shorthandBuiltinValue(lowerer, prop);
+    if (builtinValue)
+        return builtinValue;
     if (symbol) {
         if (lowerer.ctx.selfSymbol === symbol) {
             return { kind: "selfRef", type: lowerer.ctx.selfType, loc };
@@ -2857,6 +2961,10 @@ export function lowerShorthandValue(lowerer, prop) {
             }
             return lowerer.classValueRef(classInfo, propName);
         }
+        // A standard-library global (`{ Date }`): the value the long form
+        // `{ Date: Date }` reads.
+        if (lowerer.isStdlibSymbol(resolved))
+            return lowerer.lowerExpr(propName);
     }
     lowerer.rejectUnresolvedSymbol(symbol
         ? symbol.flags & ts.SymbolFlags.Alias