@scriptc/compiler 0.3.2 → 0.3.4

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

@@ -112,10 +112,19 @@ 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;
+    /** The synthetic InternTable class (@scriptc/experimental,
+     * intern-tables.ts): synthesized like lifetimeRegion. */
+    internTable?: 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
@@ -663,8 +672,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

@@ -8,6 +8,7 @@ import { InternalCompilerError } from "../../errors.js";
  * accessor access, upcasts, `new` expressions, and the builtin Error
  * hierarchy registration. */
 import * as ts from "../ts7/adapter.js";
+import { lowerZlibStreamNew, zlibStreamModeOf } from "./builtins/compression.js";
 import { BOOL, DATE_T, DYN, F64, bytesOf, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
 import { genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, } from "./generic-functions.js";
 import { extendInstantiationPath, MAX_INSTANTIATION_RECURSION, } from "./instantiation-path.js";
@@ -18,6 +19,7 @@ import { omittedArgFor } from "./call-arguments.js";
 import { isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
 import { cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeTypesPath, locOf, } from "../program.js";
 import { PoisonError, dynFallbackType, newFnCtx, own } from "./lowerer.js";
+import { isAssertClassNew } from "./assert-instances.js";
 import { lowerArrayConstructor } from "./containers/array-construction.js";
 import { lowerMapSeedNew, lowerSetSeedNew } from "./containers/collection-methods.js";
 import { lowerObjectConstructor } from "./containers/indexed-objects.js";
@@ -28,6 +30,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 +993,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);
@@ -1440,10 +1443,14 @@ mixin) {
             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)");
             }
+            if (lowerer.builtinErrorInfoOf(symbol)?.def.name === "%AssertionError") {
+                lowerer.unsupported("SC1090", t, "extending AssertionError (its constructor takes an options object the subclass constructor would have to forward — extend Error, or construct AssertionError directly)");
+            }
             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
@@ -1494,7 +1501,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 +1801,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 +1842,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 +2793,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 +2875,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 +3010,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 +3910,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 +4007,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 +6440,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 +6511,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 —
@@ -6935,6 +6971,12 @@ export function lowerNew(lowerer, expr) {
         const streamInfoNs = builtinStreamInfoOf(lowerer, resolved);
         if (streamInfoNs)
             return lowerStreamNew(lowerer, expr, streamInfoNs);
+        // `new zlib.Gzip(options?)` — the zlib stream classes.
+        const zlibModeNs = zlibStreamModeOf(lowerer, resolved);
+        if (zlibModeNs !== null) {
+            const what = `new zlib.${expr.expression.name.text}`;
+            return lowerZlibStreamNew(lowerer, expr.arguments ?? [], zlibModeNs, what, expr, loc);
+        }
         // `new N.C(...)` / `new a.Point(...)` — construction through a
         // USER namespace qualifier (import= alias chains included): the
         // member resolves to the registered program class, guarded by the
@@ -7095,6 +7137,26 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
+        // `new Assert(...)` that is not a static instance (assert-instances.ts):
+        // the instance would be a run-time value.
+        if (isAssertClassNew(lowerer, expr)) {
+            lowerer.noLowering("assert.Assert instances used as values", expr, "bind `new Assert(...)` with literal options to a const and only call methods on it (`const a = new Assert({ diff: 'full' }); a.strictEqual(x, y)`)");
+        }
+        if (errInfo && errInfo.def.name === "%AssertionError") {
+            // new AssertionError(options): Node validates the options object and
+            // generates the message from operator, actual and expected.
+            const args = expr.arguments ?? [];
+            if (args.length > 1 || args.some(ts.isSpreadElement)) {
+                lowerer.noLowering(`new AssertionError with this argument list`, expr);
+            }
+            return {
+                kind: "libCall",
+                fn: "assert.errorNew",
+                args: [args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc)],
+                type: { kind: "object", className: "%AssertionError" },
+                loc,
+            };
+        }
         if (errInfo && errInfo.def.name === "%AggregateError") {
             const args = expr.arguments ?? [];
             if (args.length > 3 || args.some(ts.isSpreadElement)) {
@@ -7140,6 +7202,11 @@ export function lowerNew(lowerer, expr) {
         const streamInfo = builtinStreamInfoOf(lowerer, symbol);
         if (streamInfo)
             return lowerStreamNew(lowerer, expr, streamInfo);
+        const zlibMode = zlibStreamModeOf(lowerer, symbol);
+        if (zlibMode !== null) {
+            const what = `new zlib.${symbol.name}`;
+            return lowerZlibStreamNew(lowerer, expr.arguments ?? [], zlibMode, what, expr, loc);
+        }
         // `new URL(input)`: the WHATWG URL class (stdlib/@types provenance —
         // a user's own `class URL` resolves through classBySymbol below).
         // Invalid input or base throws a catchable TypeError ("Invalid URL").