@scriptc/compiler 0.0.34 → 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;
@@ -3755,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 ||
@@ -3832,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;
@@ -4183,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())
@@ -4205,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;
@@ -4350,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);
@@ -4380,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);
@@ -5955,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);
@@ -6036,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;
@@ -7627,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;
@@ -7882,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);