@scriptc/compiler 0.4.8 → 0.4.9

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

@@ -31,7 +31,7 @@ import { lowerZlibStreamNew, zlibClassName, zlibStreamModeOf } from "./builtins/
 import { everyStmtList } from "../../ir/traverse.js";
 import { builtinClassAliasOf, builtinClassRefOf, } from "./builtins/class-values.js";
 import { inlineNamespaceRequireOf, lowerWithInlineRequireInit } from "./cjs-inline-require.js";
-import { BIGINT_BYTES_NAMES, BOOL, BYTES_U8, canDynCheckTo, DATE_T, DYN, F64, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, classValueConstructor, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
+import { BIGINT_BYTES_NAMES, BOOL, BYTES_U8, canDynCheckTo, DATE_T, DYN, F64, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, classValueConstructor, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, sortArms, } from "../../ir/ir.js";
 import { genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, genericLocalClassResult, } from "./generic-functions.js";
 import { extendInstantiationPath, MAX_INSTANTIATION_RECURSION, } from "./instantiation-path.js";
 import { appendImplicitUndefinedReturn, hasExplicitJsDocReturn } from "./function-returns.js";
@@ -993,13 +993,13 @@ function undefArmedFieldType(lowerer, p) {
     const byKey = new Map();
     const arms = mapped.kind === "union" ? (lowerer.unions.get(mapped.unionId)?.arms ?? []) : [mapped];
     for (const a of arms) {
-        if (a.kind === "map" || a.kind === "regex" || a.kind === "generator") {
+        if (a.kind === "regex" || a.kind === "generator") {
             return null;
         }
         byKey.set(typeKey(a), a);
     }
     byKey.set(typeKey(UNDEFINED_T), UNDEFINED_T);
-    const sorted = [...byKey.values()].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+    const sorted = sortArms([...byKey.values()]);
     return { kind: "union", unionId: lowerer.unions.intern(sorted) };
 }
 /** The emitter ClassInfo a VALUE symbol refers to (`new EventEmitter`,
@@ -2880,7 +2880,16 @@ mixin) {
                             overridden.sig.ret.kind === "promise" ||
                             overridden.sig.ret.kind === "dyn") &&
                         !overridden.sig.abstract &&
-                        overridden.sig.params.length === shapes.length &&
+                        // An override may declare extra TRAILING optional or defaulted
+                        // parameters. The inherited ABI stops at the base arity, so the
+                        // slot function supplies the omitted value for each of them and
+                        // the body's own prologue applies the default — exactly what
+                        // Node does for a call that passes only the base arguments. A
+                        // body reading `arguments` would see the completed count, so it
+                        // keeps the fence.
+                        shapes.length >= overridden.sig.params.length &&
+                        (shapes.length === overridden.sig.params.length || !bodyReadsArguments(member)) &&
+                        shapes.slice(overridden.sig.params.length).every((p) => p.mode === "omittable") &&
                         overridden.sig.params.every((p, i) => p.mode === shapes[i].mode &&
                             (p.mode === "required" || p.mode === "omittable") &&
                             // Each inherited argument converts into the override's
@@ -3594,11 +3603,20 @@ mixin) {
         if (mixin && ctor && !mixinForwarding && ctor.parameters.nodes.some((p) => p.dotDotDotToken)) {
             lowerer.unsupported("SC1090", ctor.parameters.nodes.find((p) => p.dotDotDotToken), "mixin constructors whose rest parameter does anything but forward (`super(...args)` as the first statement is the compiled shape)");
         }
+        // A body-less constructor is an overload signature only while an
+        // implementation follows it. An AMBIENT class (`declare class`) has no
+        // implementation at all, so its constructor declarations ARE the
+        // published signature — the one tsc checked every call site against —
+        // and the last of them supplies the ABI.
+        const ambientCtor = ctor === null && (ts.getCombinedModifierFlags(decl) & ts.ModifierFlags.Ambient) !== 0
+            ? (decl.members.nodes.filter(ts.isConstructorDeclaration).at(-1) ?? null)
+            : null;
+        const abiCtor = ctor ?? ambientCtor;
         // Constructor omitted on a derived class: it inherits the base's
         // (tsc types `new Derived(...)` against the inherited signature; the
         // synthesized constructor forwards the same params to super).
-        const ctorParams = ctor && !mixinForwarding
-            ? lowerer.paramShapes(ctor.parameters.nodes)
+        const ctorParams = abiCtor && !mixinForwarding
+            ? lowerer.paramShapes(abiCtor.parameters.nodes)
             : (base?.ctorParams ??
                 (callableBase || extendsDate || extendsArray ? [{ type: DYN, mode: "dynRest" }] : []));
         if (ctor &&
@@ -3635,9 +3653,9 @@ mixin) {
                     member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.StaticKeyword))
                     ? { ownStaticFields: true }
                     : {}),
-                jsLength: ctor?.parameters?.nodes.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) === -1
-                    ? ctor.parameters.nodes.length
-                    : Math.max(0, ctor?.parameters?.nodes.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) ?? 0),
+                jsLength: abiCtor?.parameters?.nodes.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) === -1
+                    ? abiCtor.parameters.nodes.length
+                    : Math.max(0, abiCtor?.parameters?.nodes.findIndex((parameter) => parameter.initializer || parameter.dotDotDotToken) ?? 0),
                 // Layout order: the base chain's fields as an IDENTICAL prefix,
                 // then this class's own — what makes an upcast a reinterpret.
                 // Redeclared INHERITED fields contribute no slot (their
@@ -7059,6 +7077,22 @@ function lowerClassCtorInner(lowerer, info) {
                         throw e;
                 }
             }
+            else if (info.ctorParams.length > 0) {
+                // An AMBIENT class declares its constructor's ABI without an
+                // implementation (the `declare class` shape). The parameters exist
+                // so a call site passes and evaluates exactly what the declaration
+                // publishes; the construction body is the field initialization.
+                info.ctorParams.forEach((shape, i) => {
+                    const local = {
+                        id: `arg${i}.0`,
+                        name: `arg${i}`,
+                        type: shape.type,
+                        mutable: false,
+                    };
+                    lowerer.ctx.locals.push(local);
+                    params.push({ localId: local.id, name: local.name, type: shape.type });
+                });
+            }
             body.push(...lowerer.fieldInitStmts(info, thisLocal));
         }
         return {
@@ -7576,6 +7610,17 @@ function lowerClassMethodMemberInner(lowerer, info, fnLike) {
                 type: adapter.ret,
                 loc,
             };
+            // The override declares more parameters than the inherited ABI
+            // carries. The extra trailing ones are optional or defaulted, so the
+            // slot passes the omitted value and the body's prologue applies the
+            // default (or leaves them undefined), as Node does for a call that
+            // stops at the inherited arity.
+            for (const shape of adapter.params.slice(params.length - 1)) {
+                const absent = omittedArgFor(lowerer, shape.type, loc);
+                if (!absent)
+                    lowerer.unsupported("SC1090", fnLike.name, "an override's extra trailing parameter has no omitted value");
+                call.args.push(absent);
+            }
             // A void slot discards the override's result after running it. A
             // toString slot hands on what every ToString consumer of the result
             // makes of it (`String(err)`, templates): undefined reads
@@ -8416,6 +8461,20 @@ export function lowerSuperMethodCall(lowerer, call, access) {
         };
     }
     lowerer.noteEdge(`%${found.declarer.def.name}.${access.name.text}`);
+    // `super.m(...)` dispatches statically above the lexical class, so an
+    // adapted override answers with its own body: that is the only entry that
+    // carries a parameter past the inherited slot arity.
+    const superAdapted = found.declarer.returnAdapters?.get(access.name.text);
+    if (superAdapted && superAdapted.params.length > found.sig.params.length) {
+        const ownArgs = lowerer.completeArgs(call.arguments.nodes, superAdapted.params, loc, call);
+        return {
+            kind: "call",
+            callee: `%${found.declarer.def.name}.${access.name.text}$own`,
+            args: [lowerer.upcastTo(thisRef, found.declarer.def.name), ...ownArgs],
+            type: superAdapted.ret,
+            loc,
+        };
+    }
     const args = lowerer.completeArgs(call.arguments.nodes, found.sig.params, loc, call);
     return {
         kind: "call",
@@ -9043,7 +9102,7 @@ export function lowerNew(lowerer, expr) {
                 ? yesType
                 : {
                     kind: "union",
-                    unionId: lowerer.unions.intern([yesType, noType].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1))),
+                    unionId: lowerer.unions.intern(sortArms([yesType, noType])),
                 };
             return {
                 kind: "ternary",
@@ -10058,9 +10117,13 @@ export function lowerNew(lowerer, expr) {
             // real closure rejecting the promise with an Error reason (the
             // ambient override pins `reason: Error` — rejection payloads share
             // the thrown-value representation, and the OBJ kind keeps
-            // catch-side instanceof and the uncaught printer working). First
-            // settle wins, exactly JS: reject-after-resolve and double-reject
-            // are no-ops, and an executor throw after any settle is swallowed.
+            // catch-side instanceof and the uncaught printer working). A
+            // checked-dynamic promise has no typed payload to protect: its
+            // reason is whatever the program rejected with, so its reject
+            // closure carries the dyn value (the override types the reason
+            // `unknown` for exactly that tier). First settle wins, exactly JS:
+            // reject-after-resolve and double-reject are no-ops, and an
+            // executor throw after any settle is swallowed.
             let executor = lowerer.lowerExpr(args[0]);
             if (executor.type.kind !== "func")
                 lowerer.badType(args[0], lowerer.typeOf(args[0]));
@@ -10069,14 +10132,16 @@ export function lowerNew(lowerer, expr) {
                 lowerer.badType(args[0], lowerer.typeOf(args[0]));
             if (executor.type.params.length > 1) {
                 const rj = executor.type.params[1];
+                const param = rj.kind === "func" && rj.params.length === 1 ? rj.params[0] : null;
+                const errorPinned = param !== null && param.kind === "object" && param.className === "%Error";
+                const dynPinned = param !== null && param.kind === "dyn" && type.inner.kind === "dyn";
                 if (executor.type.params.length > 2 ||
                     rj.kind !== "func" ||
                     rj.ret.kind !== "void" ||
-                    rj.params.length !== 1 ||
-                    rj.params[0].kind !== "object" ||
-                    rj.params[0].className !== "%Error") {
+                    (!errorPinned && !dynPinned)) {
                     // A non-contextually-typed executor VALUE whose second param
-                    // isn't the pinned (reason: Error) => void shape.
+                    // isn't the pinned (reason: Error) => void shape (or the dyn
+                    // reason of a checked-dynamic promise).
                     lowerer.unsupported("SC1090", args[0], "Promise executors whose reject parameter is not '(reason: Error) => void'");
                 }
             }