@scriptc/compiler 0.2.8 → 0.2.9

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

@@ -20,7 +20,7 @@ import { dirname } from "node:path";
 import * as posix from "node:path/posix";
 import { checkedClassAssertion, checkedClassUnionAssertion } from "./class-assertions.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 +167,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 +183,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
@@ -2209,6 +2237,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
@@ -5582,6 +5615,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 +5927,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 +6593,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 +8379,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 +12390,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 +12517,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 +12686,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))