@scriptc/compiler 0.4.0 → 0.4.2

package/dist/frontend/lowering/lower-event-emitter.js

@@ -42,13 +42,14 @@
  * emit-overrides block at the bottom of this file (per-event
  * monomorphization of the override body, dispatch on the dynamic class,
  * super.emit as the prototype chain). */
+import { keyedHelperName } from "./stable-names.js";
 import { checkKeypressListener } from "./builtins/readline.js";
 import * as ts from "../ts7/adapter.js";
 import { dynFallbackType, newFnCtx } from "./lowerer.js";
 import { isJsSourceFile, locOf } from "../program.js";
-import { arrayOf, BOOL, canBoxFuncIntoDyn, canConvertToDyn, DYN, F64, isUnitType, STRING, typeEquals, typeKey, VOID, } from "../../ir/ir.js";
+import { arrayOf, BOOL, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, isDynTypedRefType, DYN, F64, isUnitType, STRING, typeEquals, typeKey, VOID, } from "../../ir/ir.js";
 import { STREAM_FORCED_EVENT_NAMES, streamForcedTuple, streamSidesOf } from "./lower-stream.js";
-import { boolLit, strLit, varRef } from "../../ir/build.js";
+import { boolLit, dynUndefinedExpr, strLit, varRef } from "../../ir/build.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerAddAbortListener } from "./builtin-calls.js";
 import { requestGeneralStreamSurface } from "./general-streams.js";
@@ -278,8 +279,14 @@ function emitterEvents(lowerer) {
                 else if (node.arguments.nodes[1]) {
                     const cbCt = lowerer.typeOf(node.arguments.nodes[1]);
                     const cbT = lowerer.mapTypeOf(cbCt) ?? dynFallbackType(lowerer, node.arguments.nodes[1], cbCt);
+                    // A TypeScript listener with no parameters is typed too: it
+                    // registers without the adapter, so an untyped emit reaches it
+                    // only through the event's fixed ABI. A JavaScript function
+                    // without parameters can still read `arguments`.
                     if (cbT?.kind !== "dyn" &&
-                        (cbT?.kind !== "func" || cbT.params.some((p) => p.kind !== "dyn"))) {
+                        (cbT?.kind !== "func" ||
+                            (cbT.params.length === 0 && !isJsSourceFile(sf)) ||
+                            cbT.params.some((p) => p.kind !== "dyn"))) {
                         sigOf(name).typedListener = true;
                     }
                     // Dyn-flavored listeners (a checked-dynamic value, or a func
@@ -503,7 +510,7 @@ function lowerFlexListenerCall(lowerer, member, name, receiver, cbNode, register
     const key = `emitter.${registering ? "onFlex" : "offDyn"}:${typeKey(recvT)}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
-        helper = `%emitter.${registering ? "onFlex" : "offFlex"}.${lowerer.arrHofHelpers.size}`;
+        helper = keyedHelperName(lowerer, `%emitter.${registering ? "onFlex" : "offFlex"}`, key);
         lowerer.arrHofHelpers.set(key, helper);
         const params = [
             { localId: "r.0", name: "r", type: recvT },
@@ -690,7 +697,7 @@ streamData) {
     const existing = lowerer.arrHofHelpers.get(key);
     let helper = existing;
     if (!helper) {
-        helper = `%emitter.${registering ? "onDyn" : "offDyn"}.${lowerer.arrHofHelpers.size}`;
+        helper = keyedHelperName(lowerer, `%emitter.${registering ? "onDyn" : "offDyn"}`, key);
         lowerer.arrHofHelpers.set(key, helper);
         const check = {
             kind: "exprStmt",
@@ -779,6 +786,229 @@ streamData) {
         loc,
     };
 }
+/** The literal events typed code dispatches with a fixed tuple — it emits
+ * them or listens with typed parameters — whose names an untyped receiver
+ * may also use. 'error' and the meta events are excluded: the runtime fixes
+ * their tuples itself (scr_emitter_on_flex / scr_emitter_emit_flex). */
+function bridgedEvents(lowerer) {
+    const table = emitterEvents(lowerer);
+    const events = [];
+    for (const [key, sig] of table) {
+        if (key === "error" || key === ERROR_MONITOR_EVENT || META_EVENTS.has(key))
+            continue;
+        if (sig.conflict !== null || (!sig.fromEmit && sig.typedListener !== true))
+            continue;
+        if (flexibleJsEvent(key, sig))
+            continue;
+        if (computedPatterns(lowerer).some((pattern) => patternMatchesName(pattern, key)))
+            continue;
+        events.push({ name: eventKeyName(key), tuple: sig.tuple });
+    }
+    return events;
+}
+/** `emit(name, ...args)` through an untyped value on a (non-stream)
+ * emitter-rooted receiver, when typed code fixes the tuple of some event.
+ * Listeners registered as checked-dynamic functions receive the arguments
+ * as given; when the name is such an event and a listener with typed
+ * parameters is registered, the arguments also convert to the event's tuple
+ * (a mismatch throws the checked conversion's TypeError). Null when no event
+ * needs this, so the caller keeps the plain untyped emit. */
+export function lowerDynamicEmitterEmit(lowerer, receiver, name, payload, loc) {
+    const recvT = receiver.type;
+    if (recvT.kind !== "object")
+        return null;
+    const k = payload.length;
+    const getRecord = (id) => lowerer.shapes.get(id);
+    const getUnion = (id) => lowerer.unions.get(id);
+    const checkable = (t) => t.kind === "dyn" ||
+        isDynTypedRefType(t) ||
+        isUnitType(t) ||
+        (t.kind === "union"
+            ? (getUnion(t.unionId)?.arms.every(checkable) ?? false)
+            : canDynCheckTo(t, getRecord, getUnion));
+    const converted = (tuple) => {
+        if (!tuple.every(checkable))
+            return null;
+        const out = [];
+        for (let i = 0; i < tuple.length; i++) {
+            const arg = i < k ? varRef(`a.${i}`, DYN, loc) : dynUndefinedExpr(loc);
+            const value = lowerer.coerceToExpected(arg, tuple[i]);
+            if (!typeEquals(value.type, tuple[i]))
+                return null;
+            out.push(value);
+        }
+        return out;
+    };
+    const events = bridgedEvents(lowerer)
+        .map((event) => ({ ...event, args: converted(event.tuple) }))
+        .filter((event) => event.args !== null);
+    if (events.length === 0)
+        return null;
+    const key = `emitter.dynEmit:${typeKey(recvT)}:${k}`;
+    let helper = lowerer.arrHofHelpers.get(key);
+    if (!helper) {
+        helper = keyedHelperName(lowerer, "%emitter.dynEmit", key);
+        lowerer.arrHofHelpers.set(key, helper);
+        const params = [
+            { localId: "r.0", name: "r", type: recvT },
+            { localId: "n.0", name: "n", type: STRING },
+            ...payload.map((_, i) => ({ localId: `a.${i}`, name: `a${i}`, type: DYN })),
+        ];
+        const r = varRef("r.0", recvT, loc);
+        const n = varRef("n.0", STRING, loc);
+        const dynArgs = payload.map((_, i) => varRef(`a.${i}`, DYN, loc));
+        const body = events.map((event) => ({
+            kind: "if",
+            cond: {
+                kind: "strEq",
+                negated: false,
+                left: n,
+                right: strLit(event.name, loc),
+                type: BOOL,
+                loc,
+            },
+            then: [
+                {
+                    kind: "if",
+                    cond: { kind: "libCall", fn: "emitter.hasTyped", args: [r, n], type: BOOL, loc },
+                    then: [
+                        {
+                            kind: "return",
+                            value: {
+                                kind: "libCall",
+                                fn: "emitter.emitMixed",
+                                args: [
+                                    r,
+                                    n,
+                                    { kind: "numLit", value: k, type: F64, loc },
+                                    ...dynArgs,
+                                    ...event.args,
+                                ],
+                                type: BOOL,
+                                loc,
+                            },
+                            loc,
+                        },
+                    ],
+                    else_: null,
+                    loc,
+                },
+            ],
+            else_: null,
+            loc,
+        }));
+        body.push({
+            kind: "return",
+            value: { kind: "libCall", fn: "emitter.emitAny", args: [r, n, ...dynArgs], type: BOOL, loc },
+            loc,
+        });
+        lowerer.liftedFns.push({
+            name: helper,
+            params,
+            returnType: BOOL,
+            locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+            body,
+            loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [receiver, name, ...payload], type: BOOL, loc };
+}
+/** on/once/prepend*(name, fn) through an untyped value on a (non-stream)
+ * emitter-rooted receiver, when typed code fixes the tuple of some event.
+ * Under such an event's name the function registers with a typed adapter
+ * for typed emits as well as its checked-dynamic thunk for untyped ones;
+ * other names register the thunk alone. Null when no event needs this. */
+export function lowerDynamicEmitterOn(lowerer, receiver, name, cb, once, prepend, loc) {
+    const recvT = receiver.type;
+    if (recvT.kind !== "object")
+        return null;
+    const getRecord = (id) => lowerer.shapes.get(id);
+    const getUnion = (id) => lowerer.unions.get(id);
+    const events = bridgedEvents(lowerer).filter((event) => event.tuple.every((t) => t.kind === "dyn" || canConvertToDyn(t, getRecord, getUnion)));
+    if (events.length === 0)
+        return null;
+    const key = `emitter.dynOn:${typeKey(recvT)}`;
+    let helper = lowerer.arrHofHelpers.get(key);
+    if (!helper) {
+        helper = keyedHelperName(lowerer, "%emitter.dynOn", key);
+        lowerer.arrHofHelpers.set(key, helper);
+        const params = [
+            { localId: "r.0", name: "r", type: recvT },
+            { localId: "n.0", name: "n", type: STRING },
+            { localId: "cb.0", name: "cb", type: DYN },
+            { localId: "o.0", name: "o", type: BOOL },
+            { localId: "p.0", name: "p", type: BOOL },
+        ];
+        const locals = params.map((p) => ({
+            id: p.localId,
+            name: p.name,
+            type: p.type,
+            mutable: false,
+        }));
+        const r = varRef("r.0", recvT, loc);
+        const n = varRef("n.0", STRING, loc);
+        const fn = varRef("cb.0", DYN, loc);
+        const o = varRef("o.0", BOOL, loc);
+        const p = varRef("p.0", BOOL, loc);
+        const body = [
+            {
+                kind: "exprStmt",
+                expr: { kind: "libCall", fn: "emitter.checkListener", args: [fn], type: VOID, loc },
+                loc,
+            },
+        ];
+        events.forEach((event, i) => {
+            const adapterT = { kind: "func", params: event.tuple, ret: VOID };
+            const adapter = `a.${i}`;
+            locals.push({ id: adapter, name: "a", type: adapterT, mutable: false });
+            body.push({
+                kind: "if",
+                cond: {
+                    kind: "strEq",
+                    negated: false,
+                    left: n,
+                    right: strLit(event.name, loc),
+                    type: BOOL,
+                    loc,
+                },
+                then: [
+                    {
+                        kind: "varDecl",
+                        localId: adapter,
+                        init: { kind: "dynCheck", value: fn, type: adapterT, loc },
+                        loc,
+                    },
+                    {
+                        kind: "return",
+                        value: {
+                            kind: "libCall",
+                            fn: "emitter.onDyn",
+                            args: [r, n, fn, varRef(adapter, adapterT, loc), o, p],
+                            type: recvT,
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                else_: null,
+                loc,
+            });
+        });
+        body.push({
+            kind: "return",
+            value: { kind: "libCall", fn: "emitter.onAny", args: [r, n, fn, o, p], type: recvT, loc },
+            loc,
+        });
+        lowerer.liftedFns.push({ name: helper, params, returnType: recvT, locals, body, loc });
+    }
+    return {
+        kind: "call",
+        callee: helper,
+        args: [receiver, name, cb, boolLit(once, loc), boolLit(prepend, loc)],
+        type: recvT,
+        loc,
+    };
+}
 /** A listener argument: lowered, checked void-returning, and its
  * parameters checked as a typeEquals PREFIX of the event tuple. */
 function lowerListenerArg(lowerer, member, name, node, tuple) {
@@ -979,10 +1209,11 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         const receiver = lowerReceiver();
         const once = member === "once" || member === "prependOnceListener";
         const prepend = member === "prependListener" || member === "prependOnceListener";
-        // Stream 'data' rides its own two-slot payload ABI (bytes + string —
-        // encoded streams deliver strings; scr_stream_emit_data): listeners
-        // on readable-sided receivers register through DATA thunks that
-        // unwrap the declared side (typed) or box by tag (dyn).
+        // Stream 'data' rides its own three-slot payload ABI (bytes, string —
+        // encoded streams deliver strings — and an object-mode value;
+        // scr_stream_emit_data): listeners on readable-sided receivers
+        // register through DATA thunks that unwrap the declared side, convert
+        // to the declared type, or take the value (dyn).
         const sides = streamSidesOf(lowerer, info);
         if (name === "data" && (sides === "r" || sides === "rw")) {
             const dynFlavor = dynListenerFlavor(lowerer, args[1]);
@@ -1002,11 +1233,16 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             // shape) takes whichever side the stream delivers.
             const chunkUnion = p?.kind === "union" &&
                 (lowerer.unions.get(p.unionId)?.arms ?? []).every((arm) => (arm.kind === "bytes" && arm.elem === "u8") || arm.kind === "string");
+            // Any other chunk type converts from the chunk's value (an
+            // object-mode stream's value, or the Buffer or string) when the
+            // listener runs, or throws a TypeError there.
             if (p !== undefined &&
                 !(p.kind === "bytes" && p.elem === "u8") &&
                 p.kind !== "string" &&
-                !chunkUnion) {
-                lowerer.noLowering(`a 'data' listener whose chunk parameter is '${lowerer.fmt(p)}'`, args[1], "chunks are Buffers — or strings once setEncoding/the encoding option applies");
+                !chunkUnion &&
+                (p.kind === "func" ||
+                    !canConvertToDyn(p, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))) {
+                lowerer.noLowering(`a 'data' listener whose chunk parameter is '${lowerer.fmt(p)}'`, args[1], "declare the chunk as a type that converts from a checked-dynamic value");
             }
             if (!registering) {
                 return {
@@ -1111,17 +1347,24 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             }
             return emitDispatchExpr(lowerer, info, name, [{ kind: "object", className: "%Error" }], receiver, [lowerer.upcastTo(err, "%Error")], superRecv?.cls, loc);
         }
-        // Stream 'data' rides the two-slot payload ABI: a user emit fills
-        // the chunk's slot (bytes or string), NULLs the other.
+        // Stream 'data' rides the three-slot payload ABI: a user emit fills
+        // the chunk's slot (bytes or string) and NULLs the others; any other
+        // value is emitted as a checked-dynamic value, filling the slots by
+        // its tag.
         const emitSides = streamSidesOf(lowerer, info);
         if (name === "data" && (emitSides === "r" || emitSides === "rw")) {
             if (args.length !== 2) {
                 lowerer.noLowering(`emit('data') with ${args.length - 1} payload arguments`, call, "the event carries one chunk (a Buffer or string)");
             }
-            const chunk = lowerer.lowerExpr(args[1]);
+            let chunk = lowerer.lowerExpr(args[1]);
             if (!(chunk.type.kind === "bytes" && chunk.type.elem === "u8") &&
                 chunk.type.kind !== "string") {
-                lowerer.noLowering(`emit('data') with a '${lowerer.fmt(chunk.type)}' chunk`, args[1], "chunks are Buffers or strings");
+                if (chunk.type.kind === "func" ||
+                    (chunk.type.kind !== "dyn" &&
+                        !canConvertToDyn(chunk.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))) {
+                    lowerer.noLowering(`emit('data') with a '${lowerer.fmt(chunk.type)}' chunk`, args[1], "the chunk is a value that converts to a checked-dynamic value");
+                }
+                chunk = lowerer.coerceToExpected(chunk, DYN);
             }
             return {
                 kind: "libCall",
@@ -1487,10 +1730,14 @@ function ensureEmitSpec(lowerer, info, event, tuple) {
             params: tuple.map((t) => ({ type: t, mode: "required" })),
             ret: BOOL,
         });
-        if (info.def.methods)
-            info.def.methods.push(mName);
+        // Specializations sit in the method list sorted by event name, so the
+        // class table does not depend on which body asked for one first.
+        const methods = (info.def.methods ??= []);
+        const after = methods.findIndex((m) => m.startsWith("emit:") && m > mName);
+        if (after < 0)
+            methods.push(mName);
         else
-            info.def.methods = [mName];
+            methods.splice(after, 0, mName);
     }
     const ordinal = lowerer.emitSpecQueue.filter((q) => q.info === info).length;
     lowerer.emitSpecQueue.push({ info, event, tuple, ordinal });
@@ -1699,7 +1946,7 @@ function emitDispatchExpr(lowerer, info, name, tuple, receiver, payload, superOf
     const key = `emitter.emitDispatch:${typeKey(recvT)}:${name}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
-        helper = `%emitter.emitDispatch.${lowerer.arrHofHelpers.size}`;
+        helper = keyedHelperName(lowerer, "%emitter.emitDispatch", key);
         lowerer.arrHofHelpers.set(key, helper);
         const params = [
             { localId: "r.0", name: "r", type: recvT },
@@ -1757,7 +2004,7 @@ function eventsOnceBoxer(lowerer, call, tuple, arrayT, loc) {
     const key = `eventsOnce:${typeKey(fnType)}`;
     let name = lowerer.valueHelpers.get(key);
     if (name === undefined) {
-        name = `%events.onceArgs.${lowerer.valueHelpers.size}`;
+        name = keyedHelperName(lowerer, "%events.onceArgs", key);
         lowerer.valueHelpers.set(key, name);
         const params = tuple.map((type, i) => ({
             localId: `%once.a${i}`,