@scriptc/compiler 0.3.0 → 0.3.2

package/dist/frontend/lowering/lowerer.js

@@ -1,9 +1,12 @@
+import { lifetimeRegionType, lowerLifetimeRegionCall, lowerLifetimeRegionNew, } from "./lifetime-regions.js";
+import { isExperimentalDeclarationFile } from "../experimental-import.js";
 import { checkCycleBindingAccesses, refuseUncheckedCycleReads, } from "./cycle-initialization.js";
 import { identityPreservingWidening } from "./coercions/identity.js";
 import { scanDivergences } from "./divergences.js";
 import { checkedClassAssertion } from "./class-assertions.js";
 import { narrowStoredClassValue, narrowGenericClassValue } from "./class-unions.js";
 import { isOptionalProcessStreamProperty } from "./builtins/process.js";
+import { isSettledIteratorValueRead } from "./lower-generators.js";
 import { concreteCollectionNarrow } from "./collection-narrowing.js";
 import { lowerWorkerMetadata } from "./builtins/workers.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../ir/build.js";
@@ -15,7 +18,8 @@ import { widthCoerce, applyWidthLift, unionRecordWidthHelper, recordWidthHelper,
 import { funcReturnWidthAdapter, coercibleValue, cleanFuncAdaptable, funcCoerceAdapter, spawnResFnAdapterPlan, spawnResFnAdapter, } from "./coercions/function-adapters.js";
 import { unionRetagMappable, narrowedRetagHelper, strandedUnitTrap, strandedCoercionTrap, recordUnionWrapHelper, unionRetagHelper, narrowedArmHelper, checkedNarrowCall, checkedNarrowOperand, deferredReadHelper, } from "./coercions/unions.js";
 import { lowerUtilTypeValue, pathModuleValue, utilTypesModuleValue, } from "./lower-builtin-values.js";
-import { transformStmtList } from "../../ir/traverse.js";
+import { devirtualizeVirtualCalls } from "./devirtualize.js";
+import { foldRegexSpanReads } from "./regex-span-reads.js";
 import { RuntimeOptionalProvenance } from "./runtime-optional-provenance.js";
 import { presentAtUse, reassignedBindings } from "./runtime-optional-guards.js";
 import { NarrowingStability } from "./narrowing-stability.js";
@@ -33,6 +37,8 @@ import { InternalCompilerError } from "../../errors.js";
 import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.js";
 import { ClassDynamicDispatch, trackClassFieldCreation } from "./class-dynamic-dispatch.js";
 import { ClassProtocols } from "./class-protocols.js";
+import { earlyReadVarSymbols } from "./var-hoisting.js";
+import { recordTextCodecClass } from "../../ir/ir.js";
 import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
 import { finalizeClassMethodValues } from "./class-method-values.js";
 export { newFnCtx } from "./function-context.js";
@@ -60,7 +66,7 @@ import { unsupportedAnyOperationDiag, blockedBindingUseDiag, checkerPanicDiag, c
 import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
-import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, FETCH_AMBIENT_TYPES, isUnitOnlyTsType, isWorkerHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
+import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, FETCH_AMBIENT_TYPES, isOsConstantsSymbol, isUnitOnlyTsType, isWorkerHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
 import { builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalNameOf, stdlibGlobalMember, nodeTypesOnlySymbol, } from "./surfaces.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules, appendForkModules, appendWorkerModules, } from "./lower-modules.js";
 import { prepareCjsModuleGraph } from "./lower-node-module.js";
@@ -77,6 +83,7 @@ import { lowerCall, lowerPromiseMethodCall, lowerFilterNarrowCall } from "./lowe
 import { lowerFfiCall, validateFfiImports } from "./native-ffi.js";
 import { isTopLevelFnSymbol, lowerNestedFunctionDecl, lowerLambda, lowerFunction, } from "./lower-functions.js";
 import { lowerArrayMethodCall } from "./containers/array-methods.js";
+import { fuseArrayPipelines } from "./containers/array-pipelines.js";
 import { lowerMapMethodCall, lowerMapForEachCall, lowerSetMethodCall, lowerSetForEachCall, } from "./containers/collection-methods.js";
 import { lowerEnvToPairsHelper } from "./containers/indexed-objects.js";
 import { lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew } from "./containers/bytes.js";
@@ -103,13 +110,14 @@ import { lowerReadlineMethodCall } from "./builtins/readline.js";
 import { lowerDiagnosticsChannelMethodCall, lowerDiagnosticsChannelProperty, lowerAsyncLocalStorageMethodCall, lowerTracingChannelMethodCall, lowerTracingChannelProperty, } from "./builtins/async-context.js";
 import { lowerErrorCodeProperty } from "./builtins/errors.js";
 import { lowerProcessProperty, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerProcessStreamProperty, } from "./builtins/process.js";
-import { isConsoleLog, consoleCallMember } from "./builtins/console.js";
+import { consoleCallMember, consoleMethodMember, isConsoleLog, } from "./builtins/console.js";
+import { lowerConsoleNew } from "./lower-console.js";
 import { lowerNumberStaticCall, lowerNumberStaticProperty } from "./builtins/numbers.js";
 import { lowerDateCall } from "./builtins/dates.js";
 import { lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, } from "./builtins/constants.js";
 import { lowerStringStaticCall, lowerStringLastIndexOfCall } from "./builtins/strings.js";
 import { lowerPromiseStaticCall } from "./builtins/promises.js";
-import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
+import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerEventTargetNew, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty, lowerTlsRootCertificates, } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty, } from "./lower-test.js";
@@ -1114,6 +1122,9 @@ export class Lowerer {
     /** All storage slots widened for runtime absence, including slots whose
      * current control-flow branch has temporarily narrowed the value. */
     runtimeOptionalStorageLocals = new Set();
+    /** `var` bindings code can read before their first store
+     * (var-hoisting.ts): their storage holds undefined until then. */
+    earlyReadVars = new Set();
     /** Globals whose checker-bare type was widened because an indexed read can
      * carry undefined at runtime. Identifier reads keep the union tag so
      * typeof and later boundaries observe the real value. */
@@ -1127,6 +1138,9 @@ export class Lowerer {
      * prepass. This includes explicit annotations: unchecked TS annotations do
      * not prove that an array property read produced a value. */
     runtimeOptionalBindingTypes = new Map();
+    /** Set when a match result lowers to execGroups/matchGroups, the inputs
+     * of regex span folding. */
+    regexGroupResults = false;
     /** Bindings that receive an unchecked indexed read (or a value derived
      * from one) through an initializer or assignment. The checker narrows a
      * declared optional binding to that read's bare type, so presence tests
@@ -1471,6 +1485,9 @@ export class Lowerer {
     /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
      * interned per method + element/callback-result type: key → fn name. */
     arrHofHelpers = new Map();
+    /** What each array-HOF helper computes, keyed by helper name: the chain
+     * fusion pass reads it to recognize pipelines of helper calls. */
+    arrHofInfo = new Map();
     /** Per-arm calls through union-typed class receivers, interned by the
      * receiver union, member, completed argument ABI, and result type. */
     unionCallHelpers = new Map();
@@ -1650,6 +1667,12 @@ export class Lowerer {
     workerTargets;
     workerTargetIdByPath = new Map();
     usesWorkers = false;
+    /** The program constructs a LifetimeRegion (lifetime-regions.ts). */
+    usesLifetimeRegions = false;
+    /** Per-directory answers of experimental-import.ts's declaration-file test. */
+    experimentalFiles = new Map();
+    /** Interned LifetimeRegion.run helpers, by callback type key. */
+    regionRunHelpers = new Map();
     forkTargetIdByPath = new Map();
     /** Namespace ModuleBlocks this program lowers, filled by splitFiles:
      * "flattened" — an instantiated namespace whose body joined the file's
@@ -1756,6 +1779,9 @@ export class Lowerer {
     /** Import-cycle bindings with an initialization flag, by global id, and
      * the top-level statements declaring them (cycle-initialization.ts). */
     cycleInitFlags = new Map();
+    /** Initialization flags of classes reachable before their statement ran,
+     * by class name (cycle-initialization.ts). */
+    classInitFlags = new Map();
     cycleInitDeclarations = new Map();
     get ctx() {
         const top = this.fnStack[this.fnStack.length - 1];
@@ -1776,6 +1802,12 @@ export class Lowerer {
      * can contain any retained descendant, but importing its declaration
      * alone does not make every descendant constructible. */
     constructedClasses = null;
+    /** Set while a subclass constructor's super() call notes its base
+     * constructor edge: that edge does not instantiate the base exactly. */
+    superConstructorEdge = false;
+    /** Set when the async generator `return` being lowered awaited its
+     * promise operand (returnedPromiseAwait). */
+    returnAwaitedPromise = false;
     virtualEdges = new Map();
     classCanBeConstructed(info) {
         return (this.constructedClasses === null ||
@@ -1955,6 +1987,9 @@ export class Lowerer {
             // fileTag is filled just below; the hook is only ever CALLED during
             // lowering, long after the constructor completes.
             isProgramFile: (sf) => this.fileTag.has(sf),
+            lifetimeRegionClass: (decl) => isExperimentalDeclarationFile(decl.getSourceFile(), this.experimentalFiles)
+                ? lifetimeRegionType(this)
+                : null,
             moduleNamespaceId: (type) => this.moduleNamespaceIdOfType(type),
         };
         // Modules reachable only through literal import() joined
@@ -2961,7 +2996,6 @@ export class Lowerer {
         const signatureBySymbol = new Map();
         const methodFamilies = new Map();
         const familyBySymbol = new Map();
-        const optionalMethodFamilies = new Set();
         for (const [symbol, sig] of this.fnSigsBySymbol)
             signatureBySymbol.set(symbol, { params: sig.params, returnType: sig.returnType, top: sig });
         for (const decl of fnDecls) {
@@ -3002,6 +3036,17 @@ export class Lowerer {
                     familyBySymbol.set(symbol, family);
                 }
             }
+            // Static methods never share a dispatch slot: each is its own family.
+            if (info.staticMethods) {
+                for (const sig of info.staticMethods.values()) {
+                    const name = sig.member.name;
+                    if (!(ts.isIdentifier(name) || ts.isStringLiteral(name)))
+                        continue;
+                    const symbol = symbolOf(name);
+                    if (symbol && !signatureBySymbol.has(symbol))
+                        signatureBySymbol.set(symbol, { params: sig.params, returnType: sig.ret, method: sig });
+                }
+            }
         }
         const mappedOrNull = (node) => panicSafe(() => this.mapTypeOf(this.typeOf(node)), null);
         const nanCoded = new NanCodedReads({
@@ -3221,6 +3266,10 @@ export class Lowerer {
                 return true;
             if (ts.isPropertyAccessExpression(e) && isOptionalProcessStreamProperty(this, e))
                 return true;
+            if (ts.isPropertyAccessExpression(e) && isSettledIteratorValueRead(this, e))
+                return true;
+            if (ts.isPropertyAccessExpression(e) && isOsConstantsSymbol(symbolOf(e.expression), this))
+                return true;
             if (ts.isCallExpression(e) && this.runtimeOptionalReduceTypes.has(e))
                 return true;
             if (ts.isCallExpression(e) &&
@@ -3252,6 +3301,11 @@ export class Lowerer {
                 const symbol = symbolOf(e.name);
                 if (symbol && optionalSymbols.has(symbol))
                     return true;
+                // A getter read is a call of its body.
+                if (symbol &&
+                    (symbol.flags & ts.SymbolFlags.GetAccessor) !== 0 &&
+                    optionalReturns.has(symbol))
+                    return true;
             }
             if (ts.isCallExpression(e) && ts.isIdentifier(e.expression)) {
                 const symbol = callableSymbolOf(e.expression);
@@ -3326,6 +3380,27 @@ export class Lowerer {
                 return null;
             return { kind: "union", unionId: this.unions.intern([F64, STRING]) };
         };
+        /** The union of primitive result types, or null when any is missing or
+         * not a number, string or boolean (or a union of them). */
+        const joinPrimitiveTypes = (types) => {
+            const arms = new Map();
+            for (const type of types) {
+                if (!type)
+                    return null;
+                const parts = type.kind === "union" ? this.unions.get(type.unionId)?.arms : [type];
+                if (!parts)
+                    return null;
+                for (const arm of parts) {
+                    if (arm.kind !== "f64" && arm.kind !== "string" && arm.kind !== "bool")
+                        return null;
+                    arms.set(typeKey(arm), arm);
+                }
+            }
+            const sorted = [...arms.entries()].sort(([a], [b]) => (a < b ? -1 : 1)).map(([, t]) => t);
+            if (sorted.length === 1)
+                return sorted[0];
+            return { kind: "union", unionId: this.unions.intern(sorted) };
+        };
         const noteField = (decl, name) => {
             if (!ts.isIdentifier(decl.name))
                 return false;
@@ -3487,6 +3562,19 @@ export class Lowerer {
                     found = true;
             return found;
         };
+        /** A return of a var that code can read before its first store. */
+        const returnsEarlyVar = (fn) => {
+            const early = (e) => {
+                const read = peel(e);
+                if (!ts.isIdentifier(read))
+                    return false;
+                const symbol = symbolOf(read);
+                return symbol !== null && this.earlyReadVars.has(symbol);
+            };
+            if (fn.body && !ts.isBlock(fn.body))
+                return early(fn.body);
+            return returnsOf(fn).some(early);
+        };
         const jsLambdas = [];
         // TypeScript lambdas keep the checker's inferred return type, which
         // spells a missing read as its bare element type and `read ?? "text"`
@@ -4333,9 +4421,6 @@ export class Lowerer {
                             if (arg &&
                                 (this.typeOf(arg).flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) === 0)
                                 continue;
-                            const family = familyBySymbol.get(symbol);
-                            if (family)
-                                optionalMethodFamilies.add(family);
                             for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
                                 const shape = signatureBySymbol.get(target)?.params[i];
                                 if (!shape || shape.mode !== "required")
@@ -4452,8 +4537,6 @@ export class Lowerer {
                         // Promote every implementation and its parameter bindings so
                         // downstream calls and returns see the same optional value.
                         const family = familyBySymbol.get(symbol);
-                        if (family)
-                            optionalMethodFamilies.add(family);
                         for (const target of family ?? [symbol]) {
                             const parameterShape = signatureBySymbol.get(target)?.params[i];
                             if (!parameterShape)
@@ -4501,6 +4584,19 @@ export class Lowerer {
             }
             return changed;
         };
+        // A `var` that code can read before its first store holds undefined
+        // there, whatever its declared type.
+        for (const symbol of earlyReadVarSymbols(this, sourceFiles)) {
+            // Text codec bindings keep their own presence-checked storage.
+            const declaration = this.checker.valueDeclarationOf(symbol);
+            const mapped = declaration && ts.isVariableDeclaration(declaration)
+                ? mappedOrNull(declaration.name)
+                : null;
+            if (mapped?.kind === "record" && recordTextCodecClass(this.shapes.get(mapped.shapeId)))
+                continue;
+            optionalSymbols.add(symbol);
+            this.earlyReadVars.add(symbol);
+        }
         let changed = true;
         while (changed) {
             changed = false;
@@ -4518,8 +4614,10 @@ export class Lowerer {
                 if (scanReturns(symbol, decl))
                     changed = true;
             for (const fn of tsLambdas) {
-                // An annotated return is the author's contract, as for parameters.
-                if (fn.type)
+                // An annotated return is the author's contract, as for parameters,
+                // except that a var read before its first store is undefined
+                // whatever the annotation says.
+                if (fn.type && !returnsEarlyVar(fn))
                     continue;
                 const mapped = this.mapTypeOf(this.typeOf(fn));
                 if (mapped?.kind !== "func")
@@ -4580,18 +4678,35 @@ export class Lowerer {
                     changed = true;
                 }
             }
-            // Every implementation of a virtual slot must retain the same ABI,
-            // including when just one body forwards an omitted parameter.
-            for (const family of optionalMethodFamilies) {
-                if (!family.some((symbol) => optionalReturns.has(symbol)))
+            // Every implementation of a virtual slot must retain the same ABI:
+            // when one body can return undefined at runtime (an unchecked element
+            // read, a forwarded omitted parameter), the abstract or base
+            // declaration and every override return the widened type too.
+            for (const family of methodFamilies.values()) {
+                if (family.length < 2)
                     continue;
-                for (const symbol of family) {
+                const optional = family.some((symbol) => optionalReturns.has(symbol));
+                for (const symbol of optional ? family : []) {
                     if (!optionalReturns.has(symbol)) {
                         optionalReturns.add(symbol);
                         provenance?.note("return", functionDeclBySymbol.get(symbol), undefined, "(override family)");
                         changed = true;
                     }
                 }
+                // A primitive-widened result (`names[i] + 1` is NaN for a missing
+                // string) likewise becomes the slot's result for every member.
+                if (!family.some((symbol) => arithmeticReturns.has(symbol)))
+                    continue;
+                const joined = joinPrimitiveTypes(family.map((symbol) => arithmeticReturns.get(symbol) ?? signatureBySymbol.get(symbol)?.returnType));
+                if (!joined)
+                    continue;
+                for (const symbol of family) {
+                    const previous = arithmeticReturns.get(symbol);
+                    if (previous && typeEquals(previous, joined))
+                        continue;
+                    arithmeticReturns.set(symbol, joined);
+                    changed = true;
+                }
             }
         }
         // NaN-coded slots convert optional values on entry instead of holding
@@ -4959,6 +5074,8 @@ export class Lowerer {
     /** Final retention, pruning, and module assembly shared by ordinary emit
      * and the retained reachability worklist. */
     finishModule(functions) {
+        if (this.diags.length === 0)
+            fuseArrayPipelines(this, functions);
         finalizeClassMethodValues(this, functions);
         trackClassFieldCreation(this, functions);
         // Globals typed by a class that never REGISTERED (a JS class whose
@@ -5060,6 +5177,7 @@ export class Lowerer {
                 globals: this.globalsList,
                 entry: ENTRY_NAME,
                 ...(this.usesWorkers ? { workers: true } : {}),
+                ...(this.usesLifetimeRegions ? { lifetimeRegions: true } : {}),
                 ...(isNodeEsmFile(this.entry, this.program) ? {} : { commonJsEntry: true }),
                 ...(this.ffiImports.length > 0 ? { ffiImports: [...this.ffiImports] } : {}),
             };
@@ -5244,6 +5362,8 @@ export class Lowerer {
         for (const info of this.classes.values()) {
             if (info.builtinError)
                 continue; // runtime-provided; nothing lowers
+            if (info.lifetimeRegion)
+                continue; // synthesized with the class
             // Generic-class INSTANTIATIONS (and mixin instantiations) are
             // demand-driven, not units: their members lower unconditionally in
             // the instance drain below — the generic-fn instance rule.
@@ -5343,11 +5463,17 @@ export class Lowerer {
         };
         const reachable = new Set();
         this.constructedClasses = new Set();
+        // Every constructor edge except super() may create an instance of
+        // exactly that class (`new C`, class values, library roots, dynamic
+        // construction, ...).
+        const instantiated = new Set();
         const queue = [];
         const loweredUnits = new Map();
         const initFunctions = [];
         const instanceFunctions = [];
         this.onEdge = (name) => {
+            if (!this.superConstructorEdge && name.endsWith(".constructor"))
+                instantiated.add(name.slice(1, -".constructor".length));
             if (reachable.has(name))
                 return;
             reachable.add(name);
@@ -5553,35 +5679,17 @@ export class Lowerer {
             ...this.liftedFns,
             ...this.implicitFns,
         ];
-        // The worklist can leave a virtual site with only its base method.
+        if (this.regexGroupResults)
+            for (const fn of functions)
+                foldRegexSpanReads(this, fn);
+        // The worklist can leave a virtual site with a single implementation.
         // Devirtualize after construction/override reachability has settled.
-        for (const fn of functions)
-            fn.body = transformStmtList(fn.body, {
-                stmt: (statement) => statement,
-                expr: (expression) => {
-                    if (expression.kind !== "virtualCall")
-                        return expression;
-                    const info = this.classes.get(expression.className);
-                    const method = info && this.findMethodOn(info, expression.method);
-                    if (!method ||
-                        method.sig.abstract ||
-                        [...this.classes.values()].some((candidate) => this.isSubclassOf(candidate.def.name, expression.className) &&
-                            candidate.def.name !== expression.className &&
-                            candidate.methods.has(expression.method) &&
-                            reachable.has(`%${candidate.def.name}.${expression.method}`)))
-                        return expression;
-                    return {
-                        kind: "call",
-                        callee: `%${method.declarer.def.name}.${expression.method}`,
-                        args: [
-                            this.upcastTo(expression.args[0], method.declarer.def.name),
-                            ...expression.args.slice(1),
-                        ],
-                        type: expression.type,
-                        loc: expression.loc,
-                    };
-                },
-            });
+        devirtualizeVirtualCalls(this, functions, {
+            reachable,
+            instantiated,
+            library: extraRoots !== undefined,
+            files: parts.map((fp) => fp.sf),
+        });
         this.reachableForArtifacts = reachable;
         return { reachable, result: this.finishModule(functions) };
     }
@@ -5591,6 +5699,17 @@ export class Lowerer {
         if (this.onEdge)
             this.onEdge(name);
     }
+    /** A subclass constructor's super() edge: the base constructor runs, but
+     * no instance of exactly the base class is created. */
+    noteSuperConstructorEdge(name) {
+        this.superConstructorEdge = true;
+        try {
+            this.noteEdge(name);
+        }
+        finally {
+            this.superConstructorEdge = false;
+        }
+    }
     /** Discovery hook for virtual dispatch: a virtualCall on `info`'s static
      * class reaches the nearest declaration at/above it plus every override
      * on a STRICT descendant (receivers of sibling branches can't flow into
@@ -7391,10 +7510,10 @@ export class Lowerer {
     }
     /** The value of a `return` statement. In an async function `return p`
      * where p is a promise flattens (JS: the returned promise's settlement
-     * becomes the async function's result), so it lowers exactly as
-     * `return await p` — the awaitExpr parks the fiber and re-throws
-     * rejections, which IS the flattening. Everything else flows into the
-     * function's return slot through the usual coercion path. */
+     * becomes the async function's result) through an adopting awaitExpr,
+     * which parks the fiber and re-throws rejections after the adoption's
+     * then-job turn. Everything else flows into the function's return slot
+     * through the usual coercion path. */
     /** The value of `return <expr>` against the context's declared return —
      * or NULL for a bare return: `return undefined`/`return null` in a
      * void-returning function (`{ bar() { return undefined } }`, inferred
@@ -7425,11 +7544,40 @@ export class Lowerer {
         if (expected.kind === "void" && e.kind === "unitLit")
             return null;
         if (this.ctx.isAsync && e.type.kind === "promise" && expected.kind !== "promise") {
-            const awaited = { kind: "awaitExpr", value: e, type: e.type.inner, loc: e.loc };
+            const awaited = this.returnedPromiseAwait(e);
             return this.coerceInto(node, awaited, expected);
         }
         return this.coerceInto(node, e, expected);
     }
+    /** Whether a promise returned here resolves the function's own promise
+     * by adoption (async functions; async generators await their return
+     * operand instead). */
+    adoptsReturnedPromise() {
+        return this.ctx.isAsync === true && !this.ctx.generator;
+    }
+    /** `return p` of a promise into a non-promise result `R` (a void result
+     * drops the settled value; widening keeps the adopting await the return's
+     * own value). */
+    adoptingReturn(e, R, coerce) {
+        const loc = e.loc;
+        if (R.kind !== "void")
+            return { kind: "return", value: coerce(this.returnedPromiseAwait(e)), loc };
+        const widened = e.type.kind === "promise" && e.type.inner.kind !== "void"
+            ? { kind: "promiseVoidWiden", value: e, type: { kind: "promise", inner: VOID }, loc }
+            : e;
+        return { kind: "return", value: this.returnedPromiseAwait(widened), loc };
+    }
+    /** The await a returned promise `e` lowers to: adopting in async
+     * functions (one then-job turn first, outside the function's handlers). */
+    returnedPromiseAwait(e) {
+        if (e.type.kind !== "promise")
+            throw new InternalCompilerError("returned-promise await of a non-promise");
+        if (!this.adoptsReturnedPromise()) {
+            this.returnAwaitedPromise = true;
+            return { kind: "awaitExpr", value: e, type: e.type.inner, loc: e.loc };
+        }
+        return { kind: "awaitExpr", value: e, type: e.type.inner, adopt: true, loc: e.loc };
+    }
     /** `return <expr>` lowered as a STATEMENT against the declared return.
      * Void-returning contexts get the JS drop: a contextually void-typed
      * function may return a value (`fv = function() { return 0; }` into a
@@ -7437,11 +7585,33 @@ export class Lowerer {
      * caller never sees a value, so the return goes out bare. Async
      * void-inner returns still resolve a returned promise first. */
     lowerReturnStmt(node, loc) {
+        if (!(this.ctx.isAsync === true && this.ctx.generator))
+            return this.lowerReturnOf(node, loc);
+        // An async generator's `return x` awaits x; for a promise that await
+        // is the returned-promise await, and the return needs no other turn.
+        const saved = this.returnAwaitedPromise;
+        this.returnAwaitedPromise = false;
+        const s = this.lowerReturnOf(node, loc);
+        const awaited = this.returnAwaitedPromise;
+        this.returnAwaitedPromise = saved;
+        if (!awaited)
+            return s;
+        if (s.kind === "return")
+            return { ...s, awaited: true };
+        if (s.kind === "block" && s.body.at(-1)?.kind === "return") {
+            const last = s.body.at(-1);
+            return { ...s, body: [...s.body.slice(0, -1), { ...last, awaited: true }] };
+        }
+        return s;
+    }
+    lowerReturnOf(node, loc) {
         const expected = this.ctx.returnType;
         if (expected.kind === "void") {
             let e = this.lowerExpr(node);
             if (this.ctx.isAsync && e.type.kind === "promise") {
-                e = { kind: "awaitExpr", value: e, type: e.type.inner, loc: e.loc };
+                if (this.adoptsReturnedPromise())
+                    return this.adoptingReturn(e, VOID, (x) => x);
+                e = this.returnedPromiseAwait(e);
             }
             if (e.kind === "unitLit")
                 return { kind: "return", value: null, loc };
@@ -8873,7 +9043,8 @@ export class Lowerer {
         // dispatch. The general identifier-call paths have no lowering for a
         // promise-returning ambient global, and `import` is a keyword callee no
         // identifier path matches.
-        return (lowerFfiCall(this, expr) ??
+        return (lowerLifetimeRegionCall(this, expr) ??
+            lowerFfiCall(this, expr) ??
             lowerFetchCall(this, expr) ??
             lowerStaticFetchCompanionCall(this, expr) ??
             lowerStaticAbortControllerCall(this, expr) ??
@@ -9008,10 +9179,13 @@ export class Lowerer {
         return inheritsBuiltinEmitterCtor(this, info);
     }
     lowerNew(expr) {
-        const builtin = lowerAbortControllerNew(this, expr) ??
+        const builtin = lowerLifetimeRegionNew(this, expr) ??
+            lowerAbortControllerNew(this, expr) ??
+            lowerEventTargetNew(this, expr) ??
             lowerFetchWebNew(this, expr) ??
             lowerResponseNew(this, expr) ??
-            lowerStaticReadableStreamNew(this, expr);
+            lowerStaticReadableStreamNew(this, expr) ??
+            lowerConsoleNew(this, expr);
         return (builtin ?? this.withRuntimeOptionalClassValue(expr.expression, () => lowerNew(this, expr)));
     }
     lowerFieldRead(expr) {
@@ -9062,6 +9236,9 @@ export class Lowerer {
     consoleCallMember(call) {
         return consoleCallMember(this, call);
     }
+    consoleMethodMember(call) {
+        return consoleMethodMember(this, call);
+    }
     /* ── standard library (process + node:fs) ─────────────────────────── */
     builtinImportOf(ident) {
         return builtinImportOf(this, ident);
@@ -9288,6 +9465,10 @@ export class Lowerer {
         if (bi.module === "http" && bi.member === "STATUS_CODES") {
             return { kind: "libCall", fn: "http.statusCodes", args: [], type: DYN, loc };
         }
+        // os.constants: the runtime's null-prototype constants object.
+        if (bi.module === "os" && bi.member === "constants") {
+            return { kind: "libCall", fn: "os.constants", args: [], type: DYN, loc };
+        }
         // tls.rootCertificates through the namespace: the same runtime-valued
         // constant the named-import read lowers to.
         {