@scriptc/compiler 0.3.1 → 0.3.3

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

@@ -1,8 +1,15 @@
+import { lowerProtocolPropertyRead } from "./class-protocol-dispatch.js";
 import { generatorDrain } from "./iterator-adapters.js";
+import { lowerEventObjectProperty, lowerEventObjectPropertyWrite } from "./lower-event-target.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 { lowerBlobInstanceof } from "./builtins/blob.js";
+import { lowerKeyObjectInstanceof } from "./builtins/key-object.js";
+import { STATS_TYPE_TESTS } from "./builtins/filesystem.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";
@@ -22,7 +29,7 @@ import { checkedClassAssertion, checkedClassUnionAssertion } from "./class-asser
 import { checkedArmExtraction } from "./coercions/unions.js";
 import { narrowClassUnion, narrowStoredClassValue } from "./class-unions.js";
 import { lowerUnionFieldRead, lowerUnionFieldWrite } from "./expressions/union-fields.js";
-import { captureContextArguments } from "./function-context.js";
+import { captureContextArguments, declareContextLocal } from "./function-context.js";
 import { OBJECT_CALLABLE_VALUES } from "./surfaces.js";
 import { wasiGuestPath } from "../../wasi-paths.js";
 import { BIGINT_T, BYTES_ELEMENT_NAME, BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, NULL_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_ERROR_CLASSES, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, canAdaptDynFuncTo, canDynCheckTo, canBoxFuncIntoDyn, funcOf, isDynTypedRefType, isSupportedArrayElem, isUnitType, shapeHasAccessorSlots, typeEquals, typeKey, unionContainerArmsOk, } from "../../ir/ir.js";
@@ -48,8 +55,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, isLegacyUrlSymbol, 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";
@@ -77,6 +84,7 @@ import { lowerUrlAssignment } from "./builtins/url.js";
 import { jsBindingHasOpenWrites } from "./lower-stmts.js";
 import { checkedClassInstanceOf } from "./class-construction.js";
 import { lowerModuleNamespaceElement } from "./module-namespace-elements.js";
+import { isPerfEntryType, perfEntryTag } from "./builtins/performance.js";
 /** A template piece's RAW text (String.raw's contract: escapes stay
  * characters). 7's client AST ships no rawText at runtime (the typing
  * declares it; the serialized node data omits it), so the raw span comes
@@ -731,7 +739,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 +859,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 +884,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 +1428,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);
@@ -1772,7 +1792,7 @@ function lowerExprInner(lowerer, expr) {
         // attached this name to it (`exports.<name> =` nowhere in the
         // file), the honest answer is undefined. tsc types the read off the
         // REPLACEMENT (its CJS model is identity-blind), which is exactly
-        // the silent divergence this lowering closes. Reads in modules with
+        // the undiagnosed divergence this lowering closes. Reads in modules with
         // real `exports.<name> =` attachments keep their fences.
         {
             const ex = lowerReplacedExportsRead(lowerer, expr);
@@ -1787,6 +1807,13 @@ function lowerExprInner(lowerer, expr) {
             if (tm)
                 return tm;
         }
+        // Property signatures of class-backed protocols read implementing
+        // classes' fields directly.
+        if (!hasOptionalChainGuard(expr.expression)) {
+            const typed = lowerProtocolPropertyRead(lowerer, expr);
+            if (typed)
+                return typed;
+        }
         const handled = lowerer.lowerProcessEnvGet(expr) ??
             lowerer.lowerServerProperty(expr) ??
             // diagnostics_channel Channel receivers — name/hasSubscribers
@@ -1809,6 +1836,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
@@ -1816,6 +1844,7 @@ function lowerExprInner(lowerer, expr) {
             // the inner access maps no type of its own.
             lowerStreamStateProperty(lowerer, expr) ??
             lowerStreamObjectProperty(lowerer, expr) ??
+            lowerEventObjectProperty(lowerer, expr) ??
             lowerer.lowerUnionProperty(expr) ??
             lowerer.lowerFieldRead(expr);
         // A union-typed field read narrows like an identifier when the
@@ -1831,7 +1860,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 +2050,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 +2085,15 @@ 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 ||
+            isLegacyUrlSymbol(lowerer.checker.getSymbolAtLocation(expr.name), lowerer)) {
             const recv = lowerer.lowerExpr(expr.expression);
             if (recv.type.kind === "dyn") {
                 const key = {
@@ -2067,14 +2103,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 &
@@ -4286,10 +4328,10 @@ export function lowerIntrinsicProperty(lowerer, expr) {
             const receiver = lowerer.lowerExpr(expr.expression);
             return { kind: "libCall", fn: "stats.size", args: [receiver], type: F64, loc: locOf(expr) };
         }
-        if (name === "isFile" || name === "isDirectory") {
+        if (Object.hasOwn(STATS_TYPE_TESTS, name)) {
             lowerer.unsupported("SC1090", expr, `Stats methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), dev, ino, size, blocks, nlink, atimeMs, mtimeMs, and ctimeMs are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), isBlockDevice(), isCharacterDevice(), isFIFO(), isSocket(), dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs, atime, mtime, ctime, and birthtime are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "date") {
         const methods = new Set([
@@ -7122,6 +7164,8 @@ export function ensureString(lowerer, e, node) {
         // prints its elements like an array (not lowered — fenced) — every
         // other record is Object.prototype.toString's constant.
         const shape = lowerer.shapes.get(e.type.shapeId);
+        if (isPerfEntryType(lowerer, e.type))
+            return perfEntryTag(lowerer, e, e.type, e.loc);
         if (shape && !shape.tuple && !shape.fields.some((f) => f.name === "toString")) {
             return { kind: "toString", operand: e, type: STRING, loc: e.loc };
         }
@@ -7272,7 +7316,23 @@ export function lowerAsExpression(lowerer, expr) {
                 lowerer.unsupported("SC1090", expr, "opaque structural views of classes or accessor records (name the property's concrete type to retain native accessor dispatch)");
             }
             const boxed = lowerer.coerceInto(expr, inner, DYN);
-            return boxed.kind === "dynFrom" ? { ...boxed, liveRef: true } : boxed;
+            // Only references box live; a scalar or unit source (`value as
+            // unknown as View`) is an ordinary snapshot.
+            const seen = new Set();
+            const live = (type) => {
+                if (type.kind === "record" ||
+                    type.kind === "array" ||
+                    type.kind === "bytes" ||
+                    isDynTypedRefType(type))
+                    return true;
+                if (type.kind !== "union" || seen.has(type.unionId))
+                    return false;
+                seen.add(type.unionId);
+                return lowerer.unions.get(type.unionId)?.arms.some(live) ?? false;
+            };
+            return boxed.kind === "dynFrom" && live(boxed.value.type)
+                ? { ...boxed, liveRef: true }
+                : boxed;
         }
         // Collection assertions are interface views only: their backing
         // value must already have the same native key/element/value layout.
@@ -7916,6 +7976,13 @@ export function lowerBinary(lowerer, expr) {
         if (ts.isPropertyAccessExpression(expr.left) || ts.isElementAccessExpression(expr.left)) {
             fenceNodeModuleMutation(lowerer, expr.left, "assignment");
         }
+        // The writable Event accessors on Event subclass instances, in value
+        // position (`const r = (event.returnValue = false)`).
+        if (op === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(expr.left)) {
+            const eventWrite = lowerEventObjectPropertyWrite(lowerer, expr.left, expr.right);
+            if (eventWrite)
+                return eventWrite;
+        }
         // `x = e` in EXPRESSION position (`while ((idx = s.indexOf("\n")) !== -1)`,
         // `f(x = v)`): evaluate e once, write the binding, yield the assigned
         // value — JS evaluation order. Variable targets only (locals and module
@@ -8252,14 +8319,24 @@ export function lowerBinary(lowerer, expr) {
                 reference.kind === "union" ||
                 DYN_HANDLE_KINDS.has(reference.kind)) &&
                 lowerer.dynConvertible(reference)) {
+                // Records, arrays and byte views compare by the capsule identity
+                // their dyn reads produce, including when they arrive through a
+                // union (an optional array field read from a typed record).
+                const liveArm = (type) => {
+                    if (type.kind === "array" || type.kind === "bytes")
+                        return true;
+                    const shape = type.kind === "record" ? lowerer.shapes.get(type.shapeId) : undefined;
+                    return !!shape && (shape.fields.length > 0 || shape.indexValue !== undefined);
+                };
                 const boxed = {
                     kind: "dynFrom",
                     value: scalarSide,
                     type: DYN,
                     loc: scalarSide.loc,
                     ...(reference.kind === "record" ||
-                        reference.kind === "array" ||
-                        reference.kind === "bytes"
+                        liveArm(reference) ||
+                        (reference.kind === "union" &&
+                            (lowerer.unions.get(reference.unionId)?.arms.some(liveArm) ?? false))
                         ? { liveRef: true }
                         : {}),
                 };
@@ -8523,8 +8600,8 @@ export function lowerBinary(lowerer, expr) {
     // the checker typed the binding as `string`. An optional string is not
     // itself a string operand for `+`: `undefined + 1` and
     // `undefined + undefined` are NaN, while a present string concatenates.
-    // Keep this predicate exact so a nullable string does not silently take
-    // the string path either.
+    // Keep this predicate exact so a nullable string does not take the
+    // string path either.
     const optionalStringType = (type) => {
         if (type.kind !== "union")
             return false;
@@ -9518,6 +9595,7 @@ function typeofAnswer(arm) {
         case "searchParams":
         case "stats":
         case "fileHandle":
+        case "dir":
         case "spawnRes":
         case "child":
         case "netServer":
@@ -10140,6 +10218,22 @@ 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 };
+        }
+    }
+    {
+        const blob = lowerBlobInstanceof(lowerer, expr);
+        if (blob)
+            return blob;
+        const keyObject = lowerKeyObjectInstanceof(lowerer, expr);
+        if (keyObject)
+            return keyObject;
+    }
     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 };
@@ -10339,7 +10433,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)");
         }
@@ -10489,13 +10588,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)
@@ -10506,10 +10604,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
@@ -10567,7 +10688,7 @@ function lowerPrivateIn(lowerer, expr, priv, loc) {
     // A GENERIC family: JS has ONE runtime class and ONE brand for every
     // instantiation, while these layouts mint one class per instantiation
     // — a cross-instantiation check would answer false where Node says
-    // true, so the family fences rather than silently splitting the brand.
+    // true, so the family reports SC1090 instead of splitting the brand.
     if (info.generic || info.genericInstance) {
         lowerer.unsupported("SC1090", expr, `'${pname} in …' inside a generic class (JS shares one brand across every instantiation; these layouts mint one class per instantiation)`);
     }
@@ -10663,11 +10784,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
@@ -10917,7 +11054,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;
             }
@@ -10925,7 +11066,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" ||
@@ -10993,7 +11134,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);
@@ -11021,14 +11164,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)");
 }
@@ -11081,7 +11226,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: [
@@ -12912,8 +13086,8 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     // accounting; dot spelling only — symbol-keyed element targets are
     // static fields): read the member (dynKeyGet), VALIDATE it as a
     // number (dynCheck — a non-number member throws the catchable
-    // TypeError where JS would ToNumber-coerce; loud, never a silent
-    // NaN — SEMANTICS.md), combine, write back (dyn.keySet). The
+    // TypeError where JS would ToNumber-coerce; it throws instead of
+    // producing NaN — SEMANTICS.md), combine, write back (dyn.keySet). The
     // receiver and member read are saved before evaluating the RHS.
     if (ts.isPropertyAccessExpression(access)) {
         let probed = tryLowerExpression(lowerer, access.expression);
@@ -12987,22 +13161,33 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     target.obj = save(target.obj, "%compoundReceiver");
     // Accessors observe getter, RHS side effects, then setter, all through
     // the saved receiver.
-    const read = save(lowerer.fieldGetExpr(target, locOf(access), access), "%compoundOld");
+    const fieldRead = lowerer.fieldGetExpr(target, locOf(access), access);
+    // `+=` on a stored string field reads it into a mutable local, so the
+    // concat below can append to that local in place.
+    const storedString = op === "+" &&
+        fieldRead.type.kind === "string" &&
+        target.fieldType.kind === "string" &&
+        (target.container === "class" || target.container === "record");
+    let read;
+    if (storedString) {
+        const old = declareContextLocal(lowerer.ctx, "%compoundOld", STRING, true, undefined, undefined);
+        body.push({ kind: "varDecl", localId: old.id, init: fieldRead, loc: fieldRead.loc });
+        read = varRef(old.id, STRING, fieldRead.loc);
+    }
+    else {
+        read = save(fieldRead, "%compoundOld");
+    }
     const rhs = save(rhsNode ? lowerer.lowerExpr(rhsNode) : { kind: "numLit", value: 1, type: F64, loc }, "%compoundRhs");
     const numericRhs = rhs.type.kind === "dyn" && isJsSourceFile(access.getSourceFile())
         ? { kind: "dynCheck", value: rhs, type: F64, loc: rhs.loc }
         : lowerOptionalNumber(lowerer, rhs, loc);
     let value;
+    let appended = null;
     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",
-            left: read,
-            right: lowerer.ensureString(rhs, rhsNode ?? access),
-            type: STRING,
-            loc,
-        };
+        appended = lowerer.ensureString(rhs, rhsNode ?? access);
+        value = { kind: "strConcat", left: read, right: appended, type: STRING, loc };
     }
     else if (numericRead.type.kind === "f64" && numericRhs.type.kind === "f64") {
         value = { kind: "bin", op, left: numericRead, right: numericRhs, type: F64, loc };
@@ -13027,6 +13212,26 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     else {
         lowerer.unsupported("SC1043", access);
     }
+    if (storedString && rhs.type.kind === "string" && read.kind === "varRef" && appended !== null) {
+        // The field gives up its value before the concat (no code runs in
+        // between: both operands are already strings), and the concat is the
+        // self-append `old = old + rhs`, which hands the local's reference to
+        // the runtime: the old string is then uniquely owned unless something
+        // else holds it, and is appended to in place. Repeated `this.text += s`
+        // is linear rather than a copy per append.
+        const oldId = read.localId;
+        const oldLoc = read.loc;
+        const oldRef = () => varRef(oldId, STRING, oldLoc);
+        const concat = {
+            kind: "strConcat",
+            left: oldRef(),
+            right: appended,
+            type: STRING,
+            loc,
+        };
+        body.push(lowerer.fieldSetStmt(target, { kind: "strLit", value: "", type: STRING, loc }, loc, access), { kind: "assign", localId: oldId, value: concat, loc }, lowerer.fieldSetStmt(target, oldRef(), loc, access));
+        return { kind: "seqExpr", stmts: body, result: oldRef(), type: STRING, loc };
+    }
     const result = save(value, "%compoundResult");
     body.push(lowerer.fieldSetStmt(target, lowerer.coerceInto(access, result, target.fieldType), loc, access));
     return { kind: "seqExpr", stmts: body, result, type: result.type, loc };