@scriptc/compiler 0.1.6 → 0.1.7

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

@@ -1006,6 +1006,13 @@ function lowerExprInner(lowerer, expr) {
                     const canonical = stdlibGlobalNameOf(lowerer, expr) ?? expr.text;
                     return { kind: "strLit", value: `[builtin ${canonical}]`, type: STRING, loc };
                 }
+                // In a dynamic TypeScript build, the real global object is the
+                // escape hatch for host capabilities without static lowering.
+                // Direct globalThis.member uses still take their static surface
+                // paths; an explicit `as any` or `: any` can reach engine ops.
+                if (lowerer.dynamic && expr.text === "globalThis") {
+                    return { kind: "jsOp", op: "globalGet", name: "globalThis", args: [], type: JSVAL, loc };
+                }
                 // The families with a WHY: each hint states what makes the
                 // surface genuinely non-static (or what to use instead).
                 const globalHints = {
@@ -2307,8 +2314,25 @@ export function maybeNarrow(lowerer, expr, node) {
         return expr;
     }
     const tag = lowerer.armTag(expr.type.unionId, narrowed);
-    if (tag < 0)
+    if (tag < 0) {
+        // A proven-present optional base class can narrow further to a
+        // subclass. The payload is still stored under the base class tag;
+        // unwrap it before applying the ordinary class downcast.
+        const arms = lowerer.unions.get(expr.type.unionId)?.arms ?? [];
+        const valueTag = arms.findIndex((arm) => !isUnitType(arm));
+        const valueType = arms[valueTag];
+        if (narrowed.kind === "object" && valueType?.kind === "object" &&
+            arms.every((arm, i) => i === valueTag || isUnitType(arm)) &&
+            lowerer.isSubclassOf(narrowed.className, valueType.className)) {
+            return {
+                kind: "downcast",
+                value: { kind: "unionNarrow", unionId: expr.type.unionId, tag: valueTag, value: expr, type: valueType, loc: expr.loc },
+                type: narrowed,
+                loc: expr.loc,
+            };
+        }
         return expr;
+    }
     return {
         kind: "unionNarrow",
         unionId: expr.type.unionId,
@@ -2365,12 +2389,11 @@ function runtimeOptionalReceiverRead(lowerer, expr, local, property, loc) {
         }
         return { kind: "call", callee: helper, args: [varRef(local.id, local.type, loc)], type: narrowed, loc };
     }
-    const valueTag = lowerer.armTag(local.type.unionId, narrowed);
     const undefTag = lowerer.armTag(local.type.unionId, UNDEFINED_T);
-    if (valueTag < 0 || undefTag < 0)
-        throw new InternalCompilerError("runtime-optional local is missing its value or undefined arm");
     const def = lowerer.unions.get(local.type.unionId);
-    if (!def || def.arms.length !== 2) {
+    if (!def || undefTag < 0)
+        throw new InternalCompilerError("runtime-optional local is missing its undefined arm");
+    if (def.arms.length !== 2) {
         // The checker may narrow a runtime-optional capture to one arm of a
         // value union (`Circle | Square | undefined` -> `Circle`). The
         // two-arm fast path below cannot extract that arm safely: a later
@@ -2383,10 +2406,19 @@ function runtimeOptionalReceiverRead(lowerer, expr, local, property, loc) {
         }
         return { kind: "call", callee: helper, args: [varRef(local.id, local.type, loc)], type: narrowed, loc };
     }
+    // A predicate can strengthen a record's fields or narrow a base class
+    // to a subclass without changing the slot's stored value arm. Extract
+    // that actual arm first: record reads need its original field layout,
+    // and class reads apply the ordinary downcast bridge afterward.
+    const valueTag = undefTag === 0 ? 1 : 0;
+    const valueType = def.arms[valueTag];
+    if (!valueType || isUnitType(valueType)) {
+        lowerer.unsupported("SC1090", expr, "a runtime-optional receiver without a representable value arm");
+    }
     const message = property === null
         ? `${expr.text} is not a function`
         : `Cannot read properties of undefined (reading '${property}')`;
-    return {
+    return lowerer.maybeNarrow({
         kind: "ternary",
         cond: {
             kind: "unionIsTag",
@@ -2397,18 +2429,18 @@ function runtimeOptionalReceiverRead(lowerer, expr, local, property, loc) {
             type: BOOL,
             loc,
         },
-        then: nodeThrowExpr(1, "", message, narrowed, loc),
+        then: nodeThrowExpr(1, "", message, valueType, loc),
         else_: {
             kind: "unionNarrow",
             unionId: local.type.unionId,
             tag: valueTag,
             value: varRef(local.id, local.type, loc),
-            type: narrowed,
+            type: valueType,
             loc,
         },
-        type: narrowed,
+        type: valueType,
         loc,
-    };
+    }, narrowedNode);
 }
 function runtimeOptionalUseOf(expr) {
     let receiver = expr;
@@ -3429,7 +3461,10 @@ export function lowerIntrinsicProperty(lowerer, expr) {
 export function lowerArrayLiteral(lowerer, expr, expected) {
     const loc = locOf(expr);
     const ctxType = lowerer.checker.getContextualType(expr);
-    const tsType = ctxType ?? lowerer.typeOf(expr);
+    // `as const satisfies readonly T[]` checks against an array but keeps
+    // the literal's inferred tuple type. Build that shape; an actual array
+    // destination can use the ordinary tuple-to-array coercion afterward.
+    const tsType = underConstAssertion(expr) ? lowerer.typeOf(expr) : ctxType ?? lowerer.typeOf(expr);
     let mapped = expected ?? lowerer.mapTypeOf(tsType);
     // A JS literal whose OWN inferred type is never-tainted
     // (neverTaintedJsType — the evolving `const gb = []`, the mixed
@@ -3542,13 +3577,13 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
     // literal constructs the tuple's record shape — one positional field
     // per element, source order (which IS index order, so evaluation order
     // is JS-exact). tsc has already checked the arity; the recount below
-    // backstops `as` smuggling. Spreads have no fixed positions — fenced.
+    // backstops `as` smuggling. Fixed tuple spreads have known positions.
     if (mapped?.kind === "record") {
         const shape = lowerer.shapes.get(mapped.shapeId);
         if (shape?.tuple) {
             const spread = expr.elements.find(ts.isSpreadElement);
             if (spread) {
-                lowerer.unsupported("SC1090", spread, "spread elements in tuple literals (positions must be spelled out)");
+                return lowerTupleSpreadLiteral(lowerer, expr, mapped, shape);
             }
             if (expr.elements.length !== shape.fields.length) {
                 // tsc padded an UNDER-LENGTH literal against an optional-element
@@ -3817,6 +3852,62 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
         loc,
     };
 }
+/** Build a fixed tuple from positional elements and fixed tuple spreads.
+ * Capture each value in source order: deferring the reads until recordLit
+ * would observe a later element's mutations of the spread source. */
+function lowerTupleSpreadLiteral(lowerer, expr, type, shape) {
+    const loc = locOf(expr);
+    const byName = new Map(shape.fields.map((field) => [field.name, field.type]));
+    const stmts = [];
+    const fields = [];
+    const append = (node, value) => {
+        const name = String(fields.length);
+        const expected = byName.get(name);
+        if (!expected)
+            lowerer.badType(expr, lowerer.typeOf(expr));
+        const coerced = lowerer.coerceInto(node, value, expected);
+        const temp = lowerer.declareHiddenLocal("%tupleElement", expected);
+        const at = locOf(node);
+        stmts.push({ kind: "varDecl", localId: temp.id, init: coerced, loc: at });
+        fields.push({ name, value: varRef(temp.id, expected, at) });
+    };
+    for (const element of expr.elements) {
+        if (!ts.isSpreadElement(element)) {
+            const expected = byName.get(String(fields.length));
+            if (!expected)
+                lowerer.badType(element, lowerer.typeOf(element));
+            append(element, lowerer.lowerExprExpecting(element, expected));
+            continue;
+        }
+        const source = lowerer.lowerExpr(element.expression);
+        const sourceShape = source.type.kind === "record" ? lowerer.shapes.get(source.type.shapeId) : undefined;
+        if (!sourceShape?.tuple) {
+            // Empty tuples use a zero-length array representation. Preserve a
+            // producing call's effects even though there are no positions to copy.
+            const sourceTs = lowerer.typeOf(element.expression);
+            if (source.type.kind === "array" && lowerer.checker.isTupleType(sourceTs) &&
+                lowerer.checker.getTypeArguments(sourceTs).length === 0) {
+                stmts.push({ kind: "exprStmt", expr: source, loc: locOf(element) });
+                continue;
+            }
+            lowerer.unsupported("SC1090", element, "spreading a variable-length value into a fixed tuple literal");
+        }
+        const temp = lowerer.declareHiddenLocal("%tupleSpread", source.type);
+        const at = locOf(element);
+        stmts.push({ kind: "varDecl", localId: temp.id, init: source, loc: at });
+        const receiver = varRef(temp.id, source.type, at);
+        const positions = [...sourceShape.fields].sort((a, b) => Number(a.name) - Number(b.name));
+        for (const field of positions) {
+            append(element.expression, {
+                kind: "recordGet", obj: receiver, shapeId: sourceShape.id,
+                field: field.name, type: field.type, loc: at,
+            });
+        }
+    }
+    if (fields.length !== shape.fields.length)
+        lowerer.badType(expr, lowerer.typeOf(expr));
+    return { kind: "seqExpr", stmts, result: { kind: "recordLit", fields, type, loc }, type, loc };
+}
 /** Convert an undefined-armed numeric value at an arithmetic use. Ordinary
  * reads preserve their tagged value; JavaScript's ToNumber(undefined) is NaN,
  * so compounds and binary arithmetic use this checked one-time extraction. */
@@ -4384,6 +4475,16 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
         // to observe the missing value instead of throwing during that check.
         return includeUndefined ? read : lowerer.maybeNarrow(read, expr);
     }
+    // Predicates can strengthen optional fields without changing the
+    // receiver's stored layout. Use that layout for bracket reads just as
+    // fieldTarget does for the corresponding dot reads.
+    if (obj.type.kind === "record") {
+        const actualShape = lowerer.shapes.get(obj.type.shapeId);
+        if (!actualShape)
+            throw new InternalCompilerError("record receiver is missing its stored shape");
+        shapeId = obj.type.shapeId;
+        shape = actualShape;
+    }
     if (litKey !== null) {
         const field = shape.fields.find((f) => f.name === litKey);
         if (field) {
@@ -6619,7 +6720,7 @@ export function lowerCaughtTypeofTest(lowerer, expr, loc) {
         if (!ts.isStringLiteral(b)) {
             lowerer.unsupported("SC1090", expr, "'typeof' catch-binding tests against non-literal strings");
         }
-        if (b.text === "string" || b.text === "number" || b.text === "boolean") {
+        if (b.text === "string" || b.text === "number" || b.text === "boolean" || b.text === "object") {
             return {
                 kind: "caughtTest",
                 value: { kind: "varRef", localId: local.id, type: CAUGHT, loc },
@@ -6629,8 +6730,7 @@ export function lowerCaughtTypeofTest(lowerer, expr, loc) {
                 loc,
             };
         }
-        lowerer.unsupported("SC1090", b, `'typeof' catch-binding tests against "${b.text}" (only "string"/"number"/"boolean" ` +
-            `narrow a catch binding; use 'instanceof' for objects)`);
+        lowerer.unsupported("SC1090", b, `'typeof' catch-binding tests against "${b.text}" (only "string"/"number"/"boolean"/"object" are supported)`);
     }
     return null;
 }