@scriptc/compiler 0.3.0 → 0.3.1

package/dist/frontend/lowering/lowerer.js

@@ -15,7 +15,7 @@ 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 { RuntimeOptionalProvenance } from "./runtime-optional-provenance.js";
 import { presentAtUse, reassignedBindings } from "./runtime-optional-guards.js";
 import { NarrowingStability } from "./narrowing-stability.js";
@@ -77,6 +77,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";
@@ -104,6 +105,7 @@ import { lowerDiagnosticsChannelMethodCall, lowerDiagnosticsChannelProperty, low
 import { lowerErrorCodeProperty } from "./builtins/errors.js";
 import { lowerProcessProperty, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerProcessStreamProperty, } from "./builtins/process.js";
 import { isConsoleLog, consoleCallMember } 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";
@@ -1471,6 +1473,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();
@@ -1776,6 +1781,9 @@ 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;
     virtualEdges = new Map();
     classCanBeConstructed(info) {
         return (this.constructedClasses === null ||
@@ -2961,7 +2969,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) {
@@ -3252,6 +3259,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 +3338,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;
@@ -4333,9 +4366,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 +4482,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)
@@ -4580,18 +4608,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 +5004,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
@@ -5343,11 +5390,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 +5606,14 @@ export class Lowerer {
             ...this.liftedFns,
             ...this.implicitFns,
         ];
-        // The worklist can leave a virtual site with only its base method.
+        // 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 +5623,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 +7434,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 +7468,38 @@ 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())
+            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
@@ -7441,7 +7511,9 @@ export class Lowerer {
         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 };
@@ -9011,7 +9083,8 @@ export class Lowerer {
         const builtin = lowerAbortControllerNew(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) {