@scriptc/compiler 0.3.2 → 0.3.3

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

@@ -112,6 +112,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";
+    /** Runtime-provided EventTarget ("target") or Event ("event") base of
+     * compiled subclasses (lower-event-target.ts): no bodies lower, super()
+     * becomes an event.* libCall, and the inherited members lower through
+     * lower-event-target.ts over any class rooted here. Subclass structs
+     * embed the runtime prefix. */
+    builtinEventTarget?: "target" | "event";
     /** The synthetic LifetimeRegion class (@scriptc/experimental,
      * lifetime-regions.ts): its constructor is synthesized with the class,
      * and its methods lower at their call sites. */
@@ -663,8 +669,8 @@ export declare function classMemberNameOf(lowerer: Lowerer, name: ts.PropertyNam
  * `undefined` is falsy forever (Node loops forever too; corpus
  * iterators of that shape are deliberately infinite). Iterator classes
  * declaring `return`/`throw` members stay out — the desugars below
- * never call IteratorClose, and silently skipping a declared return()
- * would drop user cleanup. Null when the shape doesn't hold — callers
+ * never call IteratorClose, and skipping a declared return() without a
+ * diagnostic would drop user cleanup. Null when the shape doesn't hold — callers
  * keep their fences. */
 export interface ClassIteratorInfo {
     /** The `[Symbol.iterator]()` call's receiver class + its declarer. */

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

@@ -28,6 +28,7 @@ import { lowerTextCodecNew } from "./builtins/text-codecs.js";
 import { lowerWorkerNew } from "./builtins/workers.js";
 import { unsupportedPackageValueDiag, unsupportedDiag, } from "../../diagnostics/diagnostic.js";
 import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape, } from "./lower-stream.js";
+import { builtinEventTargetBaseOf, eventTargetApiMembers, eventTargetApiMethod, eventTargetRootOf, eventTargetSuperCall, lowerEventTargetMethodCall, } from "./lower-event-target.js";
 import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall, } from "./lower-event-emitter.js";
 import { declSymbolOf } from "./lower-modules.js";
 import { classSymbolKeyOf, classSymbolKeyOfSymbol, symbolFieldDisplayName, } from "./symbol-fields.js";
@@ -990,8 +991,8 @@ function collectClassShapeDeferring(lowerer, decl) {
     // A poisoned class containing a static BLOCK or a DECORATOR must report
     // EAGERLY: deferral's premise ("an unreached broken declaration costs
     // nothing") fails here — Node runs the block (and calls the decorator)
-    // when the class statement evaluates, referenced or not, so silently
-    // dropping the declaration would drop observable side effects (the
+    // when the class statement evaluates, referenced or not, so dropping the
+    // declaration without a diagnostic would drop observable side effects (the
     // classStaticBlock13/28 miscompiles).
     const hasDeclTimeCode = (n) => ts.isClassStaticBlockDeclaration(n) ||
         (n.modifiers ?? []).some((m) => m.kind === ts.SyntaxKind.Decorator);
@@ -1444,6 +1445,7 @@ mixin) {
                 lowerer.builtinErrorInfoOf(symbol) ??
                 lowerer.builtinEmitterInfoOf(symbol) ??
                 builtinStreamInfoOf(lowerer, symbol) ??
+                builtinEventTargetBaseOf(lowerer, t.expression) ??
                 // A const BINDING holding exactly one class (`const B = Animal`,
                 // `const B = class {…}`): the base is that class — extends
                 // through the alias is the declaration story (a general class
@@ -1494,7 +1496,9 @@ mixin) {
         }
         if (lowerer.collectingExprClasses.has(decl)) {
             for (let parent = base; parent; parent = parent.base) {
-                if (parent.builtinEmitter || parent.builtinStream !== undefined) {
+                if (parent.builtinEmitter ||
+                    parent.builtinStream !== undefined ||
+                    parent.builtinEventTarget !== undefined) {
                     lowerer.unsupported("SC1090", decl, "classes extending builtin bases as values (the inherited runtime constructor has no class-value adapter)");
                 }
             }
@@ -1792,7 +1796,7 @@ 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 — with ONE
+            // override is fenced instead of compiling to split behavior — with ONE
             // exception: `emit` in the forwarding shape on a plain (non-
             // stream) emitter-rooted class monomorphizes per event name
             // (lower-event-emitter.ts's emit-overrides block). Stream-rooted classes
@@ -1833,6 +1837,15 @@ mixin) {
                 }
                 lowerer.unsupported("SC1090", memberName, `overriding the EventEmitter member '${memberName.text}' (the runtime owns the emitter surface)`);
             }
+            // The inherited EventTarget/Event members read the engine's own
+            // state: dispatch never calls a subclass override, and the engine
+            // never reads an own field that shadows an accessor (`type`).
+            if (memberName &&
+                ts.isIdentifier(memberName) &&
+                !(ts.getCombinedModifierFlags(member) & ts.ModifierFlags.Static) &&
+                eventTargetApiMembers(base)?.has(memberName.text)) {
+                lowerer.unsupported("SC1090", memberName, `overriding the ${eventTargetRootOf(base) === "target" ? "EventTarget" : "Event"} member '${memberName.text}' (the runtime owns the inherited surface)`);
+            }
             // The stream surface is likewise runtime-provided on stream-rooted
             // subclasses: API members (push/read/write/...) and the property
             // family (readableEnded/destroyed/...) dispatch into the runtime
@@ -2775,7 +2788,7 @@ mixin) {
         // (conditional branches, methods) would be readable before any
         // assignment ran — the zeroed-memory trap a TS declaration order
         // forbids via strictPropertyInitialization — so they keep a named
-        // fence instead of a silent undefined.
+        // fence instead of reading undefined without a diagnostic.
         if (isJsSourceFile(decl.getSourceFile())) {
             const hasAccessor = (name) => methods.has(`get:${name}`) ||
                 methods.has(`set:${name}`) ||
@@ -2857,8 +2870,8 @@ mixin) {
                         // representation follows the body — the field widens to the
                         // undefined-armed union, so the declaring assignment and
                         // every pre-init read carry Node's actual undefined.
-                        // Trust-but-verify: the claim never silently narrows the
-                        // runtime value.
+                        // Trust-but-verify: the claim does not narrow the runtime
+                        // value.
                         {
                             const rhsT = lowerer.typeOf(rhs);
                             const assignsUndef = (rhsT.flags & ts.TypeFlags.Undefined) !== 0;
@@ -2992,7 +3005,7 @@ mixin) {
                 // poisoning the class (commander's `this.required` switch
                 // assignment, `this.runningCommand` method assignment).
                 // Unmappable inferences and arm-less kinds keep the fence.
-                // TypeScript classes keep the loud fence too: an annotated
+                // TypeScript classes keep the compile-time fence too: an annotated
                 // program can spell `T | undefined` itself.
                 if (isJsSourceFile(decl.getSourceFile())) {
                     const original = undefArmedFieldType(lowerer, p);
@@ -3892,6 +3905,7 @@ export function classValueRef(lowerer, info, blame) {
     }
     if (lowerer.inheritsBuiltinEmitterCtor(info) ||
         inheritsBuiltinStreamCtor(lowerer, info) ||
+        eventTargetRootOf(info) !== null ||
         (() => {
             for (let c = info.base; c; c = c.base)
                 if (c.builtinEmitter || c.builtinStream !== undefined)
@@ -3988,7 +4002,7 @@ export function lowerStaticFieldRead(lowerer, expr) {
     // A #private static resolves only through the DECLARING class's own
     // name: in JS the brand lives on that one constructor object, so
     // `D.#s` (a subclass receiver) throws Node's TypeError instead of
-    // reaching up the chain — fenced rather than silently resolved.
+    // reaching up the chain — reported as SC1090 instead of resolved.
     if (found && expr.name.text.startsWith("#") && found.declarer !== info) {
         lowerer.unsupported("SC1090", expr, `reading the private static '${expr.name.text}' through the subclass '${info.def.name.replace(/^%|^%m\d+\./, "")}' (JS brands the declaring class object alone — Node throws a TypeError here; spell the declaring class's name)`);
     }
@@ -6421,6 +6435,8 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
             loc,
         };
     }
+    if (base.builtinEventTarget)
+        return eventTargetSuperCall(lowerer, base, thisRef, args, loc);
     if (base.builtinStream) {
         // The SYNTHESIZED constructor of a ctor-less stream subclass:
         // super() with default options (underscore methods still bind; a
@@ -6490,6 +6506,21 @@ export function lowerSuperMethodCall(lowerer, call, access) {
             if (viaEmitter)
                 return viaEmitter;
         }
+        // `super.dispatchEvent(e)`, `super.preventDefault()`: the inherited
+        // runtime members over this method's own `this` (subclasses cannot
+        // override them, so the static answer is the runtime's).
+        if (eventTargetApiMethod(cls.base, access.name.text)) {
+            const thisL = lowerer.resolveThis();
+            if (!thisL)
+                lowerer.unsupported("SC1080", access);
+            const thisRef = {
+                kind: "varRef",
+                localId: thisL.id,
+                type: thisL.type,
+                loc: locOf(call),
+            };
+            return lowerEventTargetMethodCall(lowerer, call, access, cls.base, thisRef);
+        }
         lowerer.unsupported("SC1090", access, `'super.${access.name.text}' (no base class declares it)`);
     }
     // tsc rejects super-access of abstract members (TS2513); defensive —