@scriptc/compiler 0.2.8 → 0.2.10

package/dist/frontend/lowering/lower-exprs.d.ts

@@ -164,6 +164,12 @@ export declare function lowerArrayLiteral(lowerer: Lowerer, expr: ts.ArrayLitera
  * reads preserve their tagged value; JavaScript's ToNumber(undefined) is NaN,
  * so compounds and binary arithmetic use this checked one-time extraction. */
 export declare function lowerOptionalNumber(lowerer: Lowerer, operand: IrExpr, loc: SrcLoc, narrowedNode?: ts.Expression): IrExpr;
+/** A number argument of a builtin that converts it with ToNumber (Math
+ * functions, String.fromCharCode, the global isNaN/isFinite, DataView
+ * offsets and values). ToNumber(undefined) is NaN, so a missing value — an
+ * out-of-range read, a local or field holding one, or a hole — converts to
+ * NaN instead of trusting the checker's number type. */
+export declare function lowerToNumberArgument(lowerer: Lowerer, node: ts.Expression): IrExpr;
 /** `a[i]` reads. Only f64 indices into array receivers are modeled; JS
  * string-key element access (`a["length"]`) and string indexing (`s[0]`
  * typechecks against the lib's index signature; use .charAt) stay out. */

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

@@ -19,8 +19,9 @@ import { constituentTypes } from "../ts7/checker.js";
 import { dirname } from "node:path";
 import * as posix from "node:path/posix";
 import { checkedClassAssertion, checkedClassUnionAssertion } from "./class-assertions.js";
+import { checkedArmExtraction } from "./coercions/unions.js";
 import { narrowClassUnion, narrowStoredClassValue } from "./class-unions.js";
-import { lowerUnionFieldWrite } from "./expressions/union-field-write.js";
+import { lowerUnionFieldRead, lowerUnionFieldWrite } from "./expressions/union-fields.js";
 import { captureContextArguments } from "./function-context.js";
 import { OBJECT_CALLABLE_VALUES } from "./surfaces.js";
 import { wasiGuestPath } from "../../wasi-paths.js";
@@ -167,7 +168,14 @@ export function lowerExpr(lowerer, expr) {
     }
     lowerExprDepth++;
     try {
-        const lowered = lowerExprInner(lowerer, expr);
+        let lowered = lowerExprInner(lowerer, expr);
+        const nanCoded = lowerer.nanCodedReads;
+        if (nanCoded) {
+            if (lowered.type.kind === "f64" && nanCoded.reboxes(expr))
+                lowered = reboxNanCoded(lowerer, lowered, locOf(expr));
+            else if (lowered.type.kind === "union" && nanCoded.convertsSource(expr))
+                lowered = lowerOptionalNumber(lowerer, lowered, locOf(expr));
+        }
         if (lowered.type.kind === "void" && (lowerer.typeOf(expr).flags & ts.TypeFlags.Never) !== 0)
             lowerer.neverValued.add(lowered);
         return lowered;
@@ -176,6 +184,27 @@ export function lowerExpr(lowerer, expr) {
         lowerExprDepth--;
     }
 }
+/** `number | undefined` from a NaN-coded double whose slot never holds a
+ * genuine NaN (nan-coded-reads.ts): NaN is exactly undefined. */
+function reboxNanCoded(lowerer, value, loc) {
+    const optional = lowerer.withUndefinedArm(F64);
+    const stmts = [];
+    let stable = value;
+    if (value.kind !== "varRef") {
+        const tmp = lowerer.declareHiddenLocal("%nanCoded", F64);
+        stmts.push({ kind: "varDecl", localId: tmp.id, init: value, loc });
+        stable = varRef(tmp.id, F64, loc);
+    }
+    const result = {
+        kind: "ternary",
+        cond: { kind: "libCall", fn: "num.isNaN", args: [stable], type: BOOL, loc },
+        then: lowerer.wrappedUndefined(optional, loc),
+        else_: lowerer.coerceToExpected(stable, optional),
+        type: optional,
+        loc,
+    };
+    return stmts.length === 0 ? result : { kind: "seqExpr", stmts, result, type: optional, loc };
+}
 function lowerExprInner(lowerer, expr) {
     const loc = locOf(expr);
     // An optional chain's guarded receiver: already evaluated by the
@@ -797,6 +826,13 @@ function lowerExprInner(lowerer, expr) {
         // tests, so only side-effect-free reads compose — and when every arm
         // agrees the whole expression folds to that one string (dropping only
         // the pure read, the trust-the-checker bet lowerUnitComparison makes).
+        // An effectful producer (a getter) evaluates once into a hidden local.
+        const prelude = [];
+        if (operand.type.kind === "union" && !isSafeToRepeat(operand)) {
+            const local = lowerer.declareHiddenLocal("%typeofOperand", operand.type);
+            prelude.push({ kind: "varDecl", localId: local.id, init: operand, loc });
+            operand = varRef(local.id, operand.type, loc);
+        }
         if (operand.type.kind === "union" && isSafeToRepeat(operand)) {
             const def = lowerer.unions.get(operand.type.unionId);
             const answers = def?.arms.map(typeofAnswer);
@@ -847,7 +883,9 @@ function lowerExprInner(lowerer, expr) {
                         loc,
                     };
                 }
-                return result;
+                return prelude.length > 0
+                    ? { kind: "seqExpr", stmts: prelude, result, type: STRING, loc }
+                    : result;
             }
         }
         if (operand.type.kind === "dyn") {
@@ -2209,6 +2247,11 @@ function lowerExprInner(lowerer, expr) {
                 handled.kind === "recordGet" &&
                 lowerer.isRuntimeOptionalField(handled.shapeId, handled.field))
                 return handled;
+            // A class field assigned a missing read: the checker narrows this
+            // read to the assigned value's bare type, but the stored undefined
+            // arm is real (`obj.n = bytes[i]; obj.n` is undefined in Node).
+            if (runtimeOptionalClassField(lowerer, handled, expr))
+                return handled;
             return lowerer.maybeNarrow(handled, expr);
         }
         // `globalThis.<name>` that no lowering above claimed
@@ -3116,6 +3159,11 @@ export function maybeNarrow(lowerer, expr, node) {
         if (narrowed?.kind === "object" &&
             narrowed.className !== expr.type.className &&
             lowerer.isSubclassOf(narrowed.className, expr.type.className)) {
+            if (lowerer.narrowing.untrusted(node, narrowed)) {
+                const checked = checkedClassAssertion(lowerer, expr, narrowed, expr.loc);
+                if (checked)
+                    return checked;
+            }
             return { kind: "downcast", value: expr, type: narrowed, loc: expr.loc };
         }
         return expr;
@@ -3158,6 +3206,9 @@ export function maybeNarrow(lowerer, expr, node) {
         const arrayTags = lowerer.arrayValueTags(expr.type.unionId);
         if (arrayTags.length === 1) {
             const arm = def.arms[arrayTags[0]];
+            const checked = checkedStaleArm(lowerer, node, expr, arrayTags[0], arm);
+            if (checked)
+                return checked;
             return {
                 kind: "unionNarrow",
                 unionId: expr.type.unionId,
@@ -3191,6 +3242,9 @@ export function maybeNarrow(lowerer, expr, node) {
                 const values = literalValues(lowerer.checker.getTypeOfSymbol(property));
                 const arm = values && literalUnionArm(def, values, (id) => lowerer.shapes.get(id));
                 if (arm) {
+                    const checked = checkedStaleArm(lowerer, node, expr, lowerer.armTag(expr.type.unionId, arm), arm);
+                    if (checked)
+                        return checked;
                     return {
                         kind: "unionNarrow",
                         unionId: expr.type.unionId,
@@ -3216,6 +3270,10 @@ export function maybeNarrow(lowerer, expr, node) {
                 arm.kind !== "object" ||
                 !lowerer.isSubclassOf(narrowed.className, arm.className)) &&
             lowerer.isSubclassOf(narrowed.className, valueType.className)) {
+            const checked = checkedStaleArm(lowerer, node, expr, valueTag, valueType, narrowed);
+            if (checked) {
+                return checkedClassAssertion(lowerer, checked, narrowed, expr.loc) ?? checked;
+            }
             return {
                 kind: "downcast",
                 value: {
@@ -3232,6 +3290,9 @@ export function maybeNarrow(lowerer, expr, node) {
         }
         return expr;
     }
+    const checked = checkedStaleArm(lowerer, node, expr, tag, narrowed);
+    if (checked)
+        return checked;
     return {
         kind: "unionNarrow",
         unionId: expr.type.unionId,
@@ -3241,6 +3302,60 @@ export function maybeNarrow(lowerer, expr, node) {
         loc: expr.loc,
     };
 }
+/** The checked form of maybeNarrow's arm extraction for a narrowing the
+ * checker may hold past code that replaced the value (a call clearing the
+ * property; see NarrowingStability). Every other arm throws the TypeError
+ * Node raises for the operation consuming the read (`Cannot read
+ * properties of undefined (reading 'x')`, `o.f is not a function`), or the
+ * stranded-value TypeError where Node would carry the value on. Null when
+ * the narrowing is provably current. `narrowed` is the checker's type when
+ * it refines the arm (a subclass view). */
+function checkedStaleArm(lowerer, node, value, tag, arm, narrowed = arm) {
+    if (value.type.kind !== "union" || tag < 0)
+        return null;
+    if (!lowerer.narrowing.untrusted(node, narrowed))
+        return null;
+    const inPlace = checkedArmExtraction(lowerer, value, tag, arm, (found) => staleReadMessage(node, found));
+    if (inPlace)
+        return inPlace;
+    const helper = lowerer.narrowedArmHelper(value.type.unionId, arm, value.loc);
+    return helper ? lowerer.checkedNarrowCall(helper, value, arm, value.loc) : null;
+}
+/** Node's TypeError for the operation consuming `node` when it holds a
+ * value of type `found`, or null where Node would not throw. */
+function staleReadMessage(node, found) {
+    let child = node;
+    let parent = node.parent;
+    while (ts.isParenthesizedExpression(parent)) {
+        child = parent;
+        parent = parent.parent;
+    }
+    if (ts.isCallExpression(parent) && parent.expression === child && !parent.questionDotToken) {
+        return found.kind === "func" ? null : `${node.getText()} is not a function`;
+    }
+    const unit = found.kind === "undefinedT" ? "undefined" : found.kind === "nullT" ? "null" : null;
+    if (unit === null)
+        return null;
+    if (!(ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) ||
+        parent.expression !== child ||
+        parent.questionDotToken)
+        return null;
+    let key = null;
+    if (ts.isPropertyAccessExpression(parent))
+        key = parent.name.text;
+    else if (ts.isStringLiteral(parent.argumentExpression))
+        key = parent.argumentExpression.text;
+    else if (ts.isNumericLiteral(parent.argumentExpression))
+        key = String(Number(parent.argumentExpression.text));
+    if (key === null)
+        return null;
+    const store = parent.parent;
+    return ts.isBinaryExpression(store) &&
+        store.left === parent &&
+        store.operatorToken.kind === ts.SyntaxKind.EqualsToken
+        ? `Cannot set properties of ${unit} (setting '${key}')`
+        : `Cannot read properties of ${unit} (reading '${key}')`;
+}
 /** A runtime-optional slot can be assigned while a truthy guard is in
  * force. TypeScript then types a direct member receiver as the plain arm,
  * even though an OOB-safe assignment may have restored undefined. Check
@@ -5582,6 +5697,34 @@ export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
         ? value
         : { kind: "seqExpr", stmts: prefix, result: value, type: F64, loc };
 }
+/** A number argument of a builtin that converts it with ToNumber (Math
+ * functions, String.fromCharCode, the global isNaN/isFinite, DataView
+ * offsets and values). ToNumber(undefined) is NaN, so a missing value — an
+ * out-of-range read, a local or field holding one, or a hole — converts to
+ * NaN instead of trusting the checker's number type. */
+export function lowerToNumberArgument(lowerer, node) {
+    let inner = node;
+    while (ts.isParenthesizedExpression(inner))
+        inner = inner.expression;
+    const loc = locOf(inner);
+    const isOptionalNumber = (value) => value.type.kind === "union" &&
+        lowerer.armTag(value.type.unionId, UNDEFINED_T) >= 0 &&
+        lowerer.stripUndefinedArm(value.type).kind === "f64";
+    const optional = ts.isIdentifier(inner)
+        ? runtimeOptionalStorageOperand(lowerer, inner)
+        : ts.isElementAccessExpression(inner)
+            ? lowerAbsenceProbe(lowerer, inner)
+            : null;
+    if (optional && isOptionalNumber(optional))
+        return lowerOptionalNumber(lowerer, optional, loc, inner);
+    // A conditional builds each branch for the destination.
+    if (ts.isConditionalExpression(inner))
+        return lowerer.lowerExprExpecting(node, F64);
+    const value = lowerer.lowerExpr(node);
+    if (isOptionalNumber(value))
+        return lowerOptionalNumber(lowerer, value, loc, inner);
+    return lowerer.coerceInto(node, value, F64);
+}
 /** `a[i]` reads. Only f64 indices into array receivers are modeled; JS
  * string-key element access (`a["length"]`) and string indexing (`s[0]`
  * typechecks against the lib's index signature; use .charAt) stay out. */
@@ -5866,7 +6009,10 @@ export function lowerElementAccess(lowerer, expr) {
         // `t[i]!` asserts presence: the numeric element read (NaN when
         // invalid). Every other read answers undefined for an invalid index,
         // like Node.
-        if (ts.isNonNullExpression(expr.parent) && expr.parent.expression === expr) {
+        // A read whose every consumer treats undefined like NaN (see
+        // nan-coded-reads.ts) is the same plain numeric read.
+        if ((ts.isNonNullExpression(expr.parent) && expr.parent.expression === expr) ||
+            lowerer.nanCodedReads?.isNumericRead(expr) === true) {
             return {
                 kind: "bytesIntrinsic",
                 method: "get",
@@ -6529,6 +6675,23 @@ export function runtimeOptionalStorageOperand(lowerer, node) {
         return null;
     return optional.value;
 }
+/** A `T | undefined` class field read that the checker narrowed to `T`
+ * where the field was assigned a value that may be missing (an unchecked
+ * indexed read). TypeScript's assignment narrowing is not a runtime fact
+ * there, so the read keeps the stored union instead of extracting `T`. */
+function runtimeOptionalClassField(lowerer, value, node) {
+    if (value.kind !== "fieldGet" || value.type.kind !== "union")
+        return false;
+    if (lowerer.armTag(value.type.unionId, UNDEFINED_T) < 0)
+        return false;
+    if ((lowerer.unions.get(value.type.unionId)?.arms.length ?? 0) !== 2)
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(node.name);
+    if (!symbol || !lowerer.runtimeOptionalAssignedSymbols.has(symbol))
+        return false;
+    const narrowed = lowerer.mapTypeOf(lowerer.typeOf(node));
+    return narrowed !== null && typeEquals(narrowed, lowerer.stripUndefinedArm(value.type));
+}
 /** A presence-test operand: an absence-aware element or field read, an
  * identifier's runtime-optional storage, or the ordinary lowering. */
 export function lowerPresenceOperand(lowerer, node) {
@@ -8298,12 +8461,75 @@ export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
     }
     lowerer.unsupported("SC1043", expr);
 }
+/** Equality of two NaN-coded values (nan-coded-reads.ts), each of which may
+ * stand for undefined and never holds a genuine NaN: Node's undefined equals
+ * undefined, so two NaNs compare equal here. Operands evaluate once, in
+ * order. */
+function lowerNanCodedEquality(lowerer, expr) {
+    const loc = locOf(expr);
+    const left = lowerer.lowerExpr(expr.left);
+    const right = lowerer.lowerExpr(expr.right);
+    if (left.type.kind !== "f64" || right.type.kind !== "f64") {
+        throw new InternalCompilerError("NaN-coded equality operand is not a plain number");
+    }
+    const stmts = [];
+    const stable = (value, name) => {
+        if (value.kind === "varRef" || value.kind === "numLit")
+            return value;
+        const tmp = lowerer.declareHiddenLocal(name, F64);
+        stmts.push({ kind: "varDecl", localId: tmp.id, init: value, loc });
+        return varRef(tmp.id, F64, loc);
+    };
+    const a = stable(left, "%eqLeft");
+    const b = stable(right, "%eqRight");
+    const isNaN = (value) => ({
+        kind: "libCall",
+        fn: "num.isNaN",
+        args: [value],
+        type: BOOL,
+        loc,
+    });
+    const bothUndefined = {
+        kind: "logical",
+        op: "&&",
+        left: isNaN(a),
+        right: isNaN(b),
+        type: BOOL,
+        loc,
+    };
+    const op = expr.operatorToken.kind;
+    const negated = op === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+        op === ts.SyntaxKind.ExclamationEqualsToken;
+    const result = negated
+        ? {
+            kind: "logical",
+            op: "&&",
+            left: { kind: "bin", op: "!==", left: a, right: b, type: BOOL, loc },
+            right: { kind: "unary", op: "!", operand: bothUndefined, type: BOOL, loc },
+            type: BOOL,
+            loc,
+        }
+        : {
+            kind: "logical",
+            op: "||",
+            left: { kind: "bin", op: "===", left: a, right: b, type: BOOL, loc },
+            right: bothUndefined,
+            type: BOOL,
+            loc,
+        };
+    return stmts.length === 0 ? result : { kind: "seqExpr", stmts, result, type: BOOL, loc };
+}
 export function lowerBinary(lowerer, expr) {
     const loc = locOf(expr);
     const op = expr.operatorToken.kind;
     const cacheHas = lowerRequireCacheHas(lowerer, expr);
     if (cacheHas)
         return cacheHas;
+    if (lowerer.nanCodedReads?.needsUndefinedEquality(expr)) {
+        const undefinedEquality = lowerNanCodedEquality(lowerer, expr);
+        if (undefinedEquality)
+            return undefinedEquality;
+    }
     if (op === ts.SyntaxKind.EqualsToken ||
         (op >= ts.SyntaxKind.FirstCompoundAssignment && op <= ts.SyntaxKind.LastCompoundAssignment)) {
         const urlWrite = lowerUrlAssignment(lowerer, expr);
@@ -12246,6 +12472,11 @@ export function lowerUnionProperty(lowerer, expr) {
         const helper = lowerer.narrowedRetagHelper(expr.expression, value.type.unionId, receiverIr.unionId, locOf(expr));
         if (helper)
             value = { kind: "call", callee: helper, args: [value], type: receiverIr, loc: locOf(expr) };
+        // Optional storage of a base class (a runtime-optional binding holding
+        // `Base | undefined`) that `instanceof` narrowed to several subclasses:
+        // extract the instance and test its class, as typed slots do.
+        else
+            value = narrowStoredClassValue(lowerer, value, receiverIr) ?? value;
     }
     // A checker-union receiver whose VALUE lowered to a plain RECORD (the
     // merged-signature fiction — `runner(cmd, args)` where runner joined
@@ -12368,6 +12599,11 @@ export function lowerUnionProperty(lowerer, expr) {
     const keyed = lowerUnionKeyedRead(lowerer, expr, value.type.unionId, value, key, field);
     if (keyed)
         return keyed;
+    // Class arms declaring the field with compatible but different types
+    // (`T | undefined` beside `T`): per-arm slot reads widened to one type.
+    const widened = lowerUnionFieldRead(lowerer, expr, value);
+    if (widened)
+        return widened;
     // JavaScript overloads commonly inspect a class brand on a scalar-or-
     // instance argument (e.g. Matrix4.makeTranslation). Preserve primitive
     // missing-property semantics and dispatch class data through its native
@@ -12532,6 +12768,11 @@ function classFieldTarget(lowerer, receiverNode, receiverType, fieldName, saved)
     const lowerObjectReceiver = () => {
         let obj = represented;
         if (obj.type.kind === "union") {
+            // A receiver that may hold a missing value (a field assigned an
+            // unchecked read): Node's member-read TypeError for the unit arm.
+            const present = lowerer.runtimeOptionalPropertyReceiver(receiverNode, obj, receiverType, fieldName);
+            if (present)
+                return present;
             const helper = lowerer.narrowedArmHelper(obj.type.unionId, receiverType, locOf(receiverNode));
             obj = helper
                 ? lowerer.checkedNarrowCall(helper, obj, receiverType, locOf(receiverNode))