@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -1,6 +1,8 @@
+import { arrayClassMemberOwner, arrayOfClassInstance, arrayRootOf, } from "./builtins/array-classes.js";
 import { keyedHelperName } from "./stable-names.js";
 import { isNewTarget, lowerNewTarget, lowerNewTargetComparison, lowerNewTargetName, } from "./new-target.js";
 import { lowerWebAssemblyValue, refuseWebAssemblyUse } from "./builtins/webassembly.js";
+import { lowerIslandExpr } from "./lower-node-island.js";
 import { lowerAwaitedUniformPromiseAll } from "./builtins/promises.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
@@ -14,7 +16,7 @@ import * as ts from "../ts7/adapter.js";
 import { checkedPrivateReceiver, localPrivateBrandClass } from "./private-brands.js";
 import { staticCondition } from "./static-typeof.js";
 import { constituentTypes } from "../ts7/checker.js";
-import { lowerMaybePromiseAwait, maybePromiseUnionOf } from "./maybe-promise.js";
+import { lowerMaybePromiseAwait, maybePromiseUnionOf, promiseArmedUnionOf, } from "./maybe-promise.js";
 import { checkedClassUnionAssertion } from "./class-assertions.js";
 import { BIGINT_T, BOOL, CAUGHT, DYN, F64, NULL_T, REF_TRUTHY_KINDS, REGEX, STRING, UNDEFINED_T, VOID, arrayOf, funcOf, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
 import { cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportTargetLiteral, isJsSourceFile, locOf, } from "../program.js";
@@ -31,6 +33,8 @@ import { unitOnlyUnion } from "../type-mapper.js";
 import { lowerYield } from "./lower-generators.js";
 import { unionWideningTags } from "../../ir/analysis.js";
 import { isSafeToDiscard, isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { everyExprChild } from "../../ir/traverse.js";
+import { declareContextLocal } from "./function-context.js";
 import { hasOptionalChainGuard, isOptionalChainTail } from "./expressions/optional-chains.js";
 import { classToStringConversion, classUnionToString } from "./class-to-primitive.js";
 import { lowerCjsTopLevelThis, lowerRequireCacheElement } from "./lower-node-module.js";
@@ -42,7 +46,8 @@ import { lowerFieldCompoundValue, lowerIncDec } from "./expressions/updates.js";
 import { lowerTernary, v8CalleeText } from "./expressions/narrowing.js";
 import { classFieldTarget, lowerPropertyAccessExpr, lowerUnionKeyedRead, } from "./expressions/property-access.js";
 import { lowerNullishPair } from "./expressions/binary.js";
-import { lowerElementCompoundParts } from "./expressions/element-access.js";
+import { lowerElementCompoundParts, recordKeyLiteralText } from "./expressions/element-access.js";
+import { OBJECT_PROTOTYPE_MEMBERS } from "../shape-inference/domain.js";
 export { DEFERRED_READ_MESSAGE, abstractPropertyDeclOf, builtinFunctionValue, builtinGlobalValue, fieldGetExpr, fieldTarget, isMatchSliceType, lowerFieldRead, lowerGroupsProjection, lowerIntrinsicProperty, lowerUnionProperty, matchResultNamedGroupsOf, primitiveConstructorOr, } from "./expressions/property-access.js";
 export { lowerAsExpression, lowerTernary, maybeNarrow, runtimeOptionalGuardIds, runtimeOptionalTrueIds, v8CalleeText, withRuntimeOptionalNarrowed, } from "./expressions/narrowing.js";
 export { ensureString, lowerBinary, lowerCompoundValueToTarget, lowerElementCompound, lowerNativeFunctionAssignment, lowerStrictEquality, lowerUnitComparison, } from "./expressions/binary.js";
@@ -129,6 +134,13 @@ function lowerExprInner(lowerer, expr) {
     const chainRecv = lowerer.chainRecvByNode.get(expr);
     if (chainRecv)
         return { ...chainRecv, loc };
+    // Node islands (scope-B NI-4): member operations on island values and
+    // island import bindings. Programs without islands skip it.
+    if (lowerer.nodeIslands !== null) {
+        const island = lowerIslandExpr(lowerer, expr);
+        if (island !== null)
+            return island;
+    }
     // --external-types supplies CHECKER truth only. A value rooted in one
     // of those declarations has no runtime implementation in scriptc, so
     // every use fences at its expression instead of accidentally lowering
@@ -255,6 +267,12 @@ function lowerExprInner(lowerer, expr) {
             if (probe?.type.kind === "union")
                 return probe;
         }
+        const dereferenced = dereferencedElementReceiver(lowerer, expr, loc);
+        if (dereferenced)
+            return dereferenced;
+        const element = assertedElementOperand(lowerer, expr, loc);
+        if (element)
+            return element;
         const inner = lowerer.lowerExpr(expr.expression);
         if (inner.type.kind === "union") {
             // `!` performs no runtime check: a missing array element stays
@@ -351,7 +369,19 @@ function lowerExprInner(lowerer, expr) {
         // noImplicitThis, so the generic scope walk here is preflight-safe.
         const local = lowerer.resolveThis(expr);
         if (local) {
-            const value = { kind: "varRef", localId: local.id, type: local.type, loc };
+            let value = { kind: "varRef", localId: local.id, type: local.type, loc };
+            // `this` in a class declared `extends Array` is the array, except as
+            // the receiver of a member the class declares.
+            if (local.type.kind === "object") {
+                const arrayClass = lowerer.classes.get(local.type.className);
+                const parent = expr.parent;
+                if (arrayClass &&
+                    arrayRootOf(arrayClass) &&
+                    !(ts.isPropertyAccessExpression(parent) &&
+                        parent.expression === expr &&
+                        arrayClassMemberOwner(lowerer, parent) !== null))
+                    value = arrayOfClassInstance(arrayClass, value, loc);
+            }
             // `this.#x` in a function-local class's prototype method, whose `this`
             // is the call-site value: the field lives on the native instance of
             // this evaluation (checkedPrivateReceiver).
@@ -420,8 +450,25 @@ function lowerExprInner(lowerer, expr) {
         // any other super position (field reads, bare references) stays out.
         lowerer.unsupported("SC1090", expr, "'super' outside super() and super.method() calls");
     }
-    if (ts.isNewExpression(expr))
-        return lowerer.lowerNew(expr);
+    if (ts.isNewExpression(expr)) {
+        const value = lowerer.lowerNew(expr);
+        // `new X()` for a class declared `extends Array` is the array, except
+        // as the receiver of a member the class declares (as `this` above).
+        if (value.type.kind !== "object")
+            return value;
+        const arrayClass = lowerer.classes.get(value.type.className);
+        if (!arrayClass || !arrayRootOf(arrayClass))
+            return value;
+        let operand = expr;
+        while (ts.isParenthesizedExpression(operand.parent))
+            operand = operand.parent;
+        const parent = operand.parent;
+        if (ts.isPropertyAccessExpression(parent) &&
+            parent.expression === operand &&
+            arrayClassMemberOwner(lowerer, parent) !== null)
+            return value;
+        return arrayOfClassInstance(arrayClass, value, loc);
+    }
     if (ts.isAwaitExpression(expr)) {
         if (!lowerer.ctx.isAsync) {
             // A tsc-clean occurrence here is outside both an async function
@@ -460,8 +507,20 @@ function lowerExprInner(lowerer, expr) {
                         loc,
                     };
                 }
-                if (inner.kind === "union" || inner.kind === "dyn") {
-                    // A union inner would need an arm-wise re-tag into the result
+                if (inner.kind === "union") {
+                    // A UNION inner (`Promise<A | B> | undefined`): the awaited
+                    // result is the checker's own `Awaited` of the operand, which
+                    // the maybe-promise lowering already produces — it awaits the
+                    // narrowed promise arm and coerces its settled union, and the
+                    // unit arms keep JS's one-microtask hop. Only the promise-or-
+                    // unit shape reaches here, so the maybe-promise union is the
+                    // same union with its only data arms being units.
+                    const armed = promiseArmedUnionOf(lowerer, value.type);
+                    if (armed)
+                        return lowerMaybePromiseAwait(lowerer, expr, value, armed, loc);
+                    lowerer.unsupported("SC1090", expr, `awaiting '${lowerer.fmt(value.type)}' (the promise's inner type has no combined result union — await the promise arm after narrowing instead)`);
+                }
+                if (inner.kind === "dyn") {
                     lowerer.unsupported("SC1090", expr, `awaiting '${lowerer.fmt(value.type)}' (the promise's inner type has no combined result union — await the promise arm after narrowing instead)`);
                 }
                 let type;
@@ -808,13 +867,11 @@ function optionalStdlibParameter(lowerer, call, argument) {
 function assertionOperand(lowerer, expr, inner, target, loc) {
     if (inner.type.kind !== "union" || target === null || target.kind === "union")
         return null;
-    const arms = lowerer.unions.get(inner.type.unionId)?.arms;
-    if (!arms?.some(isUnitType) ||
-        !arms.every((arm) => arm.kind === "f64" || arm.kind === "string" || arm.kind === "bool" || isUnitType(arm)))
+    if (!scalarUnion(lowerer, inner.type.unionId))
         return null;
-    // Array element reads keep their own handling of a missing element. A
-    // typed-array read is optional here only where its use tells undefined
-    // from NaN (assertedReadObservesUndefined).
+    // Array element reads take assertedElementOperand or keep their own
+    // handling of a missing element. A typed-array read is optional here only
+    // where its use tells undefined from NaN (assertedReadObservesUndefined).
     let operand = expr.expression;
     while (ts.isParenthesizedExpression(operand))
         operand = operand.expression;
@@ -826,21 +883,469 @@ function assertionOperand(lowerer, expr, inner, target, loc) {
     const use = convertingUseOf(lowerer, expr);
     if (use === null)
         return null;
-    if (use === "value")
+    if (use === "value" || use === "string")
         return inner;
     return lowerPrimitiveUnionNumber(lowerer, inner, expr, loc);
 }
-/** How the converting use of `x!` (see assertionOperand) reads it:
- * "number" where the use applies ToNumber, "value" where the consumer
- * lowers the union itself (strings, equality, truthiness), null for other
+/** `xs[i]!` on an array as the operand of a converting use (see
+ * assertionOperand). The read answers undefined for a missing element, as
+ * in Node, instead of trapping: a numeric use reads NaN for it, and other
+ * uses get the optional element value. Returns null for other reads and
  * uses. */
+function assertedElementOperand(lowerer, expr, loc) {
+    let read = expr.expression;
+    while (ts.isParenthesizedExpression(read))
+        read = read.expression;
+    if (!ts.isElementAccessExpression(read) || read.questionDotToken)
+        return null;
+    // Plain arrays only: regex match results and other array subtypes keep
+    // their own element reads.
+    const receiverType = lowerer.typeOf(read.expression);
+    if (!lowerer.checker.isArrayType(receiverType) ||
+        lowerer.mapTypeOf(receiverType)?.kind !== "array")
+        return null;
+    // A counter below the length reads an existing index: the read keeps
+    // its plain element access.
+    if (lowerer.nanCodedReads?.counterIndexInBounds(read))
+        return null;
+    const target = lowerer.mapTypeOf(lowerer.typeOf(expr));
+    if (!target || !isScalarArm(target))
+        return null;
+    const use = convertingUseOf(lowerer, expr);
+    if (use === null)
+        return null;
+    if (use === "string" && target.kind === "string")
+        return stringElementOrUndefined(lowerer, read, loc);
+    const probe = lowerAbsenceProbe(lowerer, read);
+    if (probe?.type.kind !== "union" || !scalarUnion(lowerer, probe.type.unionId))
+        return null;
+    if (use === "value" || use === "string")
+        return probe;
+    return lowerer.stripUndefinedArm(probe.type).kind === "f64"
+        ? lowerOptionalNumber(lowerer, probe, loc)
+        : lowerPrimitiveUnionNumber(lowerer, probe, expr, loc);
+}
+/** `xs[i]!` on an array as the receiver of a member read
+ * (`xs[i]!.name`, `xs[i]!.size()`, `xs[i]![0]`). `!` performs no runtime
+ * check, so a missing element is undefined there and the member access
+ * throws Node's TypeError ("Cannot read properties of undefined (reading
+ * 'name')") instead of the bounds trap. The receiver is the element when it
+ * is present. A write (`xs[i]!.name = v`) is lowered as a statement by
+ * lowerDereferencedElementWrite, which evaluates the value before the
+ * receiver throws; elsewhere it keeps the bounds trap. Returns null for
+ * other reads and uses. */
+function dereferencedElementReceiver(lowerer, expr, loc) {
+    const use = runtimeOptionalUseOf(expr);
+    if (!use || isAssignmentTarget(use.access))
+        return null;
+    const parts = dereferencedElementParts(lowerer, expr, loc, false);
+    if (parts?.message == null)
+        return null;
+    const message = parts.message;
+    const value = {
+        kind: "ternary",
+        cond: parts.present,
+        then: parts.element,
+        else_: nodeTypeError(message, parts.element.type, loc),
+        type: parts.element.type,
+        loc,
+    };
+    return parts.stmts.length === 0
+        ? value
+        : { kind: "seqExpr", stmts: parts.stmts, result: value, type: value.type, loc };
+}
+/** The parts of a member access through `xs[i]!` (see
+ * dereferencedElementReceiver): statements that evaluate the array and the
+ * index, whether the element is present, the element read, and Node's
+ * TypeError message for a missing one. A `write` holds its key, so its
+ * message may be left for dereferencedElementWrite to build from the key. */
+export function dereferencedElementParts(lowerer, expr, loc, write) {
+    let read = expr.expression;
+    while (ts.isParenthesizedExpression(read))
+        read = read.expression;
+    if (!ts.isElementAccessExpression(read) || read.questionDotToken)
+        return null;
+    const receiverType = lowerer.typeOf(read.expression);
+    if (!lowerer.checker.isArrayType(receiverType) ||
+        lowerer.mapTypeOf(receiverType)?.kind !== "array")
+        return null;
+    if (lowerer.nanCodedReads?.counterIndexInBounds(read))
+        return null;
+    const use = runtimeOptionalUseOf(expr);
+    if (!use || use.optional || use.complex || use.comma || use.kind === "call")
+        return null;
+    // A write holds its key, so the message can name any number or string
+    // key (dereferencedElementWrite builds it).
+    const message = memberAccessMessage(lowerer, use.access) ??
+        (write && ts.isElementAccessExpression(use.access) && namedKey(lowerer, use.access)
+            ? null
+            : undefined);
+    if (message === undefined)
+        return null;
+    if (lowerer.mapTypeOf(lowerer.typeOf(read.argumentExpression))?.kind !== "f64")
+        return null;
+    // The element must already have the asserted type: an element union the
+    // assertion or a guard narrows keeps its checked narrow.
+    const target = lowerer.mapTypeOf(lowerer.typeOf(expr));
+    const declared = lowerer.mapTypeOf(receiverType);
+    if (!target ||
+        declared?.kind !== "array" ||
+        declared.elem.kind === "void" ||
+        !typeEquals(declared.elem, target))
+        return null;
+    const arr = lowerer.lowerExpr(read.expression);
+    if (arr.type.kind !== "array" || !typeEquals(arr.type.elem, target))
+        return null;
+    const elem = arr.type.elem;
+    const index = lowerer.lowerExprExpecting(read.argumentExpression, F64);
+    // Plain reads (a local, a field of one) evaluate once more instead of
+    // through a hidden local: the receiver then stays a borrowed element
+    // read, like the plain `xs[i]` it replaces. An index that can assign
+    // can replace the array binding or field (`xs[(xs = other, 0)]!`), so the
+    // array is held before it, as JavaScript reads it first.
+    const stmts = [];
+    const plain = (value) => isSafeToRepeat(value) || plainProjection(value);
+    const held = (value, name) => {
+        const tmp = lowerer.declareHiddenLocal(name, value.type);
+        stmts.push({ kind: "varDecl", localId: tmp.id, init: value, loc });
+        return varRef(tmp.id, value.type, loc);
+    };
+    const a = !mayAssign(index) && plain(arr) ? arr : held(arr, "%elementArray");
+    const i = plain(index) || repeatableIndex(index) ? index : held(index, "%elementIndex");
+    return {
+        stmts,
+        present: {
+            kind: "bin",
+            op: "===",
+            left: { kind: "arrayState", arr: a, index: i, type: F64, loc },
+            right: numLit(1, loc),
+            type: BOOL,
+            loc,
+        },
+        element: { kind: "arrayGet", arr: a, index: i, type: elem, loc },
+        message,
+    };
+}
+/** A write through `xs[i]!` (`xs[i]!.name = v`, `xs[i]![k] = v`): as in
+ * Node, the array, the index, the key and the value evaluate in order (the
+ * statements), then a missing element makes the write throw Node's
+ * TypeError and a present one takes the write, which reads the element,
+ * the key and the value through `overrides`. Null for other targets. */
+export function dereferencedElementWrite(lowerer, expr) {
+    if (expr.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+        return null;
+    const target = expr.left;
+    if (!(ts.isPropertyAccessExpression(target) || ts.isElementAccessExpression(target)) ||
+        target.questionDotToken ||
+        lowerer.chainRecvByNode.has(target.expression))
+        return null;
+    let receiver = target.expression;
+    while (ts.isParenthesizedExpression(receiver))
+        receiver = receiver.expression;
+    if (!ts.isNonNullExpression(receiver))
+        return null;
+    const loc = locOf(expr);
+    const keyValue = ts.isElementAccessExpression(target)
+        ? lowerer.lowerExpr(target.argumentExpression)
+        : null;
+    const rightValue = lowerer.lowerExpr(expr.right);
+    const parts = dereferencedElementParts(lowerer, receiver, loc, true);
+    if (parts === null)
+        return null;
+    const stmts = [...parts.stmts];
+    let present = parts.present;
+    let element = parts.element;
+    // JavaScript reads the element before the key and the value. When either
+    // has an effect, which can replace, remove or add the element, its
+    // presence and value are read first; otherwise the write tests and reads
+    // it after them.
+    if (!unobservable(rightValue) || (keyValue !== null && !unobservable(keyValue))) {
+        const presentLocal = lowerer.declareHiddenLocal("%elementPresent", BOOL);
+        // Assigned only when the element is present.
+        const elementLocal = declareContextLocal(lowerer.ctx, "%elementValue", element.type, true, undefined, undefined);
+        stmts.push({ kind: "varDecl", localId: presentLocal.id, init: present, loc }, { kind: "varDecl", localId: elementLocal.id, init: null, loc });
+        present = varRef(presentLocal.id, BOOL, loc);
+        stmts.push({
+            kind: "if",
+            cond: present,
+            then: [{ kind: "assign", localId: elementLocal.id, value: element, loc }],
+            else_: null,
+            loc,
+        });
+        element = varRef(elementLocal.id, element.type, loc);
+    }
+    const overrides = [];
+    // The write lowers the node with or without its parentheses.
+    const override = (node, value) => {
+        for (let n = node;; n = n.expression) {
+            overrides.push({ node: n, value });
+            if (!ts.isParenthesizedExpression(n))
+                break;
+        }
+    };
+    const held = (value, name, inline) => {
+        if (inline)
+            return value;
+        // A call without a result evaluates to undefined.
+        if (value.type.kind === "void") {
+            stmts.push({ kind: "exprStmt", expr: value, loc });
+            return { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc };
+        }
+        const tmp = lowerer.declareHiddenLocal(name, value.type);
+        stmts.push({ kind: "varDecl", localId: tmp.id, init: value, loc });
+        return varRef(tmp.id, value.type, loc);
+    };
+    override(target.expression, element);
+    let message = parts.message;
+    if (ts.isElementAccessExpression(target) && keyValue !== null) {
+        // The key evaluates before the value, which can assign the binding or
+        // field it reads; a literal, or an unobservable key the value cannot
+        // change, may evaluate in the write.
+        const key = held(keyValue, "%elementWriteKey", keyValue.kind === "numLit" ||
+            keyValue.kind === "strLit" ||
+            (unobservable(keyValue) && !mayAssign(rightValue)));
+        override(target.argumentExpression, key);
+        // The message names the key's value as the write evaluated it.
+        if (key !== keyValue || message === null)
+            message = keyMessage(messageHead(target), key, loc) ?? message;
+    }
+    // A value whose evaluation is unobservable may evaluate in the write
+    // itself, after the element is tested.
+    override(expr.right, held(rightValue, "%elementWriteValue", isSafeToRepeat(rightValue) || unobservable(rightValue)));
+    if (message === null)
+        return null;
+    return { stmts, present, message, overrides };
+}
+/** dereferencedElementWrite in value position (`f(xs[i]!.name = v)`). */
+export function lowerDereferencedElementAssignment(lowerer, expr) {
+    const write = dereferencedElementWrite(lowerer, expr);
+    if (write === null)
+        return null;
+    const loc = locOf(expr);
+    const value = lowerer.withExpressionOverrides(write.overrides, () => lowerer.lowerExpr(expr));
+    return {
+        kind: "seqExpr",
+        stmts: write.stmts,
+        result: {
+            kind: "ternary",
+            cond: write.present,
+            then: value,
+            else_: nodeTypeError(write.message, value.type, loc),
+            type: value.type,
+            loc,
+        },
+        type: value.type,
+        loc,
+    };
+}
+/** Whether evaluating `e` has no effect and cannot throw: a discardable
+ * expression, or the compiler's element-or-undefined read of one. */
+function unobservable(e) {
+    if (e.kind === "call" && e.callee.startsWith("%arr.idxOr."))
+        return e.args.every(unobservable);
+    return isSafeToDiscard(e);
+}
+/** Whether evaluating `e` can assign a binding or a field: it contains an
+ * assignment, an increment, statements, a suspension, or a call that can
+ * run program code (a library call only through a function it is given). */
+function mayAssign(e) {
+    switch (e.kind) {
+        case "call":
+            // The compiler's element-or-undefined read and union narrows run no
+            // program code.
+            if (!e.callee.startsWith("%arr.idxOr.") && !e.callee.startsWith("%union.narrow."))
+                return true;
+            break;
+        case "assignExpr":
+        case "incDec":
+        case "seqExpr":
+        case "callValue":
+        case "virtualCall":
+        case "dynCall":
+        case "dynInvoke":
+        case "ffiCall":
+        case "new":
+        case "newValue":
+        case "awaitExpr":
+        case "awaitUnionExpr":
+        case "yieldExpr":
+            return true;
+        case "closure":
+            return false;
+        case "libCall":
+            if (e.args.some((arg) => arg.type.kind === "func"))
+                return true;
+            break;
+    }
+    return !everyExprChild(e, (child) => !mayAssign(child), () => false);
+}
+/** Node's TypeError, thrown in place of a value of `type`. */
+export function nodeTypeError(message, type, loc) {
+    return {
+        kind: "libCall",
+        fn: "error.nodeThrow",
+        args: [numLit(1, loc), strLit("", loc), message],
+        type,
+        loc,
+    };
+}
+/** Whether `access` is the target of `=`. */
+function isAssignmentTarget(access) {
+    let outer = access;
+    while (ts.isParenthesizedExpression(outer.parent))
+        outer = outer.parent;
+    const parent = outer.parent;
+    return (ts.isBinaryExpression(parent) &&
+        parent.left === outer &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken);
+}
+/** A local, a number literal, or a field or record member read through a
+ * local: reading it again has no effect and yields the same value. */
+function plainProjection(e) {
+    if (e.kind === "varRef" || e.kind === "numLit")
+        return true;
+    return (e.kind === "fieldGet" || e.kind === "recordGet") && plainProjection(e.obj);
+}
+/** A number computed from plain reads, number literals and the lengths of
+ * arrays read through them (`xs.length - 1`): evaluating it again, with
+ * nothing in between, has no effect and yields the same value. An element
+ * read through `xs[xs.length - 1]!` then evaluates its index twice instead
+ * of holding it in a hidden local, and stays a borrowed element read. */
+function repeatableIndex(e) {
+    if (e.type.kind !== "f64")
+        return false;
+    switch (e.kind) {
+        case "numLit":
+        case "varRef":
+        case "fieldGet":
+        case "recordGet":
+            return plainProjection(e);
+        case "bin":
+            return repeatableIndex(e.left) && repeatableIndex(e.right);
+        case "unary":
+            return repeatableIndex(e.operand);
+        case "arrIntrinsic":
+            return e.method === "length" && e.args.length === 0 && plainProjection(e.receiver);
+        default:
+            return false;
+    }
+}
+/** Node's TypeError message for a member access on undefined: reading the
+ * member, or setting it when the access is the target of `=`. Null when
+ * the key is not a name, a literal, or a plain read of a number or string
+ * (which the message reads a second time). */
+function memberAccessMessage(lowerer, access) {
+    const head = messageHead(access);
+    const loc = locOf(access);
+    if (ts.isPropertyAccessExpression(access)) {
+        if (ts.isPrivateIdentifier(access.name))
+            return null;
+        return strLit(`${head}${access.name.text}')`, loc);
+    }
+    if (!ts.isElementAccessExpression(access))
+        return null;
+    const key = runtimeOptionalElementKey(access.argumentExpression);
+    if (key !== null)
+        return strLit(`${head}${key}')`, loc);
+    let keyNode = access.argumentExpression;
+    while (ts.isParenthesizedExpression(keyNode))
+        keyNode = keyNode.expression;
+    if (!ts.isIdentifier(keyNode))
+        return null;
+    const keyType = lowerer.mapTypeOf(lowerer.typeOf(keyNode))?.kind;
+    if (keyType !== "f64" && keyType !== "string")
+        return null;
+    const keyValue = lowerer.lowerExpr(keyNode);
+    if (!isSafeToRepeat(keyValue) || keyValue.type.kind !== keyType)
+        return null;
+    return keyMessage(head, keyValue, loc);
+}
+/** The start of Node's TypeError message for a member access on undefined:
+ * setting the member when the access is the target of `=`, else reading
+ * it. */
+function messageHead(access) {
+    return isAssignmentTarget(access)
+        ? "Cannot set properties of undefined (setting '"
+        : "Cannot read properties of undefined (reading '";
+}
+/** Whether `access`'s key is typed a number or a string, which the message
+ * can name from its value. */
+function namedKey(lowerer, access) {
+    const kind = lowerer.mapTypeOf(lowerer.typeOf(access.argumentExpression))?.kind;
+    return kind === "f64" || kind === "string";
+}
+/** The message naming a key from its value (a number or a string), or null
+ * for another type. */
+function keyMessage(head, key, loc) {
+    if (key.type.kind !== "f64" && key.type.kind !== "string")
+        return null;
+    const text = key.type.kind === "string" ? key : { kind: "toString", operand: key, type: STRING, loc };
+    const concat = (left, right) => ({
+        kind: "strConcat",
+        left,
+        right,
+        type: STRING,
+        loc,
+    });
+    return concat(concat(strLit(head, loc), text), strLit("')", loc));
+}
+/** A string array's element converted to a string: the element, or
+ * "undefined" for a missing index or a hole. */
+function stringElementOrUndefined(lowerer, read, loc) {
+    if (lowerer.mapTypeOf(lowerer.typeOf(read.argumentExpression))?.kind !== "f64")
+        return null;
+    const arr = lowerer.lowerExpr(read.expression);
+    if (arr.type.kind !== "array" || arr.type.elem.kind !== "string")
+        return null;
+    const index = lowerer.lowerExprExpecting(read.argumentExpression, F64);
+    const stmts = [];
+    const held = (value, name) => {
+        const tmp = lowerer.declareHiddenLocal(name, value.type);
+        stmts.push({ kind: "varDecl", localId: tmp.id, init: value, loc });
+        return varRef(tmp.id, value.type, loc);
+    };
+    // An index that can assign can replace the array binding or field, so
+    // the array is held before it, as JavaScript reads it first.
+    const a = !mayAssign(index) && isSafeToRepeat(arr) ? arr : held(arr, "%elementArray");
+    const i = isSafeToRepeat(index) ? index : held(index, "%elementIndex");
+    const value = {
+        kind: "ternary",
+        cond: {
+            kind: "bin",
+            op: "===",
+            left: { kind: "arrayState", arr: a, index: i, type: F64, loc },
+            right: numLit(1, loc),
+            type: BOOL,
+            loc,
+        },
+        then: { kind: "arrayGet", arr: a, index: i, type: STRING, loc },
+        else_: strLit("undefined", loc),
+        type: STRING,
+        loc,
+    };
+    return stmts.length === 0 ? value : { kind: "seqExpr", stmts, result: value, type: STRING, loc };
+}
+function isScalarArm(arm) {
+    return arm.kind === "f64" || arm.kind === "string" || arm.kind === "bool" || isUnitType(arm);
+}
+/** A union of numbers, strings, booleans, null and undefined with at least
+ * one unit arm. */
+function scalarUnion(lowerer, unionId) {
+    const arms = lowerer.unions.get(unionId)?.arms;
+    return !!arms?.some(isUnitType) && arms.every(isScalarArm);
+}
+/** How the converting use of `x!` (see assertionOperand) reads it:
+ * "number" where the use applies ToNumber, "string" where it converts the
+ * value to a string (a template span, `+` with a string), "value" where the
+ * consumer lowers the union itself (equality, truthiness, a comparison with
+ * a string), null for other uses. */
 function convertingUseOf(lowerer, expr) {
     let outer = expr;
     while (ts.isParenthesizedExpression(outer.parent))
         outer = outer.parent;
     const parent = outer.parent;
     if (ts.isTemplateSpan(parent))
-        return parent.expression === outer ? "value" : null;
+        return parent.expression === outer ? "string" : null;
     if (ts.isTypeOfExpression(parent))
         return "value";
     if (ts.isPrefixUnaryExpression(parent)) {
@@ -879,7 +1384,7 @@ function convertingUseOf(lowerer, expr) {
         while (ts.isParenthesizedExpression(partner))
             partner = partner.expression;
         if (isString(other))
-            return ts.isNonNullExpression(partner) ? null : "value";
+            return ts.isNonNullExpression(partner) ? null : "string";
         if (!numericPartner(lowerer.typeOf(other)))
             return "value";
         return isString(expr) ? null : "number";
@@ -959,7 +1464,8 @@ function assertedCalleeMessage(expr, target) {
  * holds a missing element (see assertedElementKeepsUndefined) other than a
  * return, whose slot has the function's number type. */
 export function assertedReadObservesUndefined(lowerer, node) {
-    if (convertingUseOf(lowerer, node) === "value")
+    const use = convertingUseOf(lowerer, node);
+    if (use === "value" || use === "string")
         return true;
     let outer = node;
     while (ts.isParenthesizedExpression(outer.parent))
@@ -1661,6 +2167,21 @@ export function lowerAbsenceProbe(lowerer, node) {
         if (shape && !shape.tuple && shape.indexValue && shape.indexValue.kind !== "dyn") {
             return lowerer.lowerRecordKeyRead(expr, receiverT.shapeId, shape, true);
         }
+        // A literal key the shape does not declare is absent from every value
+        // (lowerRecordKeyRead answers undefined), whatever type the checker gave
+        // the read. An optional chain keeps its own lowering, which reads a
+        // nullish receiver as undefined instead of converting it.
+        const literal = recordKeyLiteralText(expr.argumentExpression);
+        if (!expr.questionDotToken &&
+            !hasOptionalChainGuard(expr.expression) &&
+            shape &&
+            !shape.tuple &&
+            !shape.indexValue &&
+            literal !== null &&
+            !OBJECT_PROTOTYPE_MEMBERS.has(literal) &&
+            !shape.fields.some((field) => field.name === literal)) {
+            return lowerer.lowerRecordKeyRead(expr, receiverT.shapeId, shape, true);
+        }
         return null;
     }
     // `m[2]` on a JavaScript `RegExpExecArray | null` that a previous
@@ -2026,6 +2547,7 @@ export function typeofAnswer(arm) {
         case "url":
         case "searchParams":
         case "stats":
+        case "bigintStats":
         case "fileHandle":
         case "dir":
         case "spawnRes":
@@ -2733,11 +3255,9 @@ export function symbolFieldInfo(lowerer, expr) {
     const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
     if (receiverIr?.kind !== "object")
         return null;
-    const info = lowerer.classes.get(receiverIr.className);
-    if (!info) {
-        lowerer.flushDeferredClass(receiverIr.className);
+    const info = lowerer.classes.get(receiverIr.className) ?? lowerer.flushDeferredClass(receiverIr.className);
+    if (!info)
         return null;
-    }
     const key = classSymbolKeyOf(lowerer, expr.argumentExpression);
     if (!key)
         return null;