@scriptc/compiler 0.4.4 → 0.4.5

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

@@ -24,6 +24,7 @@ import { InternalCompilerError } from "../../errors.js";
  * explicit resource management, and blocked-binding poisoning. */
 import * as ts from "../ts7/adapter.js";
 import { lowerOptionalIndex } from "./undefined-index.js";
+import { builtinNamespaceValue } from "./builtin-namespaces.js";
 import { processDataMemberValue, programReadsExitCode } from "./builtins/process.js";
 import { requireInitFlagStmt } from "./require-initialization.js";
 import { isJsonRequireDecl } from "./json-require.js";
@@ -52,7 +53,7 @@ import { lowerForOfHelperChain } from "./containers/iterator-helpers.js";
 import { objectIterOverIndexShape } from "./containers/indexed-objects.js";
 import { strCharsCall } from "./containers/array-construction.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, genericBindingPresenceStore, genericBindingStoredValue, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, genericLocalClassBinding, } from "./generic-functions.js";
-import { bindingNeverReassigned, deadUnmappableBinding, nullishExprUnitOf, nullishGenericBindingUnitOf, } from "./binding-analysis.js";
+import { bindingNeverReassigned, deadUnmappableBinding, fileWritesBinding, nullishExprUnitOf, nullishGenericBindingUnitOf, } from "./binding-analysis.js";
 import { hasExplicitJsDocReturn } from "./function-returns.js";
 import { recordKeysArrayCall } from "./lower-calls.js";
 import { registerOverloadedCallableAlias } from "./call-signatures.js";
@@ -62,7 +63,7 @@ import { classStaticDataFor } from "./class-static-data.js";
 import { objectFactorySignature } from "./object-factory-new.js";
 import { isClassCallback, lowerClassCallbackAssign } from "./class-callbacks.js";
 import { classForInHasKey, classPropertiesHelper } from "./class-dynamic-dispatch.js";
-import { genericIfaceBindingKeepsClass, superConditionLead } from "./lower-classes.js";
+import { genericIfaceBindingKeepsClass, lowerClassStaticRead, staticReceiverClass, superConditionLead, } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl, streamSidesOf, } from "./lower-stream.js";
 import { staticAssertInstanceDecl } from "./assert-instances.js";
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerNetServerMaxConnectionsAssignment, lowerServerCloseOverrideAssignment, } from "./lower-server.js";
@@ -92,6 +93,7 @@ import { constituentTypes } from "../ts7/checker.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
 import { fenceNodeModuleMutation } from "./lower-node-module.js";
 import { fencePerfEntryKeyWalk } from "./builtins/performance.js";
+import { fenceX509KeyWalk } from "./builtins/x509.js";
 import { classGeneratorIterable } from "./class-iterables.js";
 import { iterableUnionOf, lowerForOfIterable } from "./iterable-values.js";
 /** An opted package's directly-returned empty array may take the function's
@@ -1373,7 +1375,39 @@ const THROWN_AS_DYN = new Set([
     "bytes",
     "func",
     "regex",
+    "date",
 ]);
+/** A `return` at the top level of a CommonJS module (preflight admits it
+ * there only): it ends the module's evaluation, and its value is
+ * evaluated and discarded, as Node's module wrapper does. Top-level
+ * bindings and export assignments after it would be left uninitialized
+ * where Node leaves them in their temporal dead zone or absent, so a
+ * module with any keeps a refusal. Null for a return inside a function. */
+function lowerModuleLevelReturn(lowerer, stmt) {
+    let top = stmt;
+    while (top.parent !== undefined && !ts.isSourceFile(top.parent)) {
+        if (ts.isFunctionLike(top.parent) || ts.isClassStaticBlockDeclaration(top.parent))
+            return null;
+        top = top.parent;
+    }
+    const sf = top.parent;
+    if (sf === undefined || !ts.isSourceFile(sf))
+        return null;
+    const stmts = sf.statements.nodes;
+    const later = stmts.slice(stmts.indexOf(top) + 1);
+    if (later.some((s) => ts.isVariableStatement(s) || ts.isClassDeclaration(s) || cjsExportAssignmentOf(s) !== null)) {
+        lowerer.unsupported("SC1090", stmt, "a top-level return in a CommonJS module that declares variables or classes, or assigns exports, after it");
+    }
+    const loc = locOf(stmt);
+    const ret = { kind: "return", value: null, loc };
+    if (!stmt.expression)
+        return ret;
+    return {
+        kind: "block",
+        body: [{ kind: "exprStmt", expr: lowerer.lowerExpr(stmt.expression), loc }, ret],
+        loc,
+    };
+}
 export function lowerStmt(lowerer, stmt) {
     if (ownPrototypeResetStatement(lowerer, stmt))
         return { kind: "block", body: [], loc: locOf(stmt) };
@@ -1475,6 +1509,9 @@ export function lowerStmt(lowerer, stmt) {
     if (ts.isLabeledStatement(stmt))
         return lowerLabeled(lowerer, stmt);
     if (ts.isReturnStatement(stmt)) {
+        const moduleReturn = lowerModuleLevelReturn(lowerer, stmt);
+        if (moduleReturn)
+            return moduleReturn;
         // Implicit-any instance RETURN INFERENCE (function-returns.ts
         // resolveInferredReturn): the value lowers BARE and the statement
         // records itself — the post-pass settles the instance's return type
@@ -1560,9 +1597,7 @@ export function lowerStmt(lowerer, stmt) {
             return { kind: "rethrow", localId: caughtLocal.id, loc: locOf(stmt) };
         }
         // Exception-representable values move into the runtime's exception
-        // cell. `throw f()` of a void call has no value; Date has numeric
-        // storage internally, but cannot preserve its object kind through the
-        // untyped catch boundary. Reject both rather than changing JS identity.
+        // cell. `throw f()` of a void call has no value.
         let value = lowerer.lowerExpr(stmt.expression);
         if (value.type.kind === "void")
             lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
@@ -1576,15 +1611,12 @@ export function lowerStmt(lowerer, stmt) {
             value = { kind: "dynFrom", value, liveRef: true, type: DYN, loc: locOf(stmt.expression) };
         }
         else if (THROWN_AS_DYN.has(value.type.kind) && lowerer.dynConvertible(value.type)) {
-            // Arrays, Maps, Sets, typed arrays, Buffers, functions, regexes and
-            // unions over them keep their identity and contents the same way:
-            // the catch binding, `typeof`, `instanceof`, `Array.isArray`,
-            // inspection and typed views read the thrown object.
+            // Arrays, Maps, Sets, typed arrays, Buffers, functions, regexes,
+            // Dates and unions over them keep their identity and contents the
+            // same way: the catch binding, `typeof`, `instanceof`,
+            // `Array.isArray`, inspection and typed views read the thrown object.
             value = lowerer.coerceInto(stmt.expression, value, DYN);
         }
-        if (value.type.kind === "date") {
-            lowerer.unsupported("SC1090", stmt.expression, "throwing Date values (catch bindings cannot preserve Date's object kind; throw an Error or primitive instead)");
-        }
         // A dyn throw rides the REF cell arm (scr_throw_ref over the checked-dynamic tree
         // node — identity preserved through catch bindings, caughtToDyn
         // passes it back by reference). The JS-lane traced-call shape:
@@ -2305,7 +2337,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                 const itRef = () => ({ kind: "varRef", localId: it.id, type: citPat.iterT, loc });
                 for (const el of pattern.elements.nodes) {
                     const stepLoc = locOf(el);
-                    const step = lowerer.classIteratorNextCall(citPat, itRef(), stepLoc);
+                    const step = lowerer.classIteratorNextCall(citPat, itRef(), null, stepLoc);
                     if (ts.isOmittedExpression(el) || el.name === undefined) {
                         out.push({ kind: "exprStmt", expr: step, loc: stepLoc });
                         continue;
@@ -2579,6 +2611,16 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         lowerer.lowerBindingPattern(pattern, () => lowerer.coerceToExpected(srcRef(), DYN), DYN, isLet, out, dynSpell, allowDynObject);
         return;
     }
+    // A class in a JavaScript file, destructured through its own name
+    // (`const { ANY, parse } = Comparator`): each element is the static
+    // read `Comparator.ANY` — the static getter, field or method as Node
+    // reads it, with the element's default applied when the read answers
+    // undefined. Other class-valued sources keep the refusal below.
+    if (srcType.kind === "classval" &&
+        ts.isObjectBindingPattern(pattern) &&
+        isJsSourceFile(ts.getSourceFileOfNode(pattern)) &&
+        lowerClassValuePattern(lowerer, pattern, isLet, out))
+        return;
     if (srcType.kind === "dyn") {
         // A runtime computed first key evaluates after RequireObjectCoercible:
         // a nullish source throws before the key's side effects run. Later
@@ -3574,7 +3616,8 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
             value =
                 canonical === "crypto"
                     ? { kind: "libCall", fn: "webcrypto.object", args: [], type: DYN, loc: locOf(el) }
-                    : builtinGlobalValue(canonical, locOf(el), true);
+                    : (builtinNamespaceValue(lowerer, canonical, locOf(el)) ??
+                        builtinGlobalValue(canonical, locOf(el), true));
         }
         else if (globalName === "console" && !CONSOLE_CALL_MEMBERS.has(propName)) {
             token = `[builtin console.${propName}]`;
@@ -3651,6 +3694,46 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
     }
     return out;
 }
+/** `const { ANY, parse } = Comparator` in a JavaScript file, where the
+ * declaration's initializer names the class exactly (staticReceiverClass):
+ * one static read per element, left to right. False, with nothing
+ * emitted, for other sources (a parameter or nested pattern over a class
+ * value), which keep the class-value refusal. */
+function lowerClassValuePattern(lowerer, pattern, isLet, out) {
+    const decl = pattern.parent;
+    if (!ts.isVariableDeclaration(decl) || decl.initializer === undefined)
+        return false;
+    let receiver = decl.initializer;
+    while (ts.isParenthesizedExpression(receiver))
+        receiver = receiver.expression;
+    const info = staticReceiverClass(lowerer, receiver);
+    if (info === null)
+        return false;
+    for (const el of pattern.elements.nodes) {
+        if (el.name === undefined)
+            continue;
+        if (el.dotDotDotToken)
+            lowerer.unsupported("SC1031", el, "rest bindings over class values (the rest object copies the class's own enumerable statics)");
+        const prop = el.propertyName ?? el.name;
+        const name = ts.isIdentifier(prop) ||
+            ts.isComputedPropertyName(prop) ||
+            ts.isStringLiteralLike(prop) ||
+            ts.isNumericLiteral(prop)
+            ? patternKeyNameOf(lowerer, prop)
+            : null;
+        if (name === null)
+            lowerer.unsupported("SC1031", el, "destructuring with computed keys that do not fold to one property name");
+        if (name === "prototype" || name.startsWith("#"))
+            lowerer.unsupported("SC1031", el, `destructuring '${name}' from a class value`);
+        let value = lowerClassStaticRead(lowerer, info, name, receiver, receiver);
+        if (value === null)
+            lowerer.unsupported("SC1031", el, `destructuring the property '${name}' the class '${info.def.jsName ?? info.def.name}' does not declare as a static`);
+        if (el.initializer)
+            value = applyBindingDefault(lowerer, el, value);
+        lowerer.bindPatternTarget(el.name, value, isLet, out);
+    }
+    return true;
+}
 /** `x = dflt` on a pattern position whose source value always EXISTS
  * (tuple positions, record fields): JS evaluates the default exactly
  * when the value is undefined — the undefined-arm ternary, lazy, so
@@ -4554,7 +4637,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     if (isTimeValueDateDeclaration(lowerer, decl)) {
         const loc = locOf(decl);
         const date = lowerer.lowerExprExpecting(decl.initializer, DATE_T);
-        const local = lowerer.declareLocal(decl.name, decl.name.text, F64, isLet);
+        const local = lowerer.declareLocal(decl.name, decl.name.text, F64, isLet || lowerer.timeValueDateWrites.has(decl));
         lowerer.timeValueDateLocals.add(local);
         const init = { kind: "libCall", fn: "date.getTime", args: [date], type: F64, loc };
         return { kind: "varDecl", localId: local.id, init, loc };
@@ -6150,6 +6233,63 @@ function lowerDeleteStatement(lowerer, expr) {
     }
     lowerer.unsupported("SC1090", expr, `'delete' on '${lowerer.fmt(obj.type)}' receivers (process.env keys and pure Record<string, T> keys delete)`);
 }
+/** True when the `var`/`let` binding `nameNode` names cannot change after
+ * the top-level CommonJS export statement `exportNode` that exports it by
+ * reference, so importers read the value Node copies at the export: its
+ * module's top level declares it once, with an initializer that runs
+ * before the export, and nothing assigns it. The initializer runs earlier
+ * in the same module, or in a module the exporting module required before
+ * the export (`var hljs = require('./core'); module.exports = hljs;` over
+ * highlight.js's `var highlight = HLJS({}); module.exports = highlight;`). */
+function unchangedAfterExport(lowerer, nameNode, exportNode) {
+    const topLevelDeclaration = (symbol) => {
+        const decl = symbol.declarations.length === 1 ? symbol.declarations[0] : undefined;
+        return decl !== undefined &&
+            ts.isVariableDeclaration(decl) &&
+            ts.isIdentifier(decl.name) &&
+            decl.initializer !== undefined &&
+            ts.isVariableDeclarationList(decl.parent) &&
+            ts.isVariableStatement(decl.parent.parent) &&
+            ts.isSourceFile(decl.parent.parent.parent)
+            ? decl
+            : null;
+    };
+    const exportFile = ts.getSourceFileOfNode(exportNode);
+    let exportStatement = exportNode;
+    for (let parent = exportNode.parent; parent !== undefined && !ts.isSourceFile(parent);) {
+        if (ts.isFunctionLike(parent) || ts.isClassDeclaration(parent) || ts.isClassExpression(parent))
+            return false;
+        exportStatement = parent;
+        parent = parent.parent;
+    }
+    const runsBeforeExport = (decl) => {
+        const statement = decl.parent?.parent;
+        return statement?.parent === exportFile && statement.end <= exportStatement.pos;
+    };
+    const sym = lowerer.resolveValueSymbol(nameNode);
+    const decl = sym ? topLevelDeclaration(sym) : null;
+    if (!sym || !decl || !bindingNeverReassigned(lowerer, sym, decl))
+        return false;
+    if (ts.getSourceFileOfNode(decl) === exportFile)
+        return runsBeforeExport(decl);
+    // A binding of another module: the exporting module's own binding
+    // `nameNode` names holds that module's require, evaluated before the
+    // export, and this file does not assign the binding either.
+    const local = lowerer.checker.getSymbolAtLocation(nameNode);
+    const localDecl = local ? topLevelDeclaration(local) : null;
+    if (!localDecl || !runsBeforeExport(localDecl))
+        return false;
+    let init = localDecl.initializer;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if (!ts.isCallExpression(init) ||
+        !ts.isIdentifier(init.expression) ||
+        init.expression.text !== "require" ||
+        init.arguments.nodes.length !== 1 ||
+        !ts.isStringLiteralLike(init.arguments.nodes[0]))
+        return false;
+    return !fileWritesBinding(sym, exportFile, (ident) => lowerer.resolveValueSymbol(ident));
+}
 /** A top-level CommonJS export statement (see cjsExportAssignmentOf):
  * `exports.f = <expr>` and each expression-valued property of
  * `module.exports = { ... }` assign their pre-registered export globals
@@ -6328,7 +6468,7 @@ function lowerCjsExportStatement(lowerer, cjs) {
     const fenceMutable = (nameNode) => {
         const sym = lowerer.resolveValueSymbol(nameNode);
         const g = sym ? lowerer.globalsBySymbol.get(sym) : undefined;
-        if (g?.mutable) {
+        if (g?.mutable && !unchangedAfterExport(lowerer, nameNode, cjs.expr)) {
             lowerer.unsupported("SC1090", nameNode, `exporting the mutable 'let' binding '${nameNode.text}' by reference (Node copies its VALUE at this statement — declare it const, or export a function that reads it)`);
         }
     };
@@ -6469,7 +6609,7 @@ function lowerCjsSingleValueExport(lowerer, expr, loc) {
         }
         const g = lowerer.globalsBySymbol.get(sym);
         if (g) {
-            if (g.mutable) {
+            if (g.mutable && !unchangedAfterExport(lowerer, rhs, expr)) {
                 lowerer.unsupported("SC1090", rhs, `exporting the mutable 'let' binding '${rhs.text}' by reference (Node copies its VALUE at this statement — declare it const, or export a function that reads it)`);
             }
             return { kind: "block", body: [], loc };
@@ -8529,16 +8669,31 @@ export function lowerForOf(lowerer, stmt) {
         // iterator are awaited as the async-from-sync iterator awaits them, and
         // a value that is not iterable throws Node's TypeError.
         const headT = lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
-        const syncGenerator = (headT?.kind === "generator" && headT.async !== true) || isJsSourceFile(stmt.getSourceFile());
+        // A class instance whose [Symbol.asyncIterator]() (or
+        // [Symbol.iterator]()) returns an iterator object takes the same
+        // checked-dynamic protocol over the boxed instance.
+        const headClass = headT?.kind === "object" ? lowerer.classes.get(headT.className) : undefined;
+        const classAsync = headClass !== undefined && lowerer.findMethodOn(headClass, "sym:asyncIterator") !== null;
+        // Without [Symbol.asyncIterator], the loop opens [Symbol.iterator]() and
+        // awaits its values, as the async-from-sync iterator does.
+        const classSync = headClass !== undefined &&
+            !classAsync &&
+            lowerer.findMethodOn(headClass, "sym:iterator") !== null;
+        const classIterable = classAsync || classSync;
+        const syncGenerator = (headT?.kind === "generator" && headT.async !== true) ||
+            classIterable ||
+            isJsSourceFile(stmt.getSourceFile());
         if (lowerer.ctx.isAsync && (syncGenerator || isUntypedIterable(lowerer, stmt.expression))) {
             const iterable = lowerer.lowerExpr(stmt.expression);
             if (iterable.type.kind === "generator" && iterable.type.async)
                 return lowerForAwaitGenerator(lowerer, stmt, iterable, labels);
             if (iterable.type.kind === "dyn")
                 return lowerForOfDyn(lowerer, stmt, iterable, labels, true);
-            if ((iterable.type.kind === "generator" || isJsSourceFile(stmt.getSourceFile())) &&
+            if ((iterable.type.kind === "generator" ||
+                classIterable ||
+                isJsSourceFile(stmt.getSourceFile())) &&
                 lowerer.dynConvertible(iterable.type))
-                return lowerForOfDyn(lowerer, stmt, lowerer.coerceToExpected(iterable, DYN), labels, true);
+                return lowerForOfDyn(lowerer, stmt, lowerer.coerceToExpected(iterable, DYN), labels, true, classSync && iterable.type.kind === "object");
         }
         // A NodeJS.ReadableStream iterates as the general Readable.
         requestGeneralStreamSurface(lowerer, stmt.expression);
@@ -8759,15 +8914,21 @@ export function lowerForOf(lowerer, stmt) {
                 return lowerForOfGenerator(lowerer, stmt, generator, labels);
             // Class iterables ([Symbol.iterator]() + next() — classIteratorOf)
             // drive the same protocol with ordinary method calls.
-            const cit = lowerer.classIteratorOf(iterable.type);
+            const cit = lowerer.classIteratorOf(iterable.type, { records: true, close: true });
             if (cit)
                 return lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels);
             // A declared [Symbol.iterator] whose shape classIteratorOf refused
             // (an `any`-typed iterator or result, a declared return()/throw()):
             // name the protocol, not the class.
             const info = lowerer.classes.get(iterable.type.className);
+            // In JavaScript the inferred shape is often a union of result
+            // objects: the loop runs the iterator protocol over the boxed value.
+            if (info &&
+                isJsSourceFile(ts.getSourceFileOfNode(stmt)) &&
+                lowerer.findMethodOn(info, "sym:iterator"))
+                return lowerForOfDyn(lowerer, stmt, lowerer.coerceInto(stmt.expression, iterable, DYN), labels);
             if (info && lowerer.findMethodOn(info, "sym:iterator")) {
-                lowerer.unsupported("SC1090", stmt.expression, `for-of over this [Symbol.iterator] shape (the method must take no parameters and return an object whose zero-parameter next() returns a { value, done? } record with a boolean done; iterator classes declaring return()/throw() stay out — IteratorClose has no lowering)`);
+                lowerer.unsupported("SC1090", stmt.expression, `for-of over this [Symbol.iterator] shape (the method must take no parameters and return an object whose zero-parameter next() returns a { value, done? } record with a boolean done, and whose return(), if any, takes no parameters and returns an object)`);
             }
         }
         if (iterable.type.kind === "record" && lowerer.shapes.get(iterable.type.shapeId)?.tuple) {
@@ -9601,11 +9762,13 @@ function lowerForOfMatchAll(lowerer, stmt, call, stored) {
  *     } }
  *
  * A result record with NO done field never terminates — exactly JS
- * (undefined is falsy forever; Node loops forever too). No
- * IteratorClose: classIteratorOf already refused iterator classes
- * declaring return()/throw(), so a break exits with nothing to close.
- * `done: true` results bind nothing (the loop breaks before the value
- * read), matching JS's ignore-the-final-value rule. */
+ * (undefined is falsy forever; Node loops forever too). An iterator with
+ * return() is closed when the loop leaves after a value arrived (break,
+ * return, or a throw from the body), as IteratorClose does: a done flag
+ * set around each step guards the call in a finally, and after a throw
+ * from the body an error from return() is dropped. A throw from next()
+ * does not close. `done: true` results bind nothing (the loop breaks
+ * before the value read), matching JS's ignore-the-final-value rule. */
 function lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels) {
     let exprTarget = null;
     let exprTargetNode = null;
@@ -9639,7 +9802,22 @@ function lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels) {
         const r = lowerer.declareHiddenLocal("%cir", cit.resultT);
         const recvRef = { kind: "varRef", localId: recv.id, type: iterable.type, loc };
         const itRef = () => ({ kind: "varRef", localId: it.id, type: cit.iterT, loc });
+        const nextRead = lowerer.classIteratorNextRead(cit, itRef(), loc);
+        const next = nextRead ? lowerer.declareHiddenLocal("%cin", nextRead.type) : null;
         const rRef = () => ({ kind: "varRef", localId: r.id, type: cit.resultT, loc });
+        const done = cit.hasReturn ? lowerer.declareHiddenLocal("%cid", BOOL) : null;
+        if (done)
+            done.mutable = true;
+        const setDone = (value) => done
+            ? [
+                {
+                    kind: "assign",
+                    localId: done.id,
+                    value: { kind: "boolLit", value, type: BOOL, loc },
+                    loc,
+                },
+            ]
+            : [];
         const varTarget = exprTarget ?? (decl ? forOfVarTarget(lowerer, decl) : null);
         const x = varTarget
             ? lowerer.declareHiddenLocal("%vof", cit.valueT)
@@ -9647,10 +9825,11 @@ function lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels) {
         const xRef = { kind: "varRef", localId: x.id, type: cit.valueT, loc };
         const blame = decl?.name ?? exprTargetNode ?? stmt.initializer;
         const head = [
+            ...setDone(true),
             {
                 kind: "varDecl",
                 localId: r.id,
-                init: lowerer.classIteratorNextCall(cit, itRef(), loc),
+                init: lowerer.classIteratorNextCall(cit, itRef(), next ? varRef(next.id, next.type, loc) : null, loc),
                 loc,
             },
             ...(cit.hasDone
@@ -9694,8 +9873,16 @@ function lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels) {
                     },
                 ]
                 : []),
+            ...setDone(false),
         ];
         const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
+        const loop = {
+            kind: "while",
+            cond: { kind: "boolLit", value: true, type: BOOL, loc },
+            body: [...head, ...body],
+            ...(labels && { labels }),
+            loc,
+        };
         return {
             kind: "block",
             body: [
@@ -9706,13 +9893,48 @@ function lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels) {
                     init: lowerer.classIteratorOpenCall(cit, recvRef, loc),
                     loc,
                 },
-                {
-                    kind: "while",
-                    cond: { kind: "boolLit", value: true, type: BOOL, loc },
-                    body: [...head, ...body],
-                    ...(labels && { labels }),
-                    loc,
-                },
+                ...(next && nextRead
+                    ? [{ kind: "varDecl", localId: next.id, init: nextRead, loc }]
+                    : []),
+                ...(done
+                    ? [
+                        {
+                            kind: "varDecl",
+                            localId: done.id,
+                            init: { kind: "boolLit", value: true, type: BOOL, loc },
+                            loc,
+                        },
+                        {
+                            kind: "tryCatch",
+                            tryBody: [loop],
+                            catchBody: null,
+                            catchLocalId: null,
+                            dropFinallyErrors: true,
+                            finallyBody: [
+                                {
+                                    kind: "if",
+                                    cond: {
+                                        kind: "unary",
+                                        op: "!",
+                                        operand: { kind: "varRef", localId: done.id, type: BOOL, loc },
+                                        type: BOOL,
+                                        loc,
+                                    },
+                                    then: [
+                                        {
+                                            kind: "exprStmt",
+                                            expr: lowerer.classIteratorReturnCall(cit, itRef(), loc),
+                                            loc,
+                                        },
+                                    ],
+                                    else_: null,
+                                    loc,
+                                },
+                            ],
+                            loc,
+                        },
+                    ]
+                    : [loop]),
             ],
             loc,
         };
@@ -9724,7 +9946,7 @@ function lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels) {
 /** A checked IteratorRecord stays live throughout the loop. Cache next once,
  * read done before value, and close only after a yielded value has arrived.
  * Abrupt body throws retain precedence over errors raised by return(). */
-function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false) {
+function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false, syncOpen = false) {
     const loc = locOf(stmt);
     const spell = notIterableSpelling(stmt.expression, asyncLoop ? "async iterable" : "iterable");
     const iterator = lowerer.declareHiddenLocal("%dofIterator", DYN);
@@ -9734,6 +9956,7 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false) {
     done.mutable = true;
     const value = lowerer.declareHiddenLocal("%dofValue", DYN);
     const returned = lowerer.declareHiddenLocal("%dofReturn", DYN);
+    const closed = lowerer.declareHiddenLocal("%dofClosed", DYN);
     const needsClose = lowerer.declareHiddenLocal("%dofNeedsClose", BOOL);
     needsClose.mutable = true;
     const error = lowerer.declareHiddenLocal("%dofError", CAUGHT);
@@ -9798,9 +10021,10 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false) {
             },
             then: [
                 {
-                    kind: "exprStmt",
+                    kind: "varDecl",
+                    localId: closed.id,
                     // return()'s (awaited) result must be an object, as for next().
-                    expr: asyncLoop
+                    init: asyncLoop
                         ? check(awaitDyn({
                             kind: "dynCall",
                             callee: varRef(returned.id, DYN, loc),
@@ -9813,6 +10037,27 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false) {
                         : call(varRef(returned.id, DYN, loc)),
                     loc,
                 },
+                // A synchronous iterator's return() result is read as the
+                // async-from-sync iterator reads it: done, then the value, which is
+                // awaited, so a rejected promise there rejects the loop.
+                ...(syncIterator
+                    ? [
+                        {
+                            kind: "if",
+                            cond: varRef(syncIterator.id, BOOL, loc),
+                            then: [
+                                { kind: "exprStmt", expr: get(varRef(closed.id, DYN, loc), "done"), loc },
+                                {
+                                    kind: "exprStmt",
+                                    expr: awaitDyn(get(varRef(closed.id, DYN, loc), "value")),
+                                    loc,
+                                },
+                            ],
+                            else_: null,
+                            loc,
+                        },
+                    ]
+                    : []),
             ],
             else_: null,
             loc,
@@ -9921,7 +10166,7 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false) {
                     localId: iterator.id,
                     init: check({
                         kind: "libCall",
-                        fn: asyncLoop ? "dyn.asyncIteratorOpen" : "dyn.iterator",
+                        fn: asyncLoop && !syncOpen ? "dyn.asyncIteratorOpen" : "dyn.iterator",
                         args: [iterable, { kind: "strLit", value: spell, type: STRING, loc }],
                         type: DYN,
                         loc,
@@ -9933,13 +10178,15 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false) {
                         {
                             kind: "varDecl",
                             localId: syncIterator.id,
-                            init: {
-                                kind: "libCall",
-                                fn: "dyn.asyncIteratorWasSync",
-                                args: [],
-                                type: BOOL,
-                                loc,
-                            },
+                            init: syncOpen
+                                ? { kind: "boolLit", value: true, type: BOOL, loc }
+                                : {
+                                    kind: "libCall",
+                                    fn: "dyn.asyncIteratorWasSync",
+                                    args: [],
+                                    type: BOOL,
+                                    loc,
+                                },
                             loc,
                         },
                     ]
@@ -10341,6 +10588,7 @@ function lowerForIn(lowerer, stmt) {
             // them (accessor slots live outside declaredOrder), so the loop
             // fences rather than skip keys.
             fencePerfEntryKeyWalk(lowerer, receiver.type, stmt.expression, "for-in");
+            fenceX509KeyWalk(lowerer, receiver.type, stmt.expression, "for-in");
             if (shapeHasAccessorSlots(rShape)) {
                 lowerer.unsupported("SC1090", stmt.expression, "for-in over a shape carrying get/set accessor properties (Node visits the accessor names — the static key walk cannot; read the properties explicitly)");
             }