@scriptc/compiler 0.0.33 → 0.0.35

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

@@ -1823,7 +1823,7 @@ export function lowerTernary(L, expr, expected) {
             const argIdent = c.arguments[0];
             const sym = L.resolveValueSymbol(argIdent);
             const t = L.checker.getTypeAtLocation(argIdent);
-            const constituents = t.isUnionType() ? t.getTypes() : [];
+            const constituents = t.isUnionType() ? ts.constituentTypes(t) : [];
             const nonArray = constituents.filter((a) => !L.checker.isArrayType(a) && !L.checker.isTupleType(a));
             const mapped = L.mapTypeOf(t);
             const armCount = mapped?.kind === "union" ? L.arrayValueTags(mapped.unionId).length : 0;
@@ -2453,6 +2453,8 @@ export function droppableStatic(e) {
             return e.elems.every(droppableStatic);
         case "recordLit":
             return e.fields.every((f) => droppableStatic(f.value));
+        case "recordClone":
+            return droppableStatic(e.source) && e.overrides.every((f) => droppableStatic(f.value));
         case "closure":
             return true;
         default:
@@ -3753,7 +3755,7 @@ export function lowerArrayLiteral(L, expr, expected) {
  * for effect and are not stored. Null for every other target. */
 function settledDropNames(L, tsType) {
     let names = null;
-    const parts = tsType.isUnionType() ? tsType.getTypes() : [tsType];
+    const parts = tsType.isUnionType() ? ts.constituentTypes(tsType) : [tsType];
     for (const part of parts) {
         const sym = part.getSymbol();
         if (!sym ||
@@ -3830,7 +3832,7 @@ function literalKeySpellingOf(t) {
         return String(t.value);
     if (t.isUnionType()) {
         let out = null;
-        for (const arm of t.getTypes()) {
+        for (const arm of ts.constituentTypes(t)) {
             const s = arm.isStringLiteralType() ? arm.value : arm.isNumberLiteralType() ? String(arm.value) : null;
             if (s === null || (out !== null && s !== out))
                 return null;
@@ -4181,7 +4183,7 @@ function literalUnionArmOf(L, expr, tsType, recordArms) {
      * equal or width-liftable. */
     const fits = (litT, ftT) => {
         if (ftT.isUnionType())
-            return ftT.getTypes().some((a) => fits(litT, a));
+            return ts.constituentTypes(ftT).some((a) => fits(litT, a));
         if (ftT.isStringLiteralType())
             return litT.isStringLiteralType() && litT.value === ftT.value;
         if (ftT.isNumberLiteralType())
@@ -4203,7 +4205,7 @@ function literalUnionArmOf(L, expr, tsType, recordArms) {
     };
     const armShapeIds = new Set(recordArms.map((a) => a.shapeId));
     const candidates = new Set();
-    for (const member of tsType.getTypes()) {
+    for (const member of ts.constituentTypes(tsType)) {
         const mMapped = L.mapTypeOf(member);
         if (mMapped?.kind !== "record" || !armShapeIds.has(mMapped.shapeId) || candidates.has(mMapped.shapeId))
             continue;
@@ -4348,7 +4350,7 @@ export function lowerObjectLiteral(L, expr) {
     // slot's field types (`lanIp: string | null`), which the literal's own
     // type narrows away (a field written as `lanIp: null` types as bare
     // `null`, which maps to nothing on its own).
-    if (tsType.isUnionType() && tsType.getTypes().some((t) => t.getSymbol()?.name === "PromiseLike")) {
+    if (tsType.isUnionType() && ts.constituentTypes(tsType).some((t) => t.getSymbol()?.name === "PromiseLike")) {
         tsType = L.checker.getAwaitedType(tsType) ?? tsType;
     }
     let mapped = L.mapTypeOf(tsType);
@@ -4378,7 +4380,7 @@ export function lowerObjectLiteral(L, expr) {
         if (ctxShape && !ctxShape.indexValue && !ctxShape.tuple) {
             const names = new Set(ctxShape.fields.map((f) => f.name));
             const ctxHasProp = (name) => {
-                const members = tsType.isUnionType() ? tsType.getTypes() : [tsType];
+                const members = tsType.isUnionType() ? ts.constituentTypes(tsType) : [tsType];
                 return members.some((m) => L.checker.getPropertyOfType(m, name) !== undefined);
             };
             const extraOf = (text) => !names.has(text) && !ctxHasProp(text);
@@ -4527,6 +4529,66 @@ export function lowerObjectLiteral(L, expr) {
         }
     }
     const fieldTypes = new Map(shape.fields.map((f) => [f.name, f.type]));
+    // The clone probe may lower the leading spread before declining (a
+    // static `as` cast can make the checker-visible shape match while its
+    // erased IR value keeps a wider shape). Reuse that exact value in the
+    // ordinary spread path so lowering still happens once.
+    let leadingSpreadLowered = null;
+    // The overwhelmingly common immutable-update form over a record:
+    // `{ ...model, changed, other: value }`. The historic lowering expanded
+    // the spread into one recordGet per untouched field at EVERY site, then
+    // the backends inlined all of those retains and stores into the caller.
+    // A 178-field model updated hundreds of times consequently produced a
+    // half-million-line LLVM function. Keep the same evaluation/ownership
+    // semantics in one compact IR node: source first, explicit overrides in
+    // source order, and one backend clone helper per shape.
+    //
+    // Stay deliberately narrow. Tuple/index/accessor shapes, conditional or
+    // multiple spreads, spread-after-explicit order, and shape-changing width
+    // copies retain their existing lowering and diagnostics.
+    if (!isJsSourceFile(expr.getSourceFile()) &&
+        !shape.indexValue &&
+        !shape.tuple &&
+        !shapeHasAccessorSlots(shape) &&
+        expr.properties.length >= 2 &&
+        ts.isSpreadAssignment(expr.properties[0]) &&
+        !conditionalSpreadOf(expr.properties[0].expression) &&
+        expr.properties.slice(1).every((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+            p.name !== undefined &&
+            (ts.isIdentifier(p.name) ||
+                ts.isStringLiteral(p.name) ||
+                ts.isNumericLiteral(p.name) ||
+                (ts.isComputedPropertyName(p.name) && literalComputedKey(L, p.name) !== null)))) {
+        const spread = expr.properties[0];
+        const props = expr.properties.slice(1);
+        const names = props.map((p) => propNameText(L, p.name));
+        const unique = new Set(names);
+        const sourceType = L.mapTypeOf(L.typeOf(spread.expression));
+        if (sourceType?.kind === "record" &&
+            sourceType.shapeId === type.shapeId &&
+            unique.size === names.length &&
+            names.every((name) => fieldTypes.has(name))) {
+            const source = L.lowerExpr(spread.expression);
+            if (source.type.kind === "record" && source.type.shapeId === type.shapeId) {
+                const overrides = [];
+                for (let i = 0; i < props.length; i++) {
+                    const p = props[i];
+                    const name = names[i];
+                    const fieldType = fieldTypes.get(name);
+                    const valueNode = ts.isPropertyAssignment(p) ? p.initializer : p;
+                    let value = ts.isPropertyAssignment(p)
+                        ? L.lowerExpr(p.initializer)
+                        : L.lowerShorthandValue(p);
+                    value = L.coerceInto(valueNode, value, fieldType);
+                    if (!typeEquals(value.type, fieldType))
+                        L.badType(valueNode, L.typeOf(valueNode));
+                    overrides.push({ name, value });
+                }
+                return { kind: "recordClone", source, overrides, type, loc };
+            }
+            leadingSpreadLowered = source;
+        }
+    }
     // A PURE index-signature target with spreads — `{ ...process.env }`,
     // `{ ...process.env, ...extraEnv }`, `{ ...env, PATH: p }` (the
     // spawn-env pattern): the field-by-field desugar below cannot
@@ -4743,7 +4805,11 @@ export function lowerObjectLiteral(L, expr) {
             let srcNode = prop.expression;
             while (ts.isParenthesizedExpression(srcNode))
                 srcNode = srcNode.expression;
-            const srcLowered = ts.isIdentifier(srcNode) ? null : L.lowerExpr(srcNode);
+            const srcLowered = prop === expr.properties[0] && leadingSpreadLowered !== null
+                ? leadingSpreadLowered
+                : ts.isIdentifier(srcNode)
+                    ? null
+                    : L.lowerExpr(srcNode);
             const srcType = srcLowered ? srcLowered.type : L.mapTypeOf(L.typeOf(srcNode));
             // `...options.installConfig` — a spread of `Partial<X> | undefined`
             // (the optional-options merge idiom `{ ...DEFAULTS, ...overrides }`):
@@ -5889,7 +5955,12 @@ export function lowerRecordKeyRead(L, expr, shapeId, shape, includeUndefined = f
         if (dk.type.kind !== "string") {
             L.unsupported("SC1090", keyNode, "indexing records with non-string or non-number keys");
         }
-        return L.maybeNarrow({ kind: "dynKeyGet", key: dk, value: obj, type: DYN, loc }, expr);
+        const read = { kind: "dynKeyGet", key: dk, value: obj, type: DYN, loc };
+        // Absence probes must keep the checked-dynamic undefined produced by
+        // a missing key. The ordinary read narrows to the checker's declared
+        // index value (and therefore validates it); ===/!==, ||, and ?? need
+        // to observe the missing value instead of throwing during that check.
+        return includeUndefined ? read : L.maybeNarrow(read, expr);
     }
     if (litKey !== null) {
         const field = shape.fields.find((f) => f.name === litKey);
@@ -5970,6 +6041,13 @@ export function lowerAbsenceProbe(L, node) {
         const target = L.fieldTarget(expr);
         if (target?.container !== "recordOvf")
             return null;
+        // A JS file-scope object-literal global is record-shaped to the
+        // checker but stored in the checked-dynamic tree to preserve object
+        // identity. Reuse the normal dyn-aware field read; constructing a
+        // recordKeyGet here would give the validator a dyn receiver.
+        if (target.obj.type.kind === "dyn") {
+            return L.fieldGetExpr(target, locOf(expr), expr);
+        }
         if (target.fieldType.kind === "union" &&
             L.armTag(target.fieldType.unionId, UNDEFINED_T) >= 0) {
             return null;
@@ -7561,7 +7639,7 @@ function errorRootedObjectOf(L, t) {
     if (rooted(direct))
         return direct;
     if (t.isIntersectionType()) {
-        for (const part of t.getTypes()) {
+        for (const part of ts.constituentTypes(t)) {
             const m = L.mapTypeOf(part);
             if (rooted(m))
                 return m;
@@ -7816,7 +7894,7 @@ function aliasTypeofArmOf(L, e, strip) {
         const arm = def.arms[tags[0]];
         // The checker-side arm: the union part whose (widened) mapping IS
         // the proven IR arm — what typeOf answers inside the branch.
-        const parts = valT.isUnionType() ? valT.getTypes() : [valT];
+        const parts = valT.isUnionType() ? ts.constituentTypes(valT) : [valT];
         const tsArm = parts.find((p) => {
             const m = L.mapTypeOf(L.checker.getBaseTypeOfLiteralType(p));
             return m !== null && typeEquals(m, arm);