@scriptc/compiler 0.3.4 → 0.3.6

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

@@ -1,3 +1,4 @@
+import { guardNullProto, nullProtoRecordShape, recordNullProtoTest } from "./null-prototype.js";
 import { lowerProtocolPropertyRead } from "./class-protocol-dispatch.js";
 import { generatorDrain } from "./iterator-adapters.js";
 import { lowerEventObjectProperty, lowerEventObjectPropertyWrite } from "./lower-event-target.js";
@@ -5,6 +6,7 @@ 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 { lowerReadlineProperty } from "./builtins/readline.js";
 import { lowerBlobInstanceof } from "./builtins/blob.js";
 import { lowerKeyObjectInstanceof } from "./builtins/key-object.js";
 import { STATS_TYPE_TESTS } from "./builtins/filesystem.js";
@@ -22,6 +24,7 @@ import { literalUnionArm } from "../union-discriminants.js";
  * comparisons, nullish coalescing and optional chains, conditions and
  * ToBoolean/ToString coercion helpers, and field/element reads and writes
  * (FieldTarget). */
+import { isFsStreamMember, lowerFsStreamProperty } from "./builtins/fs-streams.js";
 import * as ts from "../ts7/adapter.js";
 import { isZlibStreamMember, lowerZlibStreamBytesWritten } from "./builtins/compression.js";
 import { constituentTypes } from "../ts7/checker.js";
@@ -599,7 +602,9 @@ function lowerExprInner(lowerer, expr) {
             const sym = lowerer.resolveValueSymbol(expr);
             const projection = sym ? lowerer.staticCallables.get(sym) : undefined;
             if (projection?.kind === "promisified-exec-file" ||
-                projection?.kind === "promisified-builtin") {
+                projection?.kind === "promisified-exec" ||
+                projection?.kind === "promisified-builtin" ||
+                projection?.kind === "promisified-zlib") {
                 lowerer.unsupported("SC1090", expr, `a promisified builtin as a value (call '${expr.text}' directly)`);
             }
             if (projection?.kind === "builtin-function") {
@@ -1554,6 +1559,18 @@ function lowerExprInner(lowerer, expr) {
                 });
             return { kind: "closure", fnName: name, captures: [], type: funcOf([DYN], DYN), loc };
         }
+        // An Hmac has no copy() (Hash does): Node answers undefined, which
+        // `typeof mac.copy` feature checks read. TypeScript rejects the read.
+        if (expr.name.text === "copy" &&
+            lowerer.mapTypeOf(lowerer.typeOf(expr.expression))?.kind === "cryptoHmac") {
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "exprStmt", expr: lowerer.lowerExpr(expr.expression), loc }],
+                result: dynUndefinedExpr(loc),
+                type: DYN,
+                loc,
+            };
+        }
         if (lowerer.stdlibGlobalMember(expr, "globalThis") === "console") {
             return { kind: "libCall", fn: "console.native", args: [], type: DYN, loc };
         }
@@ -1828,6 +1845,9 @@ function lowerExprInner(lowerer, expr) {
             // diagnostics_channel Channel receivers — name/hasSubscribers
             // over the f64 channel handle.
             lowerer.lowerDiagnosticsChannelProperty(expr) ??
+            // readline Interface receivers — the history and option members
+            // over the f64 interface handle.
+            lowerReadlineProperty(lowerer, expr) ??
             // TracingChannel receivers — the five event channels and
             // hasSubscribers over the f64 tracing handle.
             lowerer.lowerTracingChannelProperty(expr) ??
@@ -4166,6 +4186,8 @@ export function lowerIntrinsicProperty(lowerer, expr) {
     const numberMember = lowerer.stdlibGlobalMember(expr, "Number");
     if (numberMember === "parseInt" || numberMember === "parseFloat")
         return lowerNumberParserValue(lowerer, numberMember, locOf(expr));
+    if (lowerer.stdlibGlobalMember(expr, "Buffer") === "poolSize")
+        return { kind: "libCall", fn: "buffer.poolSize", args: [], type: F64, loc: locOf(expr) };
     if (lowerer.stdlibGlobalMember(expr, "Buffer") === "isBuffer")
         return lowerCheckedPredicateValue(lowerer, "Buffer.isBuffer", "buffer", locOf(expr));
     if (lowerer.stdlibGlobalMember(expr, "Date") === "now")
@@ -6343,6 +6365,21 @@ function tupleLiteralIndex(node) {
  * change the target or the value used by the operator. The expression yields
  * the computed value before a typed array or Buffer coerces it for storage. */
 export function lowerElementCompound(lowerer, expr, op) {
+    const lowered = lowerElementCompoundParts(lowerer, expr, op, false);
+    if (!lowered.expr)
+        throw new InternalCompilerError("a compound element value lowered to statements");
+    return lowered.expr;
+}
+/** `a[i] op= rhs` in statement position: a string array append becomes the
+ * canonical `a[i] = a[i] + rhs` store (receiver and index saved first),
+ * which the backend appends in place; other forms keep the value path. */
+export function lowerElementCompoundStatement(lowerer, expr, op) {
+    const lowered = lowerElementCompoundParts(lowerer, expr, op, true);
+    if (lowered.stmts)
+        return { kind: "block", body: lowered.stmts, loc: locOf(expr) };
+    return { kind: "exprStmt", expr: lowered.expr, loc: locOf(expr) };
+}
+function lowerElementCompoundParts(lowerer, expr, op, statement) {
     const target = expr.left;
     fenceNodeModuleMutation(lowerer, target, "assignment");
     const loc = locOf(expr);
@@ -6377,7 +6414,7 @@ export function lowerElementCompound(lowerer, expr, op) {
             },
             loc,
         });
-        return { kind: "seqExpr", stmts, result: value, type: DYN, loc };
+        return { expr: { kind: "seqExpr", stmts, result: value, type: DYN, loc }, stmts: null };
     }
     const receiverType = checked.type.kind === "array" || checked.type.kind === "bytes"
         ? checked.type
@@ -6435,6 +6472,27 @@ export function lowerElementCompound(lowerer, expr, op) {
     const valueType = elementType.kind === "union" && lowerer.armTag(elementType.unionId, UNDEFINED_T) >= 0
         ? lowerer.stripUndefinedArm(elementType)
         : elementType;
+    if (statement &&
+        op === "+" &&
+        receiver.type.kind === "array" &&
+        receiver.type.elem.kind === "string") {
+        // Receiver, index, old element (read inside the concat), rhs, write.
+        const appended = {
+            kind: "strConcat",
+            left: oldValue,
+            right: lowerer.ensureString(rhs, expr.right),
+            type: STRING,
+            loc,
+        };
+        return {
+            expr: null,
+            stmts: [
+                { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
+                { kind: "varDecl", localId: indexLocal.id, init: index, loc },
+                { kind: "arraySet", arr: receiverRef(), index: indexRef(), value: appended, loc },
+            ],
+        };
+    }
     let computed;
     if (op === "+" && valueType.kind === "string") {
         computed = {
@@ -6457,17 +6515,18 @@ export function lowerElementCompound(lowerer, expr, op) {
     }
     else if (valueType.kind === "dyn" && isJsSourceFile(expr.getSourceFile())) {
         const left = lowerer.coerceToExpected(oldRef(), DYN), right = lowerer.coerceToExpected(rhs, DYN);
-        const numeric = ["-", "*", "/", "%", "**"].includes(op);
-        computed = {
-            kind: "libCall",
-            fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
-            args: op === "+" ? [left, right] : [left, right, strLit(op, loc)],
-            type: DYN,
-            loc,
-        };
+        computed = dynCompoundValue(op, left, right, loc);
+    }
+    else if (rhs.type.kind === "dyn" &&
+        receiver.type.kind === "array" &&
+        lowerer.dynConvertible(oldValue.type) &&
+        lowerer.dynConvertible(valueType)) {
+        // An untyped right operand: the expanded `a[i] = a[i] op rhs`, checked
+        // back into the element type.
+        computed = lowerer.coerceInto(expr, dynCompoundValue(op, lowerer.coerceToExpected(oldRef(), DYN), lowerer.coerceToExpected(rhs, DYN), loc), valueType);
     }
     else {
-        lowerer.unsupported("SC1043", expr);
+        compoundUnsupported(lowerer, expr, op, oldValue.type, rhs.type);
     }
     const resultLocal = lowerer.declareHiddenLocal("%compoundResult", computed.type);
     const resultRef = () => varRef(resultLocal.id, computed.type, loc);
@@ -6475,17 +6534,20 @@ export function lowerElementCompound(lowerer, expr, op) {
         ? arrayValueStore(lowerer, receiverRef(), indexRef(), resultRef(), receiver.type.elem, loc)
         : { kind: "bytesSet", arr: receiverRef(), index: indexRef(), value: resultRef(), loc };
     return {
-        kind: "seqExpr",
-        stmts: [
-            { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
-            { kind: "varDecl", localId: indexLocal.id, init: index, loc },
-            { kind: "varDecl", localId: oldLocal.id, init: oldValue, loc },
-            { kind: "varDecl", localId: resultLocal.id, init: computed, loc },
-            write,
-        ],
-        result: resultRef(),
-        type: computed.type,
-        loc,
+        expr: {
+            kind: "seqExpr",
+            stmts: [
+                { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
+                { kind: "varDecl", localId: indexLocal.id, init: index, loc },
+                { kind: "varDecl", localId: oldLocal.id, init: oldValue, loc },
+                { kind: "varDecl", localId: resultLocal.id, init: computed, loc },
+                write,
+            ],
+            result: resultRef(),
+            type: computed.type,
+            loc,
+        },
+        stmts: null,
     };
 }
 /** ToString of one stabilized `string[]` element read for `+=`: a missing
@@ -7176,6 +7238,11 @@ export function ensureString(lowerer, e, node) {
         if (isPerfEntryType(lowerer, e.type))
             return perfEntryTag(lowerer, e, e.type, e.loc);
         if (shape && !shape.tuple && !shape.fields.some((f) => f.name === "toString")) {
+            // A null-prototype record (Object.groupBy) has no toString or
+            // valueOf: ToPrimitive throws Node's TypeError.
+            const nullProtoT = nullProtoRecordShape(lowerer, e.type);
+            if (nullProtoT)
+                return nullProtoToString(lowerer, e, nullProtoT);
             return { kind: "toString", operand: e, type: STRING, loc: e.loc };
         }
     }
@@ -7183,6 +7250,34 @@ export function ensureString(lowerer, e, node) {
         lowerer.badType(node, lowerer.typeOf(node));
     return { kind: "toString", operand: e, type: STRING, loc: e.loc };
 }
+/** String(r) over a record that may have a null prototype: an interned
+ * helper that throws Node's TypeError for a null-prototype record and
+ * answers "[object Object]" otherwise. */
+function nullProtoToString(lowerer, e, t) {
+    const loc = e.loc;
+    const key = `nullProtoToString:${t.shapeId}`;
+    let helper = lowerer.valueHelpers.get(key);
+    if (!helper) {
+        helper = `%rec.tostr.${lowerer.valueHelpers.size}`;
+        lowerer.valueHelpers.set(key, helper);
+        const r = varRef("r.0", t, loc);
+        lowerer.liftedFns.push({
+            name: helper,
+            params: [{ localId: "r.0", name: "r", type: t }],
+            returnType: STRING,
+            locals: [{ id: "r.0", name: "r", type: t, mutable: false }],
+            body: [
+                {
+                    kind: "return",
+                    value: guardNullProto(r, t.shapeId, "Cannot convert object to primitive value", { kind: "toString", operand: r, type: STRING, loc }, loc),
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [e], type: STRING, loc };
+}
 /** `new String(x)` (stdlib provenance, ≤1 argument) in a ToString
  * position: the wrapper's only distinguishers are typeof and identity —
  * neither is observable where the value immediately stringifies — so the
@@ -7319,6 +7414,11 @@ export function lowerAsExpression(lowerer, expr) {
         // object. Box a live reference instead of erasing the assertion and
         // handing native storage to a checked-dynamic property operation.
         if (target?.kind === "dyn" && (targetTs0.flags & ts.TypeFlags.Object) !== 0) {
+            // A class instance asserted to a class-backed protocol view (a type
+            // class instances flow into): the same identity-keeping box an
+            // implicit flow into the view uses.
+            if (inner.type.kind === "object" && lowerer.classImplementedProtocol(targetTs0))
+                return lowerer.coerceInto(expr, inner, DYN);
             const sourceShape = inner.type.kind === "record" ? lowerer.shapes.get(inner.type.shapeId) : undefined;
             if (hasClassPayload(lowerer, inner.type) ||
                 (sourceShape && shapeHasAccessorSlots(sourceShape))) {
@@ -7477,7 +7577,7 @@ export function lowerPrefixUnary(lowerer, expr) {
                 ? { kind: "dynCheck", value: raw, type: F64, loc }
                 : lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, "-", [raw.type]);
             if (operand.kind === "numLit")
                 return { ...operand, value: -operand.value, loc };
             return { kind: "unary", op: "-", operand, type: F64, loc };
@@ -7495,7 +7595,7 @@ export function lowerPrefixUnary(lowerer, expr) {
             }
             const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, "+", [raw.type]);
             return operand;
         }
         case ts.SyntaxKind.ExclamationToken: {
@@ -7524,7 +7624,7 @@ export function lowerPrefixUnary(lowerer, expr) {
             // otherwise numeric slot to the checked-dynamic tree.
             const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, "~", [raw.type]);
             return { kind: "unary", op: "~", operand, type: F64, loc };
         }
         case ts.SyntaxKind.PlusPlusToken:
@@ -7633,12 +7733,19 @@ export function lowerIncDec(lowerer, expr, prefix) {
                     loc,
                 });
         }
-        if (isJsSourceFile(expr.getSourceFile()) && raw.type.kind === "dyn") {
+        // A TS member statically typed number on a checked-dynamic receiver (a
+        // class-backed protocol view): the expanded form `o.v = o.v + 1`, its
+        // read checked into number like any other read of the member.
+        const checkedNumber = !isJsSourceFile(expr.getSourceFile()) &&
+            raw.type.kind === "dyn" &&
+            lowerer.mapTypeOf(lowerer.typeOf(access))?.kind === "f64";
+        if ((isJsSourceFile(expr.getSourceFile()) || checkedNumber) && raw.type.kind === "dyn") {
             const receiver = save(raw, "%incrementReceiver");
             const key = save(ts.isElementAccessExpression(access)
                 ? lowerer.lowerExprExpecting(access.argumentExpression, DYN)
                 : lowerer.coerceInto(access, { kind: "strLit", value: access.name.text, type: STRING, loc }, DYN), "%incrementKey");
-            return finish({ kind: "dynKeyGet", value: receiver, key, type: DYN, loc }, (value) => ({
+            const read = { kind: "dynKeyGet", value: receiver, key, type: DYN, loc };
+            return finish(checkedNumber ? lowerer.coerceInto(access, read, F64) : read, (value) => ({
                 kind: "exprStmt",
                 expr: {
                     kind: "libCall",
@@ -7781,7 +7888,7 @@ export function lowerIncDecTarget(lowerer, expr, target, prefix) {
         };
     }
     if (target.type.kind !== "f64")
-        lowerer.unsupported("SC1043", expr);
+        operatorUnsupported(lowerer, expr, op === "+" ? "++" : "--", [target.type]);
     return { kind: "incDec", op, prefix, localId: target.id, type: F64, loc };
 }
 /** Whether a lowered statement can live inside a seqExpr. These statements
@@ -7874,26 +7981,51 @@ export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
     if (numericRead.type.kind === "f64" && numericRhs.type.kind === "f64") {
         return lowerer.coerceInto(expr, { kind: "bin", op: compound, left: numericRead, right: numericRhs, type: F64, loc }, target.type);
     }
+    // An untyped operand: exactly the expanded `x = x op rhs` — the runtime
+    // operator on both values, then the checked conversion into the
+    // target's declared type (a string result for a number target throws the
+    // catchable TypeError, as the expanded assignment does).
     if ((target.type.kind === "dyn" || rhs.type.kind === "dyn") &&
-        isJsSourceFile(expr.getSourceFile())) {
+        (isJsSourceFile(expr.getSourceFile()) ||
+            (lowerer.dynConvertible(read.type) && lowerer.dynConvertible(rhs.type)))) {
         const left = lowerer.coerceInto(expr.left, read, DYN);
         const right = lowerer.coerceInto(expr.right, rhs, DYN);
-        const numeric = ["-", "*", "/", "%", "**"].includes(compound);
-        const computed = {
-            kind: "libCall",
-            fn: compound === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
-            args: compound === "+"
-                ? [left, right]
-                : [left, right, { kind: "strLit", value: compound, type: STRING, loc }],
-            type: DYN,
-            loc,
-        };
-        return lowerer.coerceInto(expr, computed, target.type);
+        return lowerer.coerceInto(expr, dynCompoundValue(compound, left, right, loc), target.type);
     }
     const bigint = bigintCompoundValue(compound, read, rhs, loc);
     if (bigint)
         return bigint;
-    lowerer.unsupported("SC1043", expr);
+    compoundUnsupported(lowerer, expr, compound, read.type, rhs.type);
+}
+/** The runtime operator of a compound assignment over two checked-dynamic
+ * operands (Node's ToPrimitive/ToNumeric order lives in the runtime). */
+function dynCompoundValue(op, left, right, loc) {
+    const numeric = ["-", "*", "/", "%", "**"].includes(op);
+    return {
+        kind: "libCall",
+        fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
+        args: op === "+" ? [left, right] : [left, right, strLit(op, loc)],
+        type: DYN,
+        loc,
+    };
+}
+/** An operand type in an SC1043 message: checked-dynamic values (`any`,
+ * `unknown`) are "untyped", everything else its quoted type. */
+function operandText(lowerer, t) {
+    return t.kind === "dyn" ? "untyped" : `'${lowerer.fmt(t)}'`;
+}
+/** SC1043 for a compound assignment whose operand types have no lowering,
+ * naming the operator and both types rather than the comparison wording. */
+function compoundUnsupported(lowerer, node, op, target, value) {
+    lowerer.unsupported("SC1043", node, `compound '${op}=' assignments of ${operandText(lowerer, value)} values to ${operandText(lowerer, target)} targets`);
+}
+/** SC1043 for an arithmetic, unary or update operator whose operand types
+ * have no lowering (comparisons keep the registry wording). */
+function operatorUnsupported(lowerer, node, op, operands) {
+    const [first, second] = operands;
+    lowerer.unsupported("SC1043", node, second === undefined
+        ? `'${op}' operations on ${operandText(lowerer, first)} values`
+        : `'${op}' operations on ${operandText(lowerer, first)} and ${operandText(lowerer, second)} values`);
 }
 /** Equality of two NaN-coded values (nan-coded-reads.ts), each of which may
  * stand for undefined and never holds a genuine NaN: Node's undefined equals
@@ -8782,7 +8914,7 @@ export function lowerBinary(lowerer, expr) {
                     };
                 }
             }
-            lowerer.unsupported("SC1043", expr);
+            operatorUnsupported(lowerer, expr, "+", [left.type, right.type]);
             break;
         case ts.SyntaxKind.MinusToken:
         case ts.SyntaxKind.AsteriskToken:
@@ -8790,7 +8922,7 @@ export function lowerBinary(lowerer, expr) {
         case ts.SyntaxKind.PercentToken:
         case ts.SyntaxKind.AsteriskAsteriskToken: {
             if (!bothNum)
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, ts.tokenToString(op) ?? "?", [left.type, right.type]);
             const binOp = op === ts.SyntaxKind.MinusToken
                 ? "-"
                 : op === ts.SyntaxKind.AsteriskToken
@@ -8820,7 +8952,7 @@ export function lowerBinary(lowerer, expr) {
         case ts.SyntaxKind.GreaterThanGreaterThanToken:
         case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken: {
             if (!bothNum)
-                lowerer.unsupported("SC1043", expr);
+                operatorUnsupported(lowerer, expr, ts.tokenToString(op) ?? "?", [left.type, right.type]);
             const bitOp = op === ts.SyntaxKind.AmpersandToken
                 ? "&"
                 : op === ts.SyntaxKind.BarToken
@@ -10533,10 +10665,12 @@ export function lowerInstanceOf(lowerer, expr, loc) {
     if (left.type.kind === "union") {
         const unionId = left.type.unionId;
         const arms = lowerer.unions.get(unionId)?.arms;
-        // Ordinary records and scalar values do not carry a class prototype.
-        // Dynamic/opaque runtime objects keep their existing instanceof fences.
+        // Ordinary records, arrays and scalar values do not carry a class
+        // prototype (no program class extends Array). Dynamic/opaque runtime
+        // objects keep their existing instanceof fences.
         if (arms?.every((arm) => arm.kind === "object" ||
             arm.kind === "record" ||
+            arm.kind === "array" ||
             arm.kind === "f64" ||
             arm.kind === "string" ||
             arm.kind === "bool" ||
@@ -10595,6 +10729,10 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             }
             return { kind: "call", callee: helper, args: [left], type: BOOL, loc };
         }
+        // A class arm could hold an instance: the test cannot be decided
+        // statically.
+        if (arms?.some((arm) => arm.kind === "object"))
+            lowerer.unsupported("SC1090", expr, "'instanceof' on a union of class instances and values without a class prototype test");
     }
     if (left.type.kind !== "object") {
         return readsClassAfter(lowerer, target, expr.right, [{ kind: "exprStmt", expr: left, loc }], {
@@ -11182,6 +11320,17 @@ function lowerInExpression(lowerer, expr, loc) {
         recv.kind === "recordGet" ||
         recv.kind === "fieldGet" ||
         pureRecvNode) {
+        // A null-prototype record (Object.groupBy) has no inherited names.
+        const nullProtoT = inherited ? nullProtoRecordShape(lowerer, recv.type) : null;
+        if (nullProtoT) {
+            return {
+                kind: "unary",
+                op: "!",
+                operand: recordNullProtoTest(recv, nullProtoT.shapeId, loc),
+                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)");
@@ -11243,20 +11392,34 @@ function lowerRuntimeKeyIn(lowerer, expr, loc) {
             type: BOOL,
             loc,
         };
-        // A miss in the record's own keys still finds Object.prototype's.
-        let inherited = ovfHas;
+        // A miss in the record's own keys still finds Object.prototype's,
+        // unless the record has a null prototype (Object.groupBy).
+        let protoName = null;
         for (const name of OBJECT_PROTOTYPE_KEYS) {
             if (shape.fields.some((f) => f.name === name))
                 continue;
-            inherited = {
+            const eq = {
+                kind: "strEq",
+                negated: false,
+                left: k,
+                right: { kind: "strLit", value: name, type: STRING, loc },
+                type: BOOL,
+                loc,
+            };
+            protoName =
+                protoName === null
+                    ? eq
+                    : { kind: "logical", op: "||", left: protoName, right: eq, type: BOOL, loc };
+        }
+        if (protoName !== null && nullProtoRecordShape(lowerer, recT)) {
+            protoName = {
                 kind: "logical",
-                op: "||",
-                left: inherited,
+                op: "&&",
+                left: protoName,
                 right: {
-                    kind: "strEq",
-                    negated: false,
-                    left: k,
-                    right: { kind: "strLit", value: name, type: STRING, loc },
+                    kind: "unary",
+                    op: "!",
+                    operand: recordNullProtoTest(r, recvT.shapeId, loc),
                     type: BOOL,
                     loc,
                 },
@@ -11264,7 +11427,9 @@ function lowerRuntimeKeyIn(lowerer, expr, loc) {
                 loc,
             };
         }
-        body.push(ret(inherited));
+        body.push(ret(protoName === null
+            ? ovfHas
+            : { kind: "logical", op: "||", left: ovfHas, right: protoName, type: BOOL, loc }));
         lowerer.liftedFns.push({
             name: helper,
             params: [
@@ -11587,6 +11752,10 @@ function lowerMatchGroupsRead(lowerer, expr) {
     if (!recvT || !isMatchSliceType(lowerer, recvT) || !lowerer.isStdlibMember(expr))
         return null;
     const groups = matchResultNamedGroupsOf(lowerer, expr.expression);
+    // An untraced regex: TypeScript reaches the member fence; JavaScript
+    // would otherwise read the slice's absent expando as undefined.
+    if (groups === null && isJsSourceFile(expr.getSourceFile()))
+        lowerer.stdlibMemberFence(expr);
     if (groups === null)
         return null;
     if (groups.length === 0) {
@@ -13143,7 +13312,7 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
                 ? { kind: "dynCheck", value: rhs, type: F64, loc: rhs.loc }
                 : lowerOptionalNumber(lowerer, rhs, loc);
             if (numericRhs.type.kind !== "f64")
-                lowerer.unsupported("SC1043", access);
+                compoundUnsupported(lowerer, access, op, F64, numericRhs.type);
             const value = save({ kind: "bin", op, left: cur, right: numericRhs, type: F64, loc }, "%compoundResult");
             const boxed = { kind: "dynFrom", value, type: DYN, loc };
             body.push({
@@ -13204,22 +13373,16 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, 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);
-        const right = lowerer.coerceToExpected(rhs, DYN);
-        value = {
-            kind: "libCall",
-            fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
-            args: op === "+"
-                ? [left, right]
-                : [left, right, { kind: "strLit", value: op, type: STRING, loc }],
-            type: DYN,
-            loc,
-        };
+    else if ((target.fieldType.kind === "dyn" && isJsSourceFile(access.getSourceFile())) ||
+        // An untyped right operand: the expanded `o.f = o.f op rhs`; the field
+        // write below checks the result into the declared field type.
+        (rhs.type.kind === "dyn" &&
+            lowerer.dynConvertible(read.type) &&
+            lowerer.dynConvertible(target.fieldType))) {
+        value = dynCompoundValue(op, lowerer.coerceToExpected(read, DYN), lowerer.coerceToExpected(rhs, DYN), loc);
     }
     else {
-        lowerer.unsupported("SC1043", access);
+        compoundUnsupported(lowerer, access, op, read.type, rhs.type);
     }
     if (storedString && rhs.type.kind === "string" && read.kind === "varRef" && appended !== null) {
         // The field gives up its value before the concat (no code runs in
@@ -13260,6 +13423,11 @@ function lowerStreamObjectProperty(lowerer, expr) {
     if (expr.name.text === "bytesWritten" && isZlibStreamMember(lowerer, expr)) {
         return lowerZlibStreamBytesWritten(lowerer, expr);
     }
+    if (isFsStreamMember(lowerer, expr)) {
+        const member = lowerFsStreamProperty(lowerer, expr);
+        if (member)
+            return member;
+    }
     return lowerStreamProperty(lowerer, expr, info);
 }
 /** The primitive-constructor closure (`String`/`Number`/`Boolean` as a