@scriptc/compiler 0.2.5 → 0.2.6

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

@@ -2,6 +2,7 @@ import * as ts from "../ts7/adapter.js";
 import type { FnCtx, Lowerer } from "./lowerer.js";
 import { type IrClassDef, type IrExpr, type IrFunction, type IrLocal, type IrStmt, type IrType, type SrcLoc } from "../../ir/ir.js";
 import { type GenericFnInfo } from "./generic-functions.js";
+import { type InstantiationPath } from "./instantiation-path.js";
 import { type ParamShape } from "./call-signatures.js";
 import { type ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { type EmitOverrideRec } from "./lower-event-emitter.js";
@@ -131,6 +132,8 @@ export interface ClassInfo {
      * (forwarding the completed ABI values; defaults apply in the base). */
     ctorParams: ParamShape[];
     base: ClassInfo | null;
+    /** Family heritage resolves its type arguments separately for each instance. */
+    genericBase?: ts.ExpressionWithTypeArguments;
     /** A module class may inherit a compiled ordinary JS constructor. Its
      * callable and prototype are captured when the class declaration runs. */
     callableBase?: {
@@ -214,6 +217,7 @@ export interface ClassInfo {
      * counts statements toward coverage — re-instantiations re-visit the
      * same source lines). */
     genericInstance?: {
+        path: InstantiationPath;
         family: ClassInfo;
         bindings: Map<ts.Symbol, IrType>;
         typeArgsText: string;
@@ -376,6 +380,7 @@ export declare function guaranteedDecorationThrow(lowerer: Lowerer, decl: ts.Cla
 } | null;
 export declare function collectClassShape(lowerer: Lowerer, decl: ts.ClassDeclaration): void;
 export declare function collectClassShapeInner(lowerer: Lowerer, decl: ts.ClassLikeDeclaration, jsNameOverride?: string, inst?: {
+    path: InstantiationPath;
     family: ClassInfo;
     name: string;
     bindings: Map<ts.Symbol, IrType>;

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

@@ -7,7 +7,8 @@ import { InternalCompilerError } from "../../errors.js";
  * hierarchy registration. */
 import * as ts from "../ts7/adapter.js";
 import { BOOL, DATE_T, DYN, F64, bytesOf, JSVAL, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
-import { MAX_GENERIC_INSTANCES, genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, } from "./generic-functions.js";
+import { genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, } from "./generic-functions.js";
+import { extendInstantiationPath, MAX_INSTANTIATION_RECURSION, } from "./instantiation-path.js";
 import { appendImplicitUndefinedReturn, hasExplicitJsDocReturn } from "./function-returns.js";
 import { bodyReadsArguments } from "../arguments-usage.js";
 import { generatorMeta } from "./call-signatures.js";
@@ -22,6 +23,7 @@ import { bufEncoding } from "./containers/bytes.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { lowerSearchParamsNew } from "./builtins/url.js";
 import { lowerTextCodecNew } from "./builtins/text-codecs.js";
+import { lowerWorkerNew } from "./builtins/workers.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-event-emitter.js";
@@ -949,7 +951,36 @@ export function guaranteedDecorationThrow(lowerer, decl) {
     return null;
 }
 export function collectClassShape(lowerer, decl) {
-    const symbol = lowerer.collectDeferring(() => declSymbolOf(lowerer, decl), () => lowerer.collectClassShapeInner(decl));
+    if (lowerer.classes.has(lowerer.classNamer(decl)) ||
+        lowerer.collectingClassDeclarations.has(decl))
+        return;
+    lowerer.collectingClassDeclarations.add(decl);
+    try {
+        collectClassShapeDeferring(lowerer, decl);
+    }
+    finally {
+        lowerer.collectingClassDeclarations.delete(decl);
+    }
+}
+function collectClassShapeDeferring(lowerer, decl) {
+    const symbol = lowerer.collectDeferring(() => declSymbolOf(lowerer, decl), () => {
+        // A forward type reference can demand this class before collection
+        // reaches its earlier base declaration. Collect that dependency first;
+        // a later same-file base remains subject to the runtime order boundary.
+        const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+        const reference = heritage && ts.isPropertyAccessExpression(heritage) ? heritage.name : heritage;
+        const baseSymbol = reference && ts.isIdentifier(reference) ? lowerer.resolveValueSymbol(reference) : undefined;
+        const baseDeclaration = baseSymbol
+            ? lowerer.checker.declarationsOf(baseSymbol).find(ts.isClassDeclaration)
+            : undefined;
+        if (baseDeclaration &&
+            !lowerer.isStdlibSymbol(baseSymbol ?? undefined) &&
+            !baseDeclaration.getSourceFile().isDeclarationFile &&
+            (baseDeclaration.getSourceFile() !== decl.getSourceFile() ||
+                baseDeclaration.getStart() < decl.getStart()))
+            lowerer.collectClassShape(baseDeclaration);
+        lowerer.collectClassShapeInner(decl);
+    });
     // Typed receivers and module retention know the class only by its
     // qualified IR name — index the deferral under it too.
     if (symbol)
@@ -1212,18 +1243,16 @@ mixin) {
             lowerer.unsupported("SC1090", decl, "generic class expressions");
         }
         const className = inst ? inst.name : mixin ? mixin.name : lowerer.classNamer(decl); // program-wide qualified name
-        // Single inheritance: `extends` of a class declared in the program.
-        // tsc guarantees the base is declared before the derived class (its
-        // use-before-declaration error), and collection runs in module order,
-        // so the base's ClassInfo already exists here. An INSTANTIATION's
-        // base is its family (whose base is the declared one) — the heritage
-        // clause resolved when the family collected.
+        // Collection follows module order for runtime heritage. Ordinary
+        // instances use the family as their storage base; generic heritage
+        // resolves a concrete base under each instance's type bindings.
         const computedBase = lowerer.computedClassBases.get(lowerer.classNamer(decl));
         let base = inst
             ? inst.family
             : mixin
                 ? mixin.base
                 : (computedBase?.classInfo ?? null);
+        let genericBase;
         let callableBase;
         let factoryBaseExpression;
         const adoptCallableBase = (expression) => {
@@ -1250,35 +1279,12 @@ mixin) {
             };
             return true;
         };
-        // A family whose `extends` clause mentions its OWN type parameters
-        // (`class D<T> extends Box<T>`) would need a different base per
-        // instantiation — no single family interval can sit above all of
-        // them. Named fence at the declaration.
-        if (familyMode && decl.heritageClauses !== undefined) {
-            const tpSyms = new Set();
-            for (const tp of decl.typeParameters) {
-                const s = lowerer.checker.getSymbolAtLocation(tp.name);
-                if (s)
-                    tpSyms.add(s);
-            }
-            for (const clause of decl.heritageClauses) {
-                if (clause.token !== ts.SyntaxKind.ExtendsKeyword)
-                    continue;
-                for (const t of clause.types) {
-                    let mentions = false;
-                    ts.walkPreorder(t, (n) => {
-                        const s = ts.isIdentifier(n) ? lowerer.checker.getSymbolAtLocation(n) : undefined;
-                        if (s && tpSyms.has(s)) {
-                            mentions = true;
-                            return "stop";
-                        }
-                        return undefined;
-                    });
-                    if (mentions) {
-                        lowerer.unsupported("SC1090", t, "generic classes whose 'extends' clause mentions their own type parameters (each instantiation would need a different base)");
-                    }
-                }
-            }
+        const ownGenericBase = inst?.family.genericBase;
+        if (inst && ownGenericBase) {
+            const mapped = lowerer.mapTypeOf(lowerer.checker.getTypeAtLocation(ownGenericBase));
+            base = mapped?.kind === "object" ? (lowerer.classes.get(mapped.className) ?? null) : null;
+            if (!base || base.generic)
+                lowerer.unsupported("SC1090", ownGenericBase, "a generic base whose type arguments have no concrete layout");
         }
         for (const clause of inst || mixin || computedBase ? [] : (decl.heritageClauses ?? [])) {
             // `implements` is pure type-world: tsc checked the conformance and
@@ -1288,6 +1294,22 @@ mixin) {
             if (clause.token === ts.SyntaxKind.ImplementsKeyword)
                 continue;
             const t = clause.types[0];
+            if (familyMode && t) {
+                const reference = ts.isPropertyAccessExpression(t.expression)
+                    ? t.expression.name
+                    : t.expression;
+                const symbol = ts.isIdentifier(reference)
+                    ? lowerer.resolveValueSymbol(reference)
+                    : undefined;
+                const familyBase = symbol ? lowerer.classBySymbol.get(symbol) : undefined;
+                if (familyBase?.generic) {
+                    if (symbol && ts.isPropertyAccessExpression(t.expression))
+                        fenceEarlyNsMemberRef(lowerer, t.expression, symbol);
+                    base = familyBase;
+                    genericBase = t;
+                    continue;
+                }
+            }
             // `extends events.EventEmitter` — the namespace-member spelling of
             // the ambient emitter base resolves like the named import.
             if (t && ts.isPropertyAccessExpression(t.expression) && ts.isIdentifier(t.expression.name)) {
@@ -1669,6 +1691,7 @@ mixin) {
                         lowerer.badType(member.name, lowerer.typeOf(member.name));
                     if (type.kind === "dyn" &&
                         !isJsSourceFile(member.getSourceFile()) &&
+                        !lowerer.classImplementedProtocol(lowerer.typeOf(member.name)) &&
                         (member.type !== undefined ||
                             (lowerer.typeOf(member.name).flags & ts.TypeFlags.Any) === 0)) {
                         lowerer.unsupported("SC1090", member.name, "'unknown'-typed static fields");
@@ -1899,7 +1922,9 @@ mixin) {
                             : null;
                     if (!type ||
                         type.kind === "void" ||
-                        (type.kind === "dyn" && !isJsSourceFile(member.getSourceFile())))
+                        (type.kind === "dyn" &&
+                            !isJsSourceFile(member.getSourceFile()) &&
+                            !lowerer.classImplementedProtocol(inferred)))
                         lowerer.badType(member, inferred);
                     if (isJsSourceFile(member.getSourceFile())) {
                         type = inheritedJsFieldType(lowerer, decl, fieldName, type);
@@ -2027,7 +2052,9 @@ mixin) {
                 // Bundled JS declares fields without annotations before assigning
                 // them in the constructor. Use the same native checked-dynamic
                 // storage as implicit constructor-assigned JS fields.
-                if (type.kind === "dyn" && !isJsSourceFile(member.getSourceFile())) {
+                if (type.kind === "dyn" &&
+                    !isJsSourceFile(member.getSourceFile()) &&
+                    !lowerer.classImplementedProtocol(lowerer.typeOf(member.name))) {
                     lowerer.unsupported("SC1090", member.name, "'unknown'-typed class fields");
                 }
                 const undefinedInitializer = type.kind === "dyn" && !member.initializer ? locOf(member) : undefined;
@@ -2155,7 +2182,7 @@ mixin) {
                     if (type.kind === "void")
                         lowerer.badType(p.name, lowerer.typeOf(p.name));
                     // The class-field dyn rule verbatim (KEEP NARROW).
-                    if (type.kind === "dyn") {
+                    if (type.kind === "dyn" && !lowerer.classImplementedProtocol(lowerer.typeOf(p))) {
                         lowerer.unsupported("SC1090", p.name, "'unknown'-typed class fields");
                     }
                     // `override x` (and any same-named inherited member) would
@@ -3015,6 +3042,7 @@ mixin) {
             ctorParams,
             ...(paramProps.length > 0 ? { paramProps } : {}),
             base,
+            ...(genericBase ? { genericBase } : {}),
             ...(callableBase ? { callableBase } : {}),
             ...(factoryBaseExpression ? { factoryBaseExpression } : {}),
             subclasses: [],
@@ -3044,6 +3072,7 @@ mixin) {
         }
         if (inst) {
             info.genericInstance = {
+                path: inst.path,
                 family: inst.family,
                 bindings: inst.bindings,
                 typeArgsText: inst.typeArgsText,
@@ -3146,7 +3175,14 @@ mixin) {
  * arguments, the instance cap, an uncollected family) make the whole
  * reference unmappable — per-site diagnostics own the fence. */
 export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
-    const gci = lowerer.genericClassByDecl.get(decl);
+    let gci = lowerer.genericClassByDecl.get(decl);
+    if (!gci && ts.isClassDeclaration(decl)) {
+        // A method signature can reference a generic class declared later in
+        // the same module. Resolve its family now rather than freezing the
+        // signature at the erased family layout for the rest of the build.
+        lowerer.collectClassShape(decl);
+        gci = lowerer.genericClassByDecl.get(decl);
+    }
     if (!gci) {
         // The family never collected (a deferred/poisoned declaration): the
         // pre-generics answer — the class's own name, unregistered, so dead
@@ -3203,12 +3239,12 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
             lowerer.noteGenericClassInstanceDemand(existing.info);
         return existing.poisoned ? null : { kind: "object", className: existing.name };
     }
-    // The generic-fn cap, same rationale (polymorphic recursion through
-    // class fields would mint instances forever). mapType has no
-    // diagnostic channel — the family answer keeps the site compilable
-    // where the OBJECT itself is never touched; touched members fence.
-    if (gci.instances.size >= MAX_GENERIC_INSTANCES)
-        return familyT;
+    // Recursive class fields and queued member bodies share the function
+    // demand budget. Independent uses do not limit the family size.
+    const path = extendInstantiationPath(lowerer.genericInstantiationPath, decl);
+    if (!path) {
+        lowerer.unsupported("SC1090", decl, `unbounded generic class instantiation ('${gci.baseName}' exceeded ${MAX_INSTANTIATION_RECURSION} recursive specializations on one demand path)`);
+    }
     const ordinal = gci.instances.size;
     const name = `${gci.family.def.name}%${ordinal}`;
     const entry = { name, info: null };
@@ -3219,10 +3255,13 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`;
     const prevBindings = lowerer.typeParamBindings;
     const prevContext = lowerer.instantiationContext;
+    const previousPath = lowerer.genericInstantiationPath;
+    lowerer.genericInstantiationPath = path;
     lowerer.typeParamBindings = bindings;
     lowerer.instantiationContext = `instantiating class '${gci.baseName}' with ${typeArgsText}`;
     try {
         lowerer.collectClassShapeInner(decl, undefined, {
+            path,
             family: gci.family,
             name,
             bindings,
@@ -3241,6 +3280,7 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     finally {
         lowerer.typeParamBindings = prevBindings;
         lowerer.instantiationContext = prevContext;
+        lowerer.genericInstantiationPath = previousPath;
     }
     const info = lowerer.classes.get(name);
     if (!info) {
@@ -3290,6 +3330,8 @@ function withInstanceBindings(lowerer, info, fn) {
     const prevBindings = lowerer.typeParamBindings;
     const prevContext = lowerer.instantiationContext;
     const prevSuppress = lowerer.suppressStats;
+    const previousPath = lowerer.genericInstantiationPath;
+    lowerer.genericInstantiationPath = gi.path;
     lowerer.typeParamBindings = gi.bindings;
     lowerer.instantiationContext = `instantiating class '${gi.family.generic?.baseName ?? info.def.jsName ?? ""}' with ${gi.typeArgsText}`;
     lowerer.suppressStats = prevSuppress || gi.ordinal > 0;
@@ -3300,6 +3342,7 @@ function withInstanceBindings(lowerer, info, fn) {
         lowerer.typeParamBindings = prevBindings;
         lowerer.instantiationContext = prevContext;
         lowerer.suppressStats = prevSuppress;
+        lowerer.genericInstantiationPath = previousPath;
     }
 }
 /** The `%init` statements for one class's static readonly fields AND
@@ -4420,6 +4463,19 @@ export function lowerStaticMethodCall(lowerer, call, access) {
         if (info)
             return staticCallOn(lowerer, call, access, info, false);
     }
+    // Namespace exports are immutable bindings to the same declaration as
+    // named imports. Resolve them before asking for a constructor-value ABI:
+    // a generic family has statics but no single constructor signature.
+    if (ts.isPropertyAccessExpression(access.expression) && !access.expression.questionDotToken) {
+        const member = nsMemberIdentOf(lowerer, access.expression);
+        const symbol = member ? lowerer.resolveValueSymbol(member) : null;
+        const info = symbol ? lowerer.classBySymbol.get(symbol) : undefined;
+        if (info && info.classDecorators?.valueGlobalId === undefined) {
+            if (symbol)
+                fenceEarlyNsMemberRef(lowerer, access.expression, symbol);
+            return staticCallOn(lowerer, call, access, info, false);
+        }
+    }
     // `module.exports.describe()` in a module whose whole export IS a
     // class expression: the receiver is exactly that class (the kept
     // export assignment pins it) — the direct-name rules apply.
@@ -4726,9 +4782,15 @@ export function findMethodOn(lowerer, info, name) {
 }
 /** True when `sub` is a STRICT descendant of `sup` in the class graph. */
 export function isSubclassOf(lowerer, sub, sup) {
-    for (let c = lowerer.classes.get(sub)?.base ?? null; c; c = c.base) {
-        if (c.def.name === sup)
+    if (sub === sup)
+        return false;
+    for (let c = lowerer.classes.get(sub); c; c = c.base ?? undefined) {
+        if (c.def.name === sup && c.def.name !== sub)
             return true;
+        for (let family = c.genericInstance?.family; family; family = family.base ?? undefined) {
+            if (family.def.name === sup)
+                return true;
+        }
     }
     return false;
 }
@@ -5065,7 +5127,7 @@ export function exactInstanceClassOf(lowerer, expr) {
  * Const + direct `new` only — a reassignable binding or a produced
  * value keeps today's record story and its fences. */
 export function genericIfaceBindingKeepsClass(lowerer, decl, declaredType) {
-    if (declaredType.kind !== "record")
+    if (declaredType.kind !== "record" && declaredType.kind !== "dyn")
         return false;
     if (!ts.isIdentifier(decl.name) || decl.initializer === undefined || decl.type === undefined)
         return false;
@@ -5076,13 +5138,16 @@ export function genericIfaceBindingKeepsClass(lowerer, decl, declaredType) {
         init = init.expression;
     if (!ts.isNewExpression(init))
         return false;
-    const shape = lowerer.shapes.get(declaredType.shapeId);
-    if (!shape || shape.fields.length > 0 || shape.indexValue !== undefined || shape.tuple === true)
-        return false;
     const annT = lowerer.typeOf(decl.name);
     const props = lowerer.checker.getPropertiesOfType(annT);
     if (props.length === 0)
         return false;
+    if (declaredType.kind === "dyn")
+        return (lowerer.classImplementedProtocol(annT) &&
+            props.some((property) => isGenericCallableMemberType(lowerer.checker.getTypeOfSymbol(property), lowerer.checker)));
+    const shape = lowerer.shapes.get(declaredType.shapeId);
+    if (!shape || shape.fields.length > 0 || shape.indexValue !== undefined || shape.tuple === true)
+        return false;
     return props.every((p) => isGenericCallableMemberType(lowerer.checker.getTypeOfSymbol(p), lowerer.checker));
 }
 /** `recv.m<T>(args)` — a GENERIC method call, dispatched STATICALLY: the
@@ -6599,6 +6664,9 @@ function assignedThisFieldType(lowerer, expr) {
 }
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
+    const worker = lowerWorkerNew(lowerer, expr);
+    if (worker)
+        return worker;
     let intlConstructor = expr.expression;
     if (ts.isIdentifier(intlConstructor)) {
         const symbol = lowerer.resolveValueSymbol(intlConstructor);