@scriptc/compiler 0.3.0 → 0.3.2

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

@@ -1,8 +1,10 @@
 import { generatorDrain } from "./iterator-adapters.js";
+import { lowerEventStaticProperty } from "./builtins/numbers.js";
 import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js";
 import { isOptionalProcessStreamProperty } from "./builtins/process.js";
 import { lowerWorkerMetadata } from "./builtins/workers.js";
 import { threadsImportOf } from "../threads-import.js";
+import { experimentalImportOf, lifetimeRegionMemberOf } from "../experimental-import.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
 import { SYMBOL_T } from "../../ir/ir.js";
@@ -31,7 +33,7 @@ import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstO
 import { UNSUPPORTED, blockedBindingUseDiag, unsupportedPackageValueDiag, unsupportedDiag, } from "../../diagnostics/diagnostic.js";
 import { PoisonError, dynFallbackType, jsFuncNameOf, neverTaintedJsType, own } from "./lowerer.js";
 import { lowerCollectionSpread } from "./containers/collection-methods.js";
-import { arrayValueRead, arrayValueStore, arrayValueType, lowerSafeIndexRead, tryLowerIndexTruthiness, tryLowerNumericIndexRead, lowerSafeBytesRead, } from "./array-values.js";
+import { arrayNumberRead, arrayValueRead, arrayValueStore, arrayValueType, lowerSafeIndexRead, tryLowerIndexTruthiness, tryLowerNumericIndexRead, tryLowerBytesReadNumberEquality, lowerSafeBytesRead, } from "./array-values.js";
 import { strCharsCall } from "./containers/array-construction.js";
 import { lowerOptionalStringIndex } from "./string-index.js";
 import { tryLowerIndexedComparison } from "./indexed-comparison.js";
@@ -48,8 +50,8 @@ import { funcTypeFromParamShapes } from "./call-signatures.js";
 import { implicitMonoFile, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver, } from "./generic-functions.js";
 import { lowerTaggedTemplate } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
-import { isConstAssertionTypeNode, isGenericCallableMemberType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion, withUnitArm, } from "../type-mapper.js";
-import { lowerYield } from "./lower-generators.js";
+import { isConstAssertionTypeNode, isGenericCallableMemberType, isOsConstantsType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion, withUnitArm, } from "../type-mapper.js";
+import { iteratorResultValueRead, lowerYield } from "./lower-generators.js";
 import { errorPropertyRead, errorPropertyWrite, errorToStringCall } from "./error-methods.js";
 import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "./lower-stream.js";
 import { unionWideningTags } from "../../ir/analysis.js";
@@ -731,7 +733,9 @@ function lowerExprInner(lowerer, expr) {
                     lowerer.unions.get(g.type.unionId)?.arms.length === 2 &&
                     lowerer.unions.get(g.type.unionId).arms.some((a) => a.kind === "f64") &&
                     lowerer.unions.get(g.type.unionId).arms.some((a) => a.kind === "string");
+                const symbol = lowerer.resolveValueSymbol(expr);
                 if (!arithmeticUnion &&
+                    !(symbol !== null && lowerer.earlyReadVars.has(symbol)) &&
                     g.type.kind === "union" &&
                     narrowed &&
                     narrowed.kind !== "union" &&
@@ -849,6 +853,8 @@ function lowerExprInner(lowerer, expr) {
                 return { kind: "boolLit", value: true, type: BOOL, loc };
             if (member === "publish")
                 lowerer.noLowering("publish (@scriptc/threads) as a value", expr, "call publish(value) directly");
+            if (experimentalImportOf(lowerer.program, expr) === "LifetimeRegion")
+                lowerer.noLowering("LifetimeRegion (@scriptc/experimental) as a value", expr, "construct regions with new LifetimeRegion()");
         }
         {
             const bi = lowerer.builtinImportOf(expr);
@@ -872,6 +878,9 @@ function lowerExprInner(lowerer, expr) {
                 if (bi.module === "http" && bi.member === "STATUS_CODES") {
                     return { kind: "libCall", fn: "http.statusCodes", args: [], type: DYN, loc };
                 }
+                if (bi.module === "os" && bi.member === "constants") {
+                    return { kind: "libCall", fn: "os.constants", args: [], type: DYN, loc };
+                }
                 // tls.rootCertificates: a runtime-valued module constant (the
                 // cached bundled-CA array) — the one member read that lowers
                 // to a libCall instead of a baked literal.
@@ -1413,6 +1422,11 @@ function lowerExprInner(lowerer, expr) {
     if (ts.isConditionalExpression(expr))
         return lowerTernary(lowerer, expr);
     if (ts.isPropertyAccessExpression(expr)) {
+        {
+            const member = lifetimeRegionMemberOf(lowerer.program, expr, lowerer.experimentalFiles);
+            if (member !== null)
+                lowerer.noLowering(`LifetimeRegion.${member} (@scriptc/experimental) as a value`, expr, `call region.${member}(${member === "run" ? "fn" : ""}) directly`);
+        }
         // Expando statics may still be absent even when JS inference sees
         // the eventual assignment's scalar type. Preserve the checked value.
         const staticField = lowerStaticFieldRead(lowerer, expr);
@@ -1809,6 +1823,7 @@ function lowerExprInner(lowerer, expr) {
             lowerer.lowerJsonProperty(expr) ??
             lowerer.lowerErrorCodeProperty(expr) ??
             lowerer.lowerNumberStaticProperty(expr) ??
+            lowerEventStaticProperty(lowerer, expr) ??
             lowerer.lowerMathProperty(expr) ??
             lowerer.lowerIntrinsicProperty(expr) ??
             // The _readableState/_writableState scalar READS (the suite's
@@ -1831,7 +1846,7 @@ function lowerExprInner(lowerer, expr) {
             // 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);
+            return iteratorResultValueRead(lowerer, handled, expr) ?? lowerer.maybeNarrow(handled, expr);
         }
         // `globalThis.<name>` that no lowering above claimed
         // (globalThis.crypto, globalThis.SubtleCrypto, globalThis.localStorage
@@ -2021,14 +2036,15 @@ function lowerExprInner(lowerer, expr) {
                     const shape = lowerer.shapes.get(recv.type.shapeId);
                     const field = shape?.fields.find((f) => f.name === expr.name.text);
                     if (field) {
-                        return lowerer.maybeNarrow({
+                        const read = {
                             kind: "recordGet",
                             obj: recv,
                             shapeId: recv.type.shapeId,
                             field: field.name,
                             type: field.type,
                             loc,
-                        }, expr);
+                        };
+                        return iteratorResultValueRead(lowerer, read, expr) ?? lowerer.maybeNarrow(read, expr);
                     }
                 }
             }
@@ -2055,9 +2071,14 @@ function lowerExprInner(lowerer, expr) {
         const segmentDataProperty = segmentDataSymbol?.name === "SegmentData" &&
             lowerer.isStdlibSymbol(segmentDataSymbol) &&
             ["segment", "index", "input", "isWordLike"].includes(expr.name.text);
+        // os.constants members vary by platform (the declared groups list
+        // every platform's names): a number member reads as `number |
+        // undefined`, like an array element, and a group stays checked.
+        const osConstants = isOsConstantsType(lowerer.typeOf(expr.expression), lowerer);
         if (isParseArgsDynProperty(lowerer, expr) ||
             isStatFsDynProperty(lowerer, expr) ||
-            segmentDataProperty) {
+            segmentDataProperty ||
+            osConstants) {
             const recv = lowerer.lowerExpr(expr.expression);
             if (recv.type.kind === "dyn") {
                 const key = {
@@ -2067,14 +2088,20 @@ function lowerExprInner(lowerer, expr) {
                     loc: locOf(expr.name),
                 };
                 const opt = hasOptionalChainGuard(expr.expression);
-                return lowerer.maybeNarrow({
+                const read = {
                     kind: "dynKeyGet",
                     key,
                     ...(opt ? { optional: true } : {}),
                     value: recv,
                     type: DYN,
                     loc,
-                }, expr);
+                };
+                if (osConstants) {
+                    return lowerer.mapTypeOf(lowerer.typeOf(expr))?.kind === "f64"
+                        ? lowerer.coerceToExpected(read, lowerer.withUndefinedArm(F64))
+                        : read;
+                }
+                return lowerer.maybeNarrow(read, expr);
             }
         }
         // A member read through a NULLISH generic binding (`const i: I<A &
@@ -2772,6 +2799,9 @@ export function maybeNarrow(lowerer, expr, node) {
         if (symbol && lowerer.unstableSwitchBindings.has(symbol))
             return expr;
     }
+    if (ts.isPropertyAccessExpression(node) &&
+        getterResultHoldsUndeclaredUndefined(lowerer, node, expr))
+        return expr;
     const narrowedTs = lowerer.typeOf(node);
     const narrowed = lowerer.mapTypeOf(narrowedTs);
     // `Array.isArray(u)` on a union with one readonly array/tuple arm: the
@@ -2880,6 +2910,27 @@ export function maybeNarrow(lowerer, expr, node) {
         loc: expr.loc,
     };
 }
+/** A getter read whose runtime result can be undefined (an unchecked
+ * element read in its body, or in another member of its override family)
+ * although its declared type cannot. The checker's type for the read is
+ * then no narrowing proof, so the read keeps the getter's result. */
+function getterResultHoldsUndeclaredUndefined(lowerer, node, expr) {
+    if (expr.type.kind !== "union" || lowerer.armTag(expr.type.unionId, UNDEFINED_T) < 0)
+        return false;
+    const getter = (expr.kind === "virtualCall" && expr.method.startsWith("get:")) ||
+        (expr.kind === "call" && expr.callee.includes(".get:"));
+    if (!getter)
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(node.name);
+    if (!symbol || (symbol.flags & ts.SymbolFlags.GetAccessor) === 0)
+        return false;
+    const declared = lowerer.checker.getTypeOfSymbol(symbol);
+    const holdsUndefined = (type) => (type.flags &
+        (ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !==
+        0;
+    return !(holdsUndefined(declared) ||
+        (declared.isUnionType() && ts.constituentTypes(declared).some(holdsUndefined)));
+}
 /** 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
@@ -6330,7 +6381,13 @@ export function lowerElementCompound(lowerer, expr, op) {
     const receiverRef = () => varRef(receiverLocal.id, receiver.type, loc);
     const indexRef = () => varRef(indexLocal.id, F64, loc);
     const oldValue = receiver.type.kind === "array"
-        ? arrayValueRead(lowerer, receiverRef(), indexRef(), receiver.type.elem, locOf(target))
+        ? receiver.type.elem.kind === "f64"
+            ? // Every numeric operator applies ToNumber to the old value, so a
+                // missing element is NaN without materializing `number | undefined`.
+                arrayNumberRead(receiverRef(), indexRef(), locOf(target))
+            : receiver.type.elem.kind === "string" && op === "+"
+                ? arrayStringOperand(receiverRef(), indexRef(), locOf(target))
+                : arrayValueRead(lowerer, receiverRef(), indexRef(), receiver.type.elem, locOf(target))
         : {
             // An invalid index reads undefined in Node, which every numeric
             // compound operator turns into NaN; the write is then ignored.
@@ -6407,6 +6464,25 @@ export function lowerElementCompound(lowerer, expr, op) {
         loc,
     };
 }
+/** ToString of one stabilized `string[]` element read for `+=`: a missing
+ * element concatenates as "undefined". */
+function arrayStringOperand(arr, index, loc) {
+    return {
+        kind: "ternary",
+        cond: {
+            kind: "bin",
+            op: "===",
+            left: { kind: "arrayState", arr, index, type: F64, loc },
+            right: { kind: "numLit", value: 1, type: F64, loc },
+            type: BOOL,
+            loc,
+        },
+        then: { kind: "arrayGet", arr, index, type: STRING, loc },
+        else_: strLit("undefined", loc),
+        type: STRING,
+        loc,
+    };
+}
 /** Checked member assignment evaluates the reference before its RHS and
  * yields the original assigned value, including in a chained assignment. */
 function lowerDynMemberAssignment(lowerer, expr, recv) {
@@ -7443,6 +7519,13 @@ export function lowerIncDec(lowerer, expr, prefix) {
             return varRef(local.id, value.type, loc);
         };
         const finish = (read, write) => {
+            if (read.type.kind === "bigint") {
+                const old = save(read, "%incrementOld");
+                const next = save(bigintStep(op, old, loc), "%incrementNext");
+                stmts.push(write(next));
+                const result = prefix ? next : old;
+                return { kind: "seqExpr", stmts, result, type: result.type, loc };
+            }
             const old = save(read.type.kind === "f64"
                 ? read
                 : {
@@ -7486,7 +7569,9 @@ export function lowerIncDec(lowerer, expr, prefix) {
                 lowerer.unsupported("SC1090", access, "incrementing non-number array keys");
             const type = raw.type;
             const read = type.kind === "array"
-                ? arrayValueRead(lowerer, receiver, index, type.elem, loc)
+                ? type.elem.kind === "f64"
+                    ? arrayNumberRead(receiver, index, loc)
+                    : arrayValueRead(lowerer, receiver, index, type.elem, loc)
                 : {
                     kind: "bytesIntrinsic",
                     method: "get",
@@ -7633,6 +7718,26 @@ export function lowerIncDecTarget(lowerer, expr, target, prefix) {
             };
         }
     }
+    if (target.type.kind === "bigint") {
+        const old = lowerer.declareHiddenLocal("%bigintOld", BIGINT_T);
+        const next = lowerer.declareHiddenLocal("%bigintNext", BIGINT_T);
+        return {
+            kind: "seqExpr",
+            stmts: [
+                { kind: "varDecl", localId: old.id, init: varRef(target.id, BIGINT_T, loc), loc },
+                {
+                    kind: "varDecl",
+                    localId: next.id,
+                    init: bigintStep(op, varRef(old.id, BIGINT_T, loc), loc),
+                    loc,
+                },
+                { kind: "assign", localId: target.id, value: varRef(next.id, BIGINT_T, loc), loc },
+            ],
+            result: varRef(prefix ? next.id : old.id, BIGINT_T, loc),
+            type: BIGINT_T,
+            loc,
+        };
+    }
     if (target.type.kind !== "f64")
         lowerer.unsupported("SC1043", expr);
     return { kind: "incDec", op, prefix, localId: target.id, type: F64, loc };
@@ -7663,6 +7768,43 @@ function seqExprSafeStmt(s) {
             return false;
     }
 }
+const BIGINT_COMPOUND = {
+    "+": "bigint.add",
+    "-": "bigint.sub",
+    "*": "bigint.mul",
+    "/": "bigint.div",
+    "%": "bigint.mod",
+    "**": "bigint.pow",
+    "&": "bigint.and",
+    "|": "bigint.or",
+    "^": "bigint.xor",
+    "<<": "bigint.shl",
+    ">>": "bigint.shr",
+};
+/** `old op= rhs` over two bigints: the binary operator's libCall. Null
+ * for other operand types (and `>>>`, which BigInt does not have). */
+function bigintCompoundValue(op, left, right, loc) {
+    if (left.type.kind !== "bigint" || right.type.kind !== "bigint" || op === ">>>")
+        return null;
+    return { kind: "libCall", fn: BIGINT_COMPOUND[op], args: [left, right], type: BIGINT_T, loc };
+}
+/** `++`/`--` on a bigint value: old ± 1n. */
+function bigintStep(op, old, loc) {
+    const one = {
+        kind: "libCall",
+        fn: "bigint.parse",
+        args: [{ kind: "strLit", value: "1", type: STRING, loc }],
+        type: BIGINT_T,
+        loc,
+    };
+    return {
+        kind: "libCall",
+        fn: op === "+" ? "bigint.add" : "bigint.sub",
+        args: [old, one],
+        type: BIGINT_T,
+        loc,
+    };
+}
 export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
     const loc = locOf(expr);
     const read = {
@@ -7706,6 +7848,9 @@ export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
         };
         return lowerer.coerceInto(expr, computed, target.type);
     }
+    const bigint = bigintCompoundValue(compound, read, rhs, loc);
+    if (bigint)
+        return bigint;
     lowerer.unsupported("SC1043", expr);
 }
 /** Equality of two NaN-coded values (nan-coded-reads.ts), each of which may
@@ -8075,6 +8220,16 @@ export function lowerBinary(lowerer, expr) {
             left = storedLeft;
         if (storedRight !== null && left.type.kind !== "union")
             right = storedRight;
+        // A typed-array read compared with a plain number needs no
+        // `number | undefined` box.
+        const fusedLeft = tryLowerBytesReadNumberEquality(lowerer, left, right, expr.right);
+        if (fusedLeft)
+            left = fusedLeft;
+        else {
+            const fusedRight = tryLowerBytesReadNumberEquality(lowerer, right, left, expr.left);
+            if (fusedRight)
+                right = fusedRight;
+        }
     }
     if (strictEquality && (left.type.kind === "caught" || right.type.kind === "caught")) {
         if (left.type.kind === "caught")
@@ -10012,6 +10167,14 @@ export function lowerInstanceOf(lowerer, expr, loc) {
         const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
         return { kind: "libCall", fn: "dyn.dataViewIs", args: [value], type: BOOL, loc };
     }
+    {
+        const eventKind = ["Event", "CustomEvent", "EventTarget"].findIndex((name) => lowerer.isStdlibGlobal(expr.right, name));
+        if (eventKind >= 0) {
+            const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
+            const kind = { kind: "numLit", value: eventKind, type: F64, loc };
+            return { kind: "libCall", fn: "event.is", args: [value, kind], type: BOOL, loc };
+        }
+    }
     if (lowerer.isStdlibGlobal(expr.right, "SharedArrayBuffer")) {
         const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
         return { kind: "libCall", fn: "sharedArrayBuffer.is", args: [value], type: BOOL, loc };
@@ -10211,7 +10374,12 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                 lowerer.isSubclassOf(left.type.className, targetInfo.def.name);
             if (left.kind === "varRef" &&
                 (ts.isIdentifier(expr.right) || expr.right.kind === ts.SyntaxKind.ThisKeyword)) {
-                return { kind: "boolLit", value, type: BOOL, loc };
+                return readsClassAfter(lowerer, targetInfo, expr.right, [], {
+                    kind: "boolLit",
+                    value,
+                    type: BOOL,
+                    loc,
+                });
             }
             lowerer.unsupported("SC1090", expr, "statically-decided 'instanceof' on computed operands (bind the values to variables first)");
         }
@@ -10361,13 +10529,12 @@ export function lowerInstanceOf(lowerer, expr, loc) {
         }
     }
     if (left.type.kind !== "object") {
-        return {
-            kind: "seqExpr",
-            stmts: [{ kind: "exprStmt", expr: left, loc }],
-            result: { kind: "boolLit", value: false, type: BOOL, loc },
+        return readsClassAfter(lowerer, target, expr.right, [{ kind: "exprStmt", expr: left, loc }], {
+            kind: "boolLit",
+            value: false,
             type: BOOL,
             loc,
-        };
+        });
     }
     const lhsInfo = lowerer.classes.get(left.type.className);
     if (!lhsInfo)
@@ -10378,10 +10545,33 @@ export function lowerInstanceOf(lowerer, expr, loc) {
     const value = left.type.className === target.def.name ||
         lowerer.isSubclassOf(left.type.className, target.def.name);
     if (left.kind === "varRef") {
-        return { kind: "boolLit", value, type: BOOL, loc };
+        return readsClassAfter(lowerer, target, expr.right, [], {
+            kind: "boolLit",
+            value,
+            type: BOOL,
+            loc,
+        });
     }
     lowerer.unsupported("SC1090", expr, "statically-decided 'instanceof' on computed operands (bind the value to a variable first)");
 }
+/** A statically decided `instanceof` still reads its class after the left
+ * operand: a class with an initialization flag throws there before its
+ * declaration ran. */
+function readsClassAfter(lowerer, target, right, stmts, result) {
+    if (!lowerer.classInitFlags.has(target.def.name)) {
+        if (stmts.length === 0)
+            return result;
+        return { kind: "seqExpr", stmts, result, type: result.type, loc: result.loc };
+    }
+    const read = lowerer.lowerExpr(right);
+    return {
+        kind: "seqExpr",
+        stmts: [...stmts, { kind: "exprStmt", expr: read, loc: locOf(right) }],
+        result,
+        type: result.type,
+        loc: result.loc,
+    };
+}
 /** `#name in obj` — the ergonomic brand check. In this closed world a
  * brand is held by exactly the instances of the declaring class
  * (subclasses included — construction always runs the declaring class's
@@ -10535,11 +10725,27 @@ function lowerPrivateIn(lowerer, expr, priv, loc) {
         return { kind: "boolLit", value, type: BOOL, loc };
     lowerer.unsupported("SC1090", expr, `statically-decided '${pname} in …' on computed operands (bind the value to a variable first)`);
 }
+/** The string keys every record inherits from Object.prototype. */
+const OBJECT_PROTOTYPE_KEYS = new Set([
+    "constructor",
+    "__defineGetter__",
+    "__defineSetter__",
+    "hasOwnProperty",
+    "__lookupGetter__",
+    "__lookupSetter__",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+    "toString",
+    "valueOf",
+    "__proto__",
+    "toLocaleString",
+]);
 /** `"key" in v` — the key-presence test. Three lowered receivers:
  * process.env (getenv(3) presence — Node-exact, an empty value still
  * counts as present), and monomorphic record shapes, where the answer is
  * type-directed: a declared non-optional field is a compile-time `true`,
- * a missing field (no index signature) a compile-time `false` — both
+ * a missing field (no index signature) a compile-time `false` unless
+ * Object.prototype has it — both
  * folds limited to side-effect-free receivers, the lowerInstanceOf rule —
  * and an OPTIONAL field (undefined-armed union) is a runtime presence
  * test on the slot: an omitted or deleted property is absent, while a
@@ -10789,7 +10995,11 @@ function lowerInExpression(lowerer, expr, loc) {
                 break;
             }
             const f = shape.fields.find((x) => x.name === key);
-            if (f && f.type.kind === "union" && lowerer.armTag(f.type.unionId, UNDEFINED_T) >= 0) {
+            const inherited = OBJECT_PROTOTYPE_KEYS.has(key);
+            if (f &&
+                !inherited &&
+                f.type.kind === "union" &&
+                lowerer.armTag(f.type.unionId, UNDEFINED_T) >= 0) {
                 staticAnswers = false; // an optional slot: presence is per-value
                 break;
             }
@@ -10797,7 +11007,7 @@ function lowerInExpression(lowerer, expr, loc) {
             // true without invoking the getter) — either slot present makes
             // the name a member.
             const acc = shape.fields.some((x) => x.name === `%get:${key}` || x.name === `%set:${key}`);
-            answers.push({ tag, has: f !== undefined || acc });
+            answers.push({ tag, has: f !== undefined || acc || inherited });
         }
         if (staticAnswers) {
             const pureRecv = recv.kind === "varRef" ||
@@ -10865,7 +11075,9 @@ function lowerInExpression(lowerer, expr, loc) {
         throw new InternalCompilerError(`lowerer bug: unknown shape ${recv.type.shapeId}`);
     const field = shape.fields.find((f) => f.name === key);
     if (field) {
-        if (field.type.kind === "union" && lowerer.armTag(field.type.unionId, UNDEFINED_T) >= 0) {
+        if (!OBJECT_PROTOTYPE_KEYS.has(key) &&
+            field.type.kind === "union" &&
+            lowerer.armTag(field.type.unionId, UNDEFINED_T) >= 0) {
             // Optional slot: the key is present unless the field is absent
             // (omitted or deleted); an explicit undefined is present.
             return lowerer.recordFieldPresent(recv, recv.type.shapeId, key, loc);
@@ -10893,14 +11105,16 @@ function lowerInExpression(lowerer, expr, loc) {
         }
         lowerer.unsupported("SC1090", expr, "statically-decided 'in' on computed receivers (bind the value to a variable first)");
     }
-    if (shape.indexValue) {
+    // Records are ordinary objects: Object.prototype's members are in them.
+    const inherited = OBJECT_PROTOTYPE_KEYS.has(key);
+    if (shape.indexValue && !inherited) {
         lowerer.unsupported("SC1090", expr, "'in' over index-signature keys (read the key and test '!== undefined' instead)");
     }
     if (recv.kind === "varRef" ||
         recv.kind === "recordGet" ||
         recv.kind === "fieldGet" ||
         pureRecvNode) {
-        return { kind: "boolLit", value: false, type: BOOL, loc };
+        return { kind: "boolLit", value: inherited, type: BOOL, loc };
     }
     lowerer.unsupported("SC1090", expr, "statically-decided 'in' on computed receivers (bind the value to a variable first)");
 }
@@ -10953,7 +11167,36 @@ function lowerRuntimeKeyIn(lowerer, expr, loc) {
         // Overflow keys answer through the map's hashed presence probe (a
         // stored undefined value is still present), not a scan over a fresh
         // key snapshot, which made `k in dict` loops quadratic.
-        body.push(ret({ kind: "recordOvfHas", obj: r, shapeId: recvT.shapeId, key: k, type: BOOL, loc }));
+        const ovfHas = {
+            kind: "recordOvfHas",
+            obj: r,
+            shapeId: recvT.shapeId,
+            key: k,
+            type: BOOL,
+            loc,
+        };
+        // A miss in the record's own keys still finds Object.prototype's.
+        let inherited = ovfHas;
+        for (const name of OBJECT_PROTOTYPE_KEYS) {
+            if (shape.fields.some((f) => f.name === name))
+                continue;
+            inherited = {
+                kind: "logical",
+                op: "||",
+                left: inherited,
+                right: {
+                    kind: "strEq",
+                    negated: false,
+                    left: k,
+                    right: { kind: "strLit", value: name, type: STRING, loc },
+                    type: BOOL,
+                    loc,
+                },
+                type: BOOL,
+                loc,
+            };
+        }
+        body.push(ret(inherited));
         lowerer.liftedFns.push({
             name: helper,
             params: [
@@ -12866,6 +13109,7 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
         : lowerOptionalNumber(lowerer, rhs, loc);
     let value;
     const numericRead = lowerOptionalNumber(lowerer, read, loc, access);
+    const bigintValue = rhsNode ? bigintCompoundValue(op, read, rhs, loc) : null;
     if (op === "+" && read.type.kind === "string") {
         value = {
             kind: "strConcat",
@@ -12878,6 +13122,9 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     else if (numericRead.type.kind === "f64" && numericRhs.type.kind === "f64") {
         value = { kind: "bin", op, left: numericRead, right: numericRhs, type: F64, loc };
     }
+    else if (bigintValue) {
+        value = bigintValue;
+    }
     else if (target.fieldType.kind === "dyn" && isJsSourceFile(access.getSourceFile())) {
         const numeric = ["-", "*", "/", "%", "**"].includes(op);
         const left = lowerer.coerceToExpected(read, DYN);