@scriptc/compiler 0.3.1 → 0.3.3

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

@@ -8,7 +8,7 @@ import { NARROW_FIRST } from "../surfaces.js";
 import { recordShapeMismatchDiag } from "../../../diagnostics/diagnostic.js";
 import { PoisonError, neverTaintedJsType } from "../lowerer.js";
 import { lowerIndexMergeHelper } from "../containers/indexed-objects.js";
-import { isGenericCallableMemberType, jsOpenObjectType } from "../../type-mapper.js";
+import { PERF_ENTRY_MARKER, isGenericCallableMemberType, jsOpenObjectType, } from "../../type-mapper.js";
 import { isSafeToRepeat } from "./evaluation-safety.js";
 import { tryLowerExpression } from "./try-lower-expression.js";
 import { fenceSymbolFieldCopy } from "../symbol-fields.js";
@@ -21,30 +21,6 @@ import { runtimeOptionalStorageOperand } from "../lower-exprs.js";
  * smuggle a wider/narrower literal past tsc's freshness check), which the
  * exact-shape checks below reject with SC2002. Fields lower IN SOURCE
  * ORDER: JS evaluates property values in source order. */
-/** The dropped-field names of the PromiseSettledResult honest subset
- * (SEMANTICS.md 46): when the literal's target type is (a union
- * containing) the lib's PromiseFulfilledResult / PromiseRejectedResult,
- * the record mapping kept only `status` — `value` and `reason` evaluate
- * for effect and are not stored. Null for every other target. */
-function settledDropNames(lowerer, tsType) {
-    let names = null;
-    const parts = tsType.isUnionType() ? ts.constituentTypes(tsType) : [tsType];
-    for (const part of parts) {
-        const sym = part.getSymbol();
-        if (!sym ||
-            !lowerer.checker
-                .declarationsOf(sym)
-                .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
-            continue;
-        }
-        if (sym.name === "PromiseFulfilledResult" || sym.name === "PromiseRejectedResult") {
-            if (names === null)
-                names = new Set();
-            names.add(sym.name === "PromiseFulfilledResult" ? "value" : "reason");
-        }
-    }
-    return names;
-}
 /** `{ [KEY]: v }` where KEY is a compile-time-known string or number:
  * the key folds into an ordinary (spelled) property name — the record
  * shape is exactly what tsc computed for the literal (the late-bound
@@ -436,9 +412,12 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
 /** Spreading a source whose shape carries accessor slots: Node's copy
  * invokes each getter exactly once in insertion order — even for keys a
  * later contributor overrides — while the field-copy desugar assumes pure
- * reads it may drop or reorder. Getter-call counts would silently diverge,
- * so accessor-carrying sources fence by name. */
+ * reads it may drop or reorder. Getter-call counts would diverge from Node
+ * without a diagnostic, so accessor-carrying sources fence by name. */
 function fenceAccessorSpreadSource(lowerer, prop, srcShape) {
+    if (srcShape && srcShape.fields.some((f) => f.name === PERF_ENTRY_MARKER)) {
+        lowerer.unsupported("SC1090", prop, "object spread over performance entries (Node keeps their fields as prototype getters, so own-key walks see none; read the fields or call toJSON())");
+    }
     if (srcShape && shapeHasAccessorSlots(srcShape)) {
         lowerer.unsupported("SC1090", prop, "object spread of sources carrying get/set accessor properties (Node invokes each getter once during the copy — the field-copy desugar cannot model the calls; bind the reads to consts first)");
     }
@@ -785,7 +764,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             // reserved closure slots (%get:/%set: — see accessorSlotProp);
             // `this` in the body is fenced up front: the closure slot has no
             // receiver (capturing the record under construction would be an
-            // RC cycle), and the generic lexical-this walk would silently
+            // RC cycle), and the generic lexical-this walk would incorrectly
             // capture an ENCLOSING method's `this` — the object-method rule.
             if (!isJsSourceFile(expr.getSourceFile())) {
                 rejectThisInObjectAccessor(lowerer, prop.body ?? prop);
@@ -811,7 +790,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         // Shorthand methods are just closure-valued fields — but their `this`
         // is dynamically bound (typed as the literal by tsc, so noImplicitThis
         // lets it through) and records don't model it; the generic
-        // lexical-this walk would silently capture an ENCLOSING method's
+        // lexical-this walk would incorrectly capture an ENCLOSING method's
         // `this`, so any `this` in the body is rejected up front.
         if (ts.isMethodDeclaration(prop))
             lowerer.rejectThisInObjectMethod(prop.body ?? prop);
@@ -1395,8 +1374,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
     };
     // 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 —
-    // collisions fence in both directions.
+    // contributor overriding one would drop that evaluation without a
+    // diagnostic — collisions fence in both directions.
     const conditionalNames = new Set();
     // Member names DROPPED from the shape (JS deferral — unlowerable pure
     // member reads narrow away; see the catch in the property loop).
@@ -1408,11 +1387,6 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         if (hasSpread) {
             for (let i = 0; i < fields.length; i++) {
                 const field = fields[i];
-                if (field.drop) {
-                    spreadStmts.push({ kind: "exprStmt", expr: field.value, loc: field.value.loc });
-                    fields.splice(i--, 1);
-                    continue;
-                }
                 field.value = captureField(field.value);
             }
         }
@@ -1465,7 +1439,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             }
             // `{ ...base, ... }` — field-by-field copy of a known record
             // shape. Every source field must land on the target shape with an
-            // equal type (a wider source would silently DROP fields JS keeps —
+            // equal type (a wider source would DROP fields JS keeps —
             // the width fence, same as literals). Later contributors override
             // earlier ones (JS last-write-wins). Evaluate the source exactly
             // once, including empty sources and those whose fields are all
@@ -1675,7 +1649,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                         if (canBeAbsent)
                             cond = fieldPresent();
                     }
-                    const at = fields.findIndex((x) => x.name === f.name && !x.drop);
+                    const at = fields.findIndex((x) => x.name === f.name);
                     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 })`);
@@ -1780,8 +1754,8 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
                 // field type (dynCheck) — the checked-dynamic member-read
                 // discipline. A missing key answers the dyn undefined, exactly
                 // the undefined-armed optional's absent case; a mismatched
-                // runtime value throws the catchable TypeError, never a silent
-                // wrong copy. Runtime-ADDED keys drop — width subtyping in
+                // runtime value throws the catchable TypeError instead of
+                // producing a wrong copy. Runtime-ADDED keys drop — width subtyping in
                 // spread clothing, divergence 36's stance.
                 let value;
                 if (obj.type.kind === "dyn") {
@@ -1887,10 +1861,7 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
         let fieldType = fieldTypes.get(name);
         // An undeclared name against an index-signature shape is an OVERFLOW
         // entry (tsc typechecked it against the signature's value type);
-        // against a plain shape it is the width mismatch it always was —
-        // EXCEPT the PromiseSettledResult honest subset's dropped fields
-        // (value/reason — SEMANTICS.md 46): those evaluate for effect in
-        // their source-order slot and store nothing.
+        // against a plain shape it is the width mismatch it always was.
         // A GENERIC-callable member (a generic method `m<T>(x: T) {...}` or a
         // generic arrow/function-expression property): excluded from the
         // record shape (isGenericCallableMemberType — no single closure slot
@@ -1921,28 +1892,6 @@ export function lowerObjectLiteral(lowerer, expr, expected) {
             }
         }
         if (!fieldType && !shape.indexValue) {
-            if (settledDropNames(lowerer, tsType)?.has(name)) {
-                // Identifier and shorthand initializers are effect-free reads —
-                // skipped outright. The caught `reason` MUST skip: lowering the
-                // read would hit the catch-binding narrowness fence, and the
-                // snapshot it names needs no evaluation.
-                if (ts.isPropertyAssignment(prop) && !ts.isIdentifier(prop.initializer)) {
-                    const v = lowerer.lowerExpr(prop.initializer);
-                    // Effect-free lowerings (literals, plain reads) drop at
-                    // compile time; anything else — the awaited mapper — runs
-                    // (and may throw into the enclosing catch) with its result
-                    // released by the statement frame.
-                    if (v.kind !== "unitLit" &&
-                        v.kind !== "numLit" &&
-                        v.kind !== "strLit" &&
-                        v.kind !== "boolLit" &&
-                        v.kind !== "varRef" &&
-                        v.kind !== "closure") {
-                        fields.push({ name, value: v, drop: true });
-                    }
-                }
-                continue;
-            }
             shapeMismatch(prop);
         }
         let value;
@@ -2135,7 +2084,8 @@ function lowerUnionRecordClone(lowerer, expr) {
             const lift = valueType ? lowerer.widthLiftPlan(valueType, fieldType) : null;
             // The inferred result must retain an override's own fields and
             // aliases. A structural copy into the source field's narrower shape
-            // would silently reshape an unannotated spread expression.
+            // would reshape an unannotated spread expression without a
+            // diagnostic.
             if (!lift)
                 return null;
             if (lift.how === "retag" && valueType?.kind === "union" && fieldType.kind === "union") {
@@ -2657,6 +2607,9 @@ export function lowerShorthandValue(lowerer, prop) {
         if (stored)
             return stored;
         const local = lowerer.resolveKey(symbol, propName);
+        // A catch binding reads like the long form `{ reason: reason }`.
+        if (local?.type.kind === "caught")
+            return lowerer.caughtRead(propName, local, loc);
         if (local) {
             return lowerer.maybeNarrow({ kind: "varRef", localId: local.id, type: local.type, loc }, propName);
         }
@@ -2713,7 +2666,7 @@ export function rejectThisInObjectMethod(lowerer, node) {
  * referencing `this` (`get x() { return this._x }`). The accessor lowers
  * as a closure stored IN the record — passing the record as a receiver
  * would capture the value under construction (an RC cycle), and the
- * generic lexical-this walk would silently bind an ENCLOSING method's
+ * generic lexical-this walk would incorrectly bind an ENCLOSING method's
  * `this`; the fence names the fix (capture a binding instead). */
 function rejectThisInObjectAccessor(lowerer, node) {
     if (node.kind === ts.SyntaxKind.ThisKeyword) {