@scriptc/compiler 0.2.5 → 0.2.7

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

@@ -321,9 +321,7 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
             flushFields();
             hasAccessors = true;
             acc ??= { kind: "dynObjLit", fields: [], type: DYN, loc };
-            if (!isJsSourceFile(expr.getSourceFile()))
-                lowerer.rejectThisInObjectMethod(prop.body ?? prop);
-            const fn = lowerer.lowerLambda(prop);
+            const fn = lowerer.lowerLambda(prop, true);
             const descriptor = {
                 kind: "dynObjLit",
                 type: DYN,
@@ -370,9 +368,7 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         const propDiagsBefore = lowerer.diags.length;
         try {
             const lowerValue = () => ts.isMethodDeclaration(prop)
-                ? isJsSourceFile(expr.getSourceFile())
-                    ? lowerer.lowerLambda(prop)
-                    : (lowerer.rejectThisInObjectMethod(prop.body ?? prop), lowerer.lowerLambda(prop))
+                ? lowerer.lowerLambda(prop, true)
                 : !boxValue && ts.isObjectLiteralExpression(valueExpr)
                     ? lowerer.lowerExprExpecting(valueExpr, DYN)
                     : lowerer.lowerExpr(valueExpr);
@@ -1342,6 +1338,68 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         captured.add(ref);
         return ref;
     };
+    // A pending field value may carry the ABSENT state (an omitted
+    // conditional-spread arm, a spread source lacking the key). That state
+    // only lives in a field slot, so a snapshot splits the value into a
+    // captured ordinary value and a pure presence test over captured
+    // conditions, then rebuilds `present ? value : absent` (arms stay lazy:
+    // the captured value keeps the original ternary structure).
+    const canLackField = (t) => t.kind === "union" && lowerer.armTag(t.unionId, UNDEFINED_T) >= 0;
+    const containsAbsent = (value) => value.kind === "fieldAbsent" ||
+        (value.kind === "ternary" && (containsAbsent(value.then) || containsAbsent(value.else_)));
+    const captureField = (value) => {
+        if (captured.has(value))
+            return value;
+        if (!containsAbsent(value))
+            return capture(value);
+        if (value.kind === "fieldAbsent")
+            return value;
+        const split = (v) => {
+            if (v.kind === "fieldAbsent") {
+                return {
+                    value: lowerer.wrappedUndefined(v.type, v.loc),
+                    present: { kind: "boolLit", value: false, type: BOOL, loc: v.loc },
+                };
+            }
+            if (v.kind === "ternary" && containsAbsent(v)) {
+                // Conditions snapshot here too. Nested conditions come from the
+                // spread desugar's own presence tests over captured sources, so
+                // evaluating them eagerly is unobservable.
+                const cond = v.cond.kind === "varRef" || v.cond.kind === "boolLit" ? v.cond : capture(v.cond);
+                const t = split(v.then);
+                const e = split(v.else_);
+                return {
+                    value: { ...v, cond, then: t.value, else_: e.value },
+                    present: {
+                        kind: "ternary",
+                        cond,
+                        then: t.present,
+                        else_: e.present,
+                        type: BOOL,
+                        loc: v.loc,
+                    },
+                };
+            }
+            return { value: v, present: { kind: "boolLit", value: true, type: BOOL, loc: v.loc } };
+        };
+        const parts = split(value);
+        const ref = capture(parts.value);
+        const out = {
+            kind: "ternary",
+            cond: parts.present,
+            then: ref,
+            else_: {
+                kind: "fieldAbsent",
+                unionId: value.type.unionId,
+                type: value.type,
+                loc: value.loc,
+            },
+            type: value.type,
+            loc: value.loc,
+        };
+        captured.add(out);
+        return out;
+    };
     // Field names introduced by conditional spreads: their ternary carries
     // the spread's whole evaluation (cond once, value lazily), so a LATER
     // contributor overriding one would silently drop that evaluation —
@@ -1362,8 +1420,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     fields.splice(i--, 1);
                     continue;
                 }
-                if (!captured.has(field.value))
-                    field.value = capture(field.value);
+                field.value = captureField(field.value);
             }
         }
         if (ts.isSpreadAssignment(prop)) {
@@ -1384,7 +1441,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     }
                     shapeMismatch(prop);
                 }
-                const absent = lowerer.wrappedUndefined(fieldType, locOf(prop));
+                const absent = lowerer.absentFieldValue(fieldType, locOf(prop));
                 if (!absent) {
                     lowerer.unsupported("SC1090", prop, `conditional spreads onto the required field '${name}' (the empty arm leaves it undefined — declare the field optional)`);
                 }
@@ -1473,8 +1530,10 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                             continue;
                         const lt = laterSpreadType(lowerer, later.expression);
                         if (lt?.kind === "record") {
+                            // A field the later source may lack defines nothing.
                             for (const lf of lowerer.shapes.get(lt.shapeId)?.fields ?? [])
-                                laterNames.add(lf.name);
+                                if (!canLackField(lf.type))
+                                    laterNames.add(lf.name);
                         }
                         continue;
                     }
@@ -1524,8 +1583,34 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                         loc: locOf(prop),
                     };
                     let thenVal;
+                    // A source field that can be absent copies only when present.
+                    const fieldPresent = () => ({
+                        kind: "logical",
+                        op: "&&",
+                        left: cond,
+                        right: {
+                            kind: "recordHas",
+                            obj: {
+                                kind: "unionNarrow",
+                                unionId: srcType.unionId,
+                                tag: recTag,
+                                value: srcRef(),
+                                type: recArm,
+                                loc: locOf(prop),
+                            },
+                            shapeId: recArm.shapeId,
+                            field: f.name,
+                            type: BOOL,
+                            loc: locOf(prop),
+                        },
+                        type: BOOL,
+                        loc: locOf(prop),
+                    });
+                    const canBeAbsent = f.type.kind === "union" && lowerer.armTag(f.type.unionId, UNDEFINED_T) >= 0;
                     if (typeEquals(f.type, targetType)) {
                         thenVal = fRead();
+                        if (canBeAbsent)
+                            cond = fieldPresent();
                     }
                     else if (f.type.kind === "union" &&
                         lowerer.armTag(f.type.unionId, UNDEFINED_T) >= 0 &&
@@ -1594,9 +1679,11 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                             throw new PoisonError();
                         }
                         thenVal = lowerer.applyWidthLift(lift, fRead(), targetType, locOf(prop));
+                        if (canBeAbsent)
+                            cond = fieldPresent();
                     }
                     const at = fields.findIndex((x) => x.name === f.name && !x.drop);
-                    const elseVal = at >= 0 ? fields[at].value : lowerer.wrappedUndefined(targetType, locOf(prop));
+                    const elseVal = at >= 0 ? fields[at].value : lowerer.absentFieldValue(targetType, locOf(prop));
                     if (!elseVal) {
                         lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(srcType)}' sources where '${f.name}' has no earlier contributor (the absent arm leaves the required field unset — spread defaults first: { ...defaults, ...overrides })`);
                     }
@@ -1641,8 +1728,10 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                         continue;
                     const lt = laterSpreadType(lowerer, later.expression);
                     if (lt?.kind === "record") {
+                        // A field the later source may lack defines nothing.
                         for (const lf of lowerer.shapes.get(lt.shapeId)?.fields ?? [])
-                            laterNames.add(lf.name);
+                            if (!canLackField(lf.type))
+                                laterNames.add(lf.name);
                     }
                     continue;
                 }
@@ -1725,6 +1814,32 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                     lowerer.unsupported("SC1090", prop, `spread of '${f.name}' over an earlier conditional spread (the desugar keeps one entry per name — restructure so each name has one contributor)`);
                 }
                 const at = fields.findIndex((x) => x.name === f.name);
+                // A source field that can be absent copies only when present: an
+                // absent one keeps the earlier contributor's value, or leaves the
+                // target field absent.
+                const canBeAbsent = f.type.kind === "union" && lowerer.armTag(f.type.unionId, UNDEFINED_T) >= 0;
+                if (canBeAbsent) {
+                    const present = obj.type.kind === "dyn"
+                        ? {
+                            kind: "dynHasKey",
+                            key: f.name,
+                            value: obj,
+                            type: BOOL,
+                            loc: locOf(prop),
+                        }
+                        : lowerer.recordFieldPresent(obj, srcType.shapeId, f.name, locOf(prop));
+                    const otherwise = at >= 0 ? fields[at].value : lowerer.absentFieldValue(targetType, locOf(prop));
+                    if (otherwise) {
+                        value = {
+                            kind: "ternary",
+                            cond: present,
+                            then: value,
+                            else_: otherwise,
+                            type: targetType,
+                            loc: locOf(prop),
+                        };
+                    }
+                }
                 if (at >= 0)
                     fields[at] = { name: f.name, value };
                 else
@@ -1913,10 +2028,10 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             fields.splice(at, 1);
         fields.push({ name, value });
     }
-    // Optional fields may be omitted: the absent field holds an undefined
-    // union arm or, for an island handle slot, the engine's undefined cell.
-    // This matches writing `a: undefined` without exactOptionalPropertyTypes;
-    // tsc rejects omission of required fields before lowering.
+    // Optional fields may be omitted: the field holds its ABSENT state (it
+    // reads as undefined but is not an own property) or, for an island
+    // handle slot, the engine's undefined cell. tsc rejects omission of
+    // required fields before lowering.
     // A REQUIRED missing field keeps the shape-mismatch rejection (possible
     // through `as`: the cast smuggles a narrower literal past freshness).
     if (droppedNames.size > 0) {
@@ -1940,7 +2055,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             const absentHandle = f.type.kind === "jsval" && optional
                 ? { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc }
                 : null;
-            const absent = lowerer.wrappedUndefined(f.type, loc) ??
+            const absent = lowerer.absentFieldValue(f.type, loc) ??
                 (f.type.kind === "dyn" ? dynUndefinedExpr(loc) : null) ??
                 absentHandle;
             if (!absent)
@@ -2194,8 +2309,8 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
         fenceAccessorSpreadSource(lowerer, prop, srcShape);
         srcs.push({ value, shapeId: value.type.shapeId, shape: srcShape });
     }
-    // Every target field must be optional: absent keys leave the undefined
-    // arm, exactly the unset-optional representation.
+    // Every target field must be optional: keys no source supplies stay
+    // absent.
     for (const f of shape.fields) {
         if (f.type.kind !== "union" || lowerer.armTag(f.type.unionId, UNDEFINED_T) < 0) {
             lowerer.unsupported("SC1090", expr, `object spread of runtime-keyed sources onto the required field '${f.name}' (the keys decide presence at runtime — declare the field optional or spell it explicitly)`);
@@ -2313,7 +2428,7 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
                 kind: "recordLit",
                 fields: shape.fields.map((f) => ({
                     name: f.name,
-                    value: lowerer.wrappedUndefined(f.type, loc),
+                    value: lowerer.absentFieldValue(f.type, loc),
                 })),
                 type,
                 loc,
@@ -2369,26 +2484,13 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
                     value: lowerer.applyWidthLift(lift, raw, target.type, loc),
                     loc,
                 };
-                // Optional declared fields use the established unset convention.
+                // Optional declared fields copy only when present (an explicit
+                // undefined is a real property and overwrites an earlier value).
                 // A dyn field, including a present undefined, is a real property;
                 // its checked conversion runs and can overwrite an earlier value.
-                const absent = field.type.kind === "union" ? lowerer.armTag(field.type.unionId, UNDEFINED_T) : -1;
-                if (absent >= 0 && field.type.kind === "union") {
-                    body.push({
-                        kind: "if",
-                        cond: {
-                            kind: "unionIsTag",
-                            unionId: field.type.unionId,
-                            tag: absent,
-                            negated: true,
-                            value: raw,
-                            type: BOOL,
-                            loc,
-                        },
-                        then: [write],
-                        else_: null,
-                        loc,
-                    });
+                const present = lowerer.recordFieldPresent(receiver, source.shapeId, field.name, loc);
+                if (present.kind === "recordHas") {
+                    body.push({ kind: "if", cond: present, then: [write], else_: null, loc });
                 }
                 else
                     body.push(write);