@scriptc/compiler 0.3.1 → 0.3.3

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

@@ -112,6 +112,16 @@ 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. */
+    lifetimeRegion?: true;
     /** 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
@@ -659,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. */
@@ -752,9 +762,6 @@ export declare function inheritsBuiltinErrorCtor(lowerer: Lowerer, info: ClassIn
 /** The EventEmitter twin: a ctor-less chain into the emitter base
  * inherits `new C()` — zero arguments (the options bag fences). */
 export declare function inheritsBuiltinEmitterCtor(lowerer: Lowerer, info: ClassInfo): boolean;
-/** Preserve argument evaluation order and option presence through builtin
- * and inherited Error constructors. Checked-dynamic conversion retains
- * Error identity and distinguishes a missing cause from undefined. */
 export declare function errorConstructorArgs(lowerer: Lowerer, args: readonly ts.Expression[], loc: SrcLoc, blame: ts.Node): IrExpr[];
 export declare function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr;
 /** A getter/setter invocation over an accessor target's receiver — the

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

@@ -1,4 +1,5 @@
-import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js";
+import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js";
+import { checkedIterableSpread } from "./checked-iterable-spread.js";
 import { collectClassMethodMutations } from "./class-method-mutations.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Class lowering: shape collection over the single-inheritance graph
@@ -27,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";
@@ -989,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);
@@ -1303,7 +1305,9 @@ mixin) {
                     lowerer.isStdlibGlobal(t.expression.expression, "globalThis")
                     ? lowerer.builtinErrorInfoOf(resolved)
                     : null;
-                if (globalError && globalError.def.name !== "%DOMException") {
+                if (globalError &&
+                    globalError.def.name !== "%DOMException" &&
+                    globalError.def.name !== "%AggregateError") {
                     if (t.typeArguments)
                         lowerer.unsupported("SC1090", t, "extending generic classes");
                     base = globalError;
@@ -1432,10 +1436,16 @@ mixin) {
             if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%DOMException") {
                 lowerer.unsupported("SC1090", t, "extending DOMException (its runtime layout carries hidden slots a subclass would overlap — extend Error and set name/code yourself)");
             }
+            // `extends AggregateError`: the errors list is the same kind of
+            // hidden runtime slot.
+            if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%AggregateError") {
+                lowerer.unsupported("SC1090", t, "extending AggregateError (its runtime layout carries a hidden errors slot a subclass would overlap — extend Error and keep the list in a field)");
+            }
             const named = (symbol && lowerer.classBySymbol.get(symbol)) ??
                 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
@@ -1486,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)");
                 }
             }
@@ -1784,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
@@ -1825,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
@@ -2767,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}`) ||
@@ -2849,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;
@@ -2984,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);
@@ -3065,6 +3086,10 @@ mixin) {
                         .map((f) => ({ name: f.name, type: f.type })),
                 ],
                 ...(methods.size > 0 ? { methods: [...methods.keys()] } : {}),
+                ...(() => {
+                    const names = classPrototypeNames(decl);
+                    return names.length > 0 ? { prototypeNames: names } : {};
+                })(),
                 ...(abstractClass ? { abstract: true } : {}),
                 ...(() => {
                     const am = [...methods.entries()].filter(([, s]) => s.abstract === true).map(([n]) => n);
@@ -3880,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)
@@ -3976,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)`);
     }
@@ -5511,6 +5537,33 @@ function lowerClassCtorInner(lowerer, info) {
         lowerer.currentClass = prevClass;
     }
 }
+/** The string keys a class declaration puts on its prototype: concrete
+ * instance methods and accessors with literal names. Symbol-keyed,
+ * private, static and abstract members are not prototype string keys. */
+function classPrototypeNames(decl) {
+    const names = [];
+    for (const member of decl.members) {
+        if (!ts.isMethodDeclaration(member) &&
+            !ts.isGetAccessorDeclaration(member) &&
+            !ts.isSetAccessorDeclaration(member))
+            continue;
+        if (ts
+            .getModifiers(member)
+            ?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword || m.kind === ts.SyntaxKind.AbstractKeyword))
+            continue;
+        const name = member.name;
+        let text = null;
+        if (ts.isIdentifier(name) || ts.isStringLiteralLike(name))
+            text = name.text;
+        else if (ts.isNumericLiteral(name))
+            text = String(Number(name.text));
+        else if (ts.isComputedPropertyName(name) && ts.isStringLiteralLike(name.expression))
+            text = name.expression.text;
+        if (text !== null && !names.includes(text))
+            names.push(text);
+    }
+    return names;
+}
 /** The lowered method-map name of a class member: identifier text, a
  * COMPUTED name that folds to one compile-time string
  * (foldedStringKeyOf — the object-literal computed-key machinery
@@ -6382,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
@@ -6451,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 —
@@ -6615,6 +6685,67 @@ function inheritsBuiltinStreamCtor(lowerer, info) {
 /** Preserve argument evaluation order and option presence through builtin
  * and inherited Error constructors. Checked-dynamic conversion retains
  * Error identity and distinguishes a missing cause from undefined. */
+/** `new AggregateError(errors, message, options)` in the spec's order:
+ * the message and cause install first, then `errors` iterates (a
+ * non-iterable throws out of the constructor). */
+function aggregateErrorConstructor(lowerer, loc) {
+    const name = "%aggregate.new";
+    if (lowerer.liftedFns.some((fn) => fn.name === name))
+        return name;
+    const type = { kind: "object", className: "%AggregateError" };
+    const context = newFnCtx(false, null, null, type);
+    lowerer.fnStack.push(context);
+    try {
+        const params = ["errors", "message", "options"].map((id) => ({
+            localId: id,
+            name: id,
+            type: DYN,
+        }));
+        const error = varRef("error", type, loc);
+        const list = checkedIterableSpread(lowerer, varRef("errors", DYN, loc), "", loc);
+        lowerer.liftedFns.push({
+            name,
+            params,
+            returnType: type,
+            locals: [
+                ...params.map((p) => ({ id: p.localId, name: p.name, type: DYN, mutable: false })),
+                { id: "error", name: "error", type, mutable: false },
+                ...context.locals,
+            ],
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: "error",
+                    init: {
+                        kind: "libCall",
+                        fn: "error.newAggregate",
+                        args: [varRef("message", DYN, loc), varRef("options", DYN, loc)],
+                        type,
+                        loc,
+                    },
+                    loc,
+                },
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "error.aggregateSetErrors",
+                        args: [error, list],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                },
+                { kind: "return", value: error, loc },
+            ],
+            loc,
+        });
+    }
+    finally {
+        lowerer.fnStack.pop();
+    }
+    return name;
+}
 export function errorConstructorArgs(lowerer, args, loc, blame) {
     if (args.length > 2)
         lowerer.unsupported("SC1090", blame, "Error constructors with more than two arguments");
@@ -6995,6 +7126,20 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
+        if (errInfo && errInfo.def.name === "%AggregateError") {
+            const args = expr.arguments ?? [];
+            if (args.length > 3 || args.some(ts.isSpreadElement)) {
+                lowerer.noLowering(`new AggregateError with this argument list`, expr);
+            }
+            const errors = args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc);
+            return {
+                kind: "call",
+                callee: aggregateErrorConstructor(lowerer, loc),
+                args: [errors, ...lowerer.errorConstructorArgs(args.slice(1), loc, expr)],
+                type: { kind: "object", className: "%AggregateError" },
+                loc,
+            };
+        }
         if (errInfo) {
             const args = lowerer.errorConstructorArgs(expr.arguments ?? [], loc, expr);
             return {