@scriptc/compiler 0.0.10 → 0.0.12

package/dist/frontend/lowering/lower-classes.d.ts

@@ -2,6 +2,7 @@ import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
 import { IrClassDef, IrExpr, IrFunction, IrLocal, IrStmt, IrType, SrcLoc } from "../../ir/nodes.js";
 import { type GenericFnInfo, type ParamShape } from "./lower-calls.js";
+import { type EmitOverrideRec } from "./lower-emitter.js";
 import { type MixinInstanceInfo } from "./lower-mixins.js";
 export interface ClassInfo {
     def: IrClassDef;
@@ -81,6 +82,12 @@ export interface ClassInfo {
      * the base chain. The value names which SIDES the class carries. User
      * `extends` of these classes is fenced at the declaration (phase 1). */
     builtinStream?: "r" | "w" | "rw";
+    /** This class's own `emit` override in the FORWARDING SHAPE (the one
+     * EventEmitter member a subclass may re-declare): never in `methods` —
+     * emit calls keep routing through the emitter spoke, which lowers the
+     * body once per event name as the specialization method `emit:<event>`
+     * (lower-emitter.ts's emit-overrides block has the whole story). */
+    emitOverride?: EmitOverrideRec;
     ctor: ts.ConstructorDeclaration | null;
     /** PARAMETER PROPERTIES (`constructor(public x: number)`), in parameter
      * order: each declares a field (placed BEFORE the class's declared

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

@@ -14,6 +14,7 @@ import { pureReemittable } from "./lower-exprs.js";
 import { lowerSearchParamsNew } from "./lower-builtins.js";
 import { requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
 import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape } from "./lower-stream.js";
+import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall } from "./lower-emitter.js";
 import { declSymbolOf } from "./lower-modules.js";
 import { uniqueSymbolKeyOf } from "./lower-exprs.js";
 import { lowerHttpServerNew } from "./lower-server.js";
@@ -473,6 +474,32 @@ export function collectClassShape(L, decl) {
             }
         }
     }
+    // A poisoned BASE this class EXTENDS must report EAGERLY for the same
+    // reason: the derived statement evaluates its heritage when module
+    // init reaches it (these are top-level declarations), and the base's
+    // fence is the COMPILER's, not Node's — Node defines the base fine and
+    // runs on — so a deferred trap there is a manufactured divergence, not
+    // the Node-parity deferral is licensed by (classFieldSuperAccessibleJs2:
+    // the binary refused at `class D extends C` where Node prints five
+    // lines). Leaf poisoned classes stay deferred — only the extends edge
+    // reports. Resolution runs under the collect pass's guard (this is
+    // collectProgram), so the lookup neither flushes nor fences.
+    {
+        const baseIdent = decl.heritageClauses
+            ?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword)
+            ?.types.map((t) => t.expression)
+            .filter(ts.isIdentifier)[0];
+        const baseSym = baseIdent ? L.resolveValueSymbol(baseIdent) : null;
+        const baseDiags = baseSym ? L.deferredDiags.get(baseSym) : undefined;
+        if (baseSym && baseDiags) {
+            L.deferredDiags.delete(baseSym);
+            if (!L.alreadyFlushed.has(baseSym)) {
+                L.flushedSymbols.add(baseSym);
+                for (const d of baseDiags)
+                    L.pushDiag(d);
+            }
+        }
+    }
 }
 export function collectClassShapeInner(L, decl, jsNameOverride, inst, 
 /** MIXIN instantiation mode (lower-mixins.ts): the class inside a
@@ -814,6 +841,10 @@ mixin) {
          * symbol-slot refinement retries them after the constructor scan
          * declares this class's OWN symbol-keyed slots. */
         const dynRetMethods = new Map();
+        /** The class's own `emit` override in the forwarding shape (emitter-
+         * rooted classes only) — recorded here, NEVER in `methods`, so emit
+         * calls keep routing through the emitter spoke's dispatch. */
+        let emitOverride;
         let ctor = null;
         /** Initializer-less fields whose type cannot hold undefined and whose
          * definite assignment tsc did NOT verify (a `!` assertion, or
@@ -1011,7 +1042,13 @@ mixin) {
             // The EventEmitter API surface is runtime-provided: a subclass
             // member with one of its names would shadow behavior the runtime
             // dispatches internally (meta events, once removal), so the
-            // override is fenced rather than silently split-brained.
+            // override is fenced rather than silently split-brained — with ONE
+            // exception: `emit` in the forwarding shape on a plain (non-
+            // stream) emitter-rooted class monomorphizes per event name
+            // (lower-emitter.ts's emit-overrides block). Stream-rooted classes
+            // keep the fence for emit too: the runtime stream machinery emits
+            // 'data'/'end'/... internally, which could never route through
+            // the override.
             if (memberName && ts.isIdentifier(memberName) &&
                 EMITTER_API_MEMBERS.has(memberName.text) &&
                 (() => {
@@ -1020,6 +1057,26 @@ mixin) {
                             return true;
                     return false;
                 })()) {
+                const streamRooted = (() => {
+                    for (let c = base; c; c = c.base)
+                        if (c.builtinStream !== undefined)
+                            return true;
+                    return false;
+                })();
+                if (memberName.text === "emit" && !streamRooted && !inst && !mixin &&
+                    ts.isMethodDeclaration(member) &&
+                    !member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
+                    const reason = emitOverrideShapeReason(L, member);
+                    if (reason === null) {
+                        const eventSym = L.checker.getSymbolAtLocation(member.parameters[0].name);
+                        const restSym = L.checker.getSymbolAtLocation(member.parameters[1].name);
+                        if (eventSym && restSym) {
+                            emitOverride = { decl: member, eventSym, restSym };
+                            continue;
+                        }
+                    }
+                    L.unsupported("SC1090", memberName, `overriding EventEmitter's 'emit' outside the forwarding shape (${reason ?? "its parameters do not resolve statically"}; the compiled form is \`emit(event: string, ...args: unknown[]): boolean\`)`);
+                }
                 L.unsupported("SC1090", memberName, `overriding the EventEmitter member '${memberName.text}' (the runtime owns the emitter surface)`);
             }
             // The stream surface is likewise runtime-provided on stream-rooted
@@ -1838,6 +1895,7 @@ mixin) {
             fieldOrder,
             methods,
             decl,
+            ...(emitOverride !== undefined ? { emitOverride } : {}),
             ctor,
             ctorParams,
             ...(paramProps.length > 0 ? { paramProps } : {}),
@@ -3925,6 +3983,13 @@ export function lowerSuperMethodCall(L, call, access) {
         // tsc rejects super outside derived-class bodies first; defensive.
         L.unsupported("SC1090", access, "'super' outside a derived class");
     }
+    // An emit-override SPECIALIZATION body's forward — `super.emit(event,
+    // ...args)` — carries no literal event name; the specialization's own
+    // context answers it (matched before any lookup: neither identifier
+    // resolves through the ordinary lowering).
+    const forward = emitSpecSuperForward(L, call, access);
+    if (forward)
+        return forward;
     const found = L.findMethodOn(cls.base, access.name.text);
     if (!found) {
         // `super.m(...)` of a GENERIC method: super dispatch is static in JS
@@ -3947,6 +4012,17 @@ export function lowerSuperMethodCall(L, call, access) {
                 loc,
             };
         }
+        // The runtime-provided emitter surface through `super` —
+        // `super.emit('x', v)`, `super.on(...)`: Node's prototype-chain rule
+        // is STATIC dispatch above the lexical class, which the emitter
+        // spoke lowers with this method's own `this` as the receiver (an
+        // emit override at-or-below `cls` never answers; the nearest one
+        // strictly above does).
+        if (EMITTER_API_MEMBERS.has(access.name.text) && emitterRooted(L, cls.base)) {
+            const viaEmitter = lowerEmitterSuperCall(L, call, access, cls);
+            if (viaEmitter)
+                return viaEmitter;
+        }
         L.unsupported("SC1090", access, `'super.${access.name.text}' (no base class declares it)`);
     }
     // tsc rejects super-access of abstract members (TS2513); defensive —
@@ -4312,7 +4388,7 @@ export function lowerNew(L, expr) {
         // like Node's message property default.
         const errInfo = L.builtinErrorInfoOf(symbol);
         // `new DOMException(message?, nameOrOptions?)`: both arguments cross
-        // as DOM values (absent → the DOM undefined), and the runtime owns
+        // as dyn values (absent → the dyn undefined), and the runtime owns
         // WebIDL's resolution — ToString of the message ("" for undefined),
         // name from a string / an options object's `name` member (with the
         // `cause` own-property record) / "Error" for absent, and the legacy
@@ -4573,7 +4649,7 @@ export function lowerNew(L, expr) {
             const targs = L.checker.getTypeArguments(tsType);
             // JAVASCRIPT `new Map()` whose arguments never resolved past
             // Map<any, any> (no annotation, no contextual type, no seed): the
-            // WeakMap stance below — the VALUE lowers as an opaque DOM object
+            // WeakMap stance below — the VALUE lowers as an opaque dyn object
             // (identity and truthiness are real), and every reached METHOD use
             // meets its own per-site fence at runtime. The formatter's
             // config-cache shape: module init constructs the caches
@@ -4606,7 +4682,7 @@ export function lowerNew(L, expr) {
         // `new WeakMap()` / `new WeakSet()` in JAVASCRIPT sources: no weak
         // container exists in the value model, but harness code constructs
         // one unconditionally and touches it only on paths tests don't
-        // reach — the value lowers as an opaque DOM object (identity only;
+        // reach — the value lowers as an opaque dyn object (identity only;
         // every reached METHOD use meets its own per-site fence → runtime
         // fence). TypeScript keeps the compile fence.
         if ((symbol?.name === "WeakMap" || symbol?.name === "WeakSet") &&
@@ -4706,14 +4782,14 @@ export function lowerNew(L, expr) {
             // `new Promise(setImmediate)` (the Node-suite early-exit shape):
             // the executor IS the stdlib setImmediate, so resolve rides the
             // immediate queue — a dedicated runtime constructor arms an
-            // immediate that fulfills with the undefined DOM value.
+            // immediate that fulfills with the undefined dyn value.
             {
                 const a0 = args[0];
                 if (ts.isIdentifier(a0) && a0.text === "setImmediate") {
                     const sym = L.checker.getSymbolAtLocation(a0);
                     const decls = sym ? L.checker.declarationsOf(sym) : [];
                     if (decls.length > 0 && decls.every((d) => L.isStdlibFile(d.getSourceFile()))) {
-                        // The settled value is the undefined DOM value — the result
+                        // The settled value is the undefined dyn value — the result
                         // is promise<dyn> whatever T the checker inferred for the
                         // unusual executor (Promise<unknown> in the suite's shape).
                         return {