@scriptc/compiler 0.2.0 → 0.2.1

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

@@ -16,16 +16,16 @@ import { BOOL, DYN, F64, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, ca
 import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, newFnCtx, staticImportNamespaceType, uncheckedOverloadHandleCall } from "./lowerer.js";
 import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireSpecOf, isPromisifyCall, registerBuiltinCallableAlias, stripTypeCasts } from "./lower-builtins.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, funcTypeFromParamShapes, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishGenericBindingUnitOf, registerOverloadedCallableAlias } from "./lower-calls.js";
-import { hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl } from "./lower-stmts.js";
+import { jsBindingHasOpenWrites, hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl } from "./lower-stmts.js";
 import { objectFactorySignature } from "./object-factory-new.js";
 import { streamClassAliasDecl } from "./lower-stream.js";
 import { stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
-import { collectNamespaceStmt, nsPathPrefix, trapDeclRootOf } from "./lower-namespaces.js";
+import { collectNamespaceStmt, nsMemberIdentOf, nsPathPrefix, trapDeclRootOf } from "./lower-namespaces.js";
 import { collectExpandoMembers } from "./lower-expando.js";
 import { recordTextCodecClass } from "../../ir/ir.js";
 import { isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
-import { collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow } from "./lower-classes.js";
+import { collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType } from "./lower-classes.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { cjsModuleRef, cjsModuleRegistryPrelude } from "./lower-node-module.js";
 import { forkTargetPaths } from "../fork-target.js";
@@ -228,12 +228,41 @@ export function appendDynamicImportModules(program, order, onCycle) {
    * signatures are cheap and calls resolve against them; only BODY lowering
    * is reachability-gated. */
 export function collectProgram(lowerer, parts) {
+    const computed = new Set();
+    for (const fp of parts)
+        for (const decl of fp.classDecls) {
+            const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+            if (heritage && ts.isCallExpression(heritage))
+                computed.add(decl);
+        }
+    // Descendants need the computed ancestor's completed layout before
+    // their own fields and inherited methods can be collected.
+    const computedSymbols = new Set([...computed].map((decl) => declSymbolOf(lowerer, decl)).filter((symbol) => symbol !== undefined));
+    let expanded = true;
+    while (expanded) {
+        expanded = false;
+        for (const fp of parts)
+            for (const decl of fp.classDecls) {
+                if (computed.has(decl))
+                    continue;
+                const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+                const base = heritage && ts.isIdentifier(heritage) ? lowerer.resolveValueSymbol(heritage) : undefined;
+                if (!base || !computedSymbols.has(base))
+                    continue;
+                computed.add(decl);
+                const symbol = declSymbolOf(lowerer, decl);
+                if (symbol)
+                    computedSymbols.add(symbol);
+                expanded = true;
+            }
+    }
     lowerer.collecting = true;
     try {
         collectVirtualJsMethods(lowerer, parts.map((part) => part.sf));
         for (const fp of parts)
             for (const decl of fp.classDecls)
-                lowerer.collectClassShape(decl);
+                if (!computed.has(decl))
+                    lowerer.collectClassShape(decl);
         for (const fp of parts)
             for (const decl of fp.fnDecls)
                 lowerer.collectSignature(decl);
@@ -263,6 +292,60 @@ export function collectProgram(lowerer, parts) {
         lowerer.collectNpmImports(parts);
         lowerer.collectJsonImports(parts);
     }
+    for (const decl of computed) {
+        const symbol = declSymbolOf(lowerer, decl);
+        const wasCollecting = lowerer.collecting;
+        lowerer.collecting = true;
+        const previousSink = lowerer.diagSink;
+        const deferred = [];
+        lowerer.diagSink = deferred;
+        const expression = decl.heritageClauses.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword).types[0].expression;
+        const context = newFnCtx(false, null, null, DYN);
+        lowerer.fnStack.push(context);
+        try {
+            let value = lowerer.lowerExpr(expression);
+            const known = value.type.kind === "dyn" ? storedClassValueType(lowerer, expression) : null;
+            if (known?.kind === "classval")
+                value = lowerer.coerceToExpected(value, known);
+            if (value.type.kind === "dyn" || value.type.kind === "func") {
+                const name = `%class.base.${lowerer.classNamer(decl)}`;
+                const loc = locOf(expression);
+                lowerer.liftedFns.push({ name, params: [], returnType: value.type, locals: context.locals,
+                    body: [{ kind: "return", value, loc }], loc });
+                lowerer.computedCallableBases.set(decl, { kind: "call", callee: name, args: [], type: value.type, loc });
+            }
+            if (value.type.kind === "classval") {
+                const classInfo = lowerer.classes.get(value.type.className);
+                if (classInfo) {
+                    const name = `%class.base.${lowerer.classNamer(decl)}`;
+                    const loc = locOf(expression);
+                    lowerer.liftedFns.push({ name, params: [], returnType: value.type, locals: context.locals,
+                        body: [{ kind: "return", value, loc }], loc });
+                    lowerer.computedClassBases.set(lowerer.classNamer(decl), { value: { kind: "call", callee: name, args: [], type: value.type, loc }, classInfo });
+                }
+            }
+        }
+        catch (error) {
+            if (!(error instanceof PoisonError))
+                throw error;
+        }
+        finally {
+            lowerer.fnStack.pop();
+            lowerer.diagSink = previousSink;
+        }
+        lowerer.diagSink = deferred;
+        try {
+            lowerer.collectClassShape(decl);
+        }
+        finally {
+            lowerer.diagSink = previousSink;
+        }
+        if (symbol && deferred.length) {
+            lowerer.deferredDiags.set(symbol, [...(lowerer.deferredDiags.get(symbol) ?? []), ...deferred]);
+            lowerer.deferredClassByName.set(lowerer.classNamer(decl), symbol);
+        }
+        lowerer.collecting = wasCollecting;
+    }
 }
 /** The npm-import chokepoint, run once per pass during collection (so
    * bodies lowered in ANY pass resolve the bindings). In a static build
@@ -655,15 +738,41 @@ export function moduleArtifacts(lowerer, functions) {
     const pendingClasses = [];
     const pendingShapes = [];
     const pendingUnions = [];
+    const boxedChild = (type, seen = new Set()) => {
+        switch (type.kind) {
+            case "child": return true;
+            case "array":
+            case "set": return boxedChild(type.elem, seen);
+            case "promise": return boxedChild(type.inner, seen);
+            case "map": return boxedChild(type.key, seen) || boxedChild(type.value, seen);
+            case "func": return boxedChild(type.ret, seen);
+            case "record":
+                if (seen.has(type.shapeId))
+                    return false;
+                seen.add(type.shapeId);
+                return lowerer.shapes.get(type.shapeId)?.fields.some((field) => boxedChild(field.type, seen)) ?? false;
+            case "union":
+                if (seen.has(type.unionId))
+                    return false;
+                seen.add(type.unionId);
+                return lowerer.unions.get(type.unionId)?.arms.some((arm) => boxedChild(arm, seen)) ?? false;
+            default: return false;
+        }
+    };
     const visit = (node) => {
         if (Array.isArray(node)) {
-            for (const item of node)
-                visit(item);
+            // This walk only reads compiler-owned arrays. A callback traversal
+            // reuses one checked view instead of refreshing it at each step.
+            node.forEach(visit);
             return;
         }
         if (node === null || typeof node !== "object")
             return;
         const rec = node;
+        if (rec["kind"] === "dynFrom" && boxedChild(rec["value"].type)) {
+            // A generic child can expose native stdio without importing stream.
+            visit([{ className: "%Readable" }, { className: "%Writable" }]);
+        }
         if (typeof rec["className"] === "string" && !classNames.has(rec["className"])) {
             classNames.add(rec["className"]);
             pendingClasses.push(rec["className"]);
@@ -681,8 +790,25 @@ export function moduleArtifacts(lowerer, functions) {
                 visit(rec[key]);
         }
     };
-    visit(functions);
-    visit(lowerer.globalsList);
+    // Keep function lists and their typed slots in native storage. Reflective
+    // array iteration refreshes a complete view at each step; only executable
+    // nodes and individual types need the general dependency walk.
+    for (const fn of functions) {
+        for (const param of fn.params)
+            visit(param.type);
+        visit(fn.returnType);
+        for (const local of fn.locals)
+            visit(local.type);
+        for (const capture of fn.captures ?? [])
+            visit(capture.type);
+        for (const capture of fn.classCaptures ?? [])
+            visit(capture.type);
+        visit(fn.generator);
+        for (const stmt of fn.body)
+            visit(stmt);
+    }
+    for (const global of lowerer.globalsList)
+        visit(global.type);
     // The builtin error classes ride EVERY module: the runtime's own throws
     // (JSON/dynCheck/regex failures) mint instances of them whether or not
     // user code mentions Error, and the uncaught printer tells Error
@@ -803,7 +929,7 @@ function cjsScalarLiteral(e) {
  * a checked-dynamic (or unit) value, so a DYN module global can hold it:
  * no initializer, a unit literal, or a checker-`any` call/member/
  * identifier read (any-typed operations lower through the checked-dynamic tree in JS).
- * `new` expressions stay OUT even when checker-any (`new Anon.Sub()` over
+ * User-class `new` expressions stay OUT even when checker-any (`new Anon.Sub()` over
  * an expando class member constructs a TYPED instance — corpus 2032), as
  * does everything else (object/array literals have their own rules;
  * typed-but-unmappable initializers keep the %init-local adoption). */
@@ -827,6 +953,16 @@ function jsDynHoldableInitializer(lowerer, init) {
         e = e.expression;
     if (checkedGlobalReference(lowerer, e))
         return true;
+    if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) &&
+        ["freeze", "seal", "preventExtensions"].includes(e.expression.name.text) &&
+        lowerer.stdlibGlobalMember(e.expression, "Object") !== null && e.arguments[0] &&
+        ts.isArrayLiteralExpression(e.arguments[0]))
+        return true;
+    // The built-in Array constructor can create an evolving array whose
+    // inferred element type has no native mapping. Its checked reference
+    // must remain shared with separately declared functions and aliases.
+    if ((ts.isCallExpression(e) || ts.isNewExpression(e)) && lowerer.isStdlibGlobal(e.expression, "Array"))
+        return true;
     // JavaScript process streams lower to native checked handles even when
     // their declared method overloads prevent a structural type mapping.
     // Register the shared slot before separately declared functions lower.
@@ -834,6 +970,8 @@ function jsDynHoldableInitializer(lowerer, init) {
         const member = lowerer.stdlibGlobalMember(e, "process");
         if (member === "stdin" || member === "stdout" || member === "stderr")
             return true;
+        if (e.name.text === "constructor" && lowerer.checker.getCallSignatures(lowerer.typeOf(e.expression)).length > 0)
+            return true;
     }
     if (e.kind === ts.SyntaxKind.NullKeyword)
         return true;
@@ -851,6 +989,11 @@ function jsDynHoldableInitializer(lowerer, init) {
     if ((ts.isPropertyAccessExpression(e) || ts.isElementAccessExpression(e)) &&
         ts.isIdentifier(e.expression) && lowerer.globalOf(e.expression)?.type.kind === "dyn")
         return true;
+    if (ts.isPropertyAccessExpression(e)) {
+        const member = nsMemberIdentOf(lowerer, e);
+        if (member && (lowerer.globalOf(member)?.type.kind === "dyn" || lowerer.genericFnOf(member)?.implicitParams))
+            return true;
+    }
     // Optional callable reads (for example descriptor?.get) can be held in
     // the same checked slot as a callable. Their nullish arm must remain
     // observable by functions declared outside the module initializer.
@@ -862,6 +1005,8 @@ function jsDynHoldableInitializer(lowerer, init) {
         if (arms?.some(arm => arm.kind === "func") && arms.every(arm => isUnitType(arm) || (arm.kind === "func" && canBoxFuncIntoDyn(arm, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))))
             return true;
     }
+    if ((ts.isFunctionExpression(e) || ts.isArrowFunction(e)) && !e.typeParameters?.length && isJsSourceFile(e.getSourceFile()))
+        return true;
     if (ts.isIdentifier(e) || ts.isArrowFunction(e) || ts.isFunctionExpression(e)) {
         if (ts.isIdentifier(e)) {
             if (lowerer.globalOf(e)?.type.kind === "dyn")
@@ -1123,8 +1268,12 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     const diagsBefore = lowerer.diags.length;
                     try {
                         const strict = lowerer.typeOf(rhs);
-                        const t = lowerer.mapTypeOf(strict) ??
+                        let t = lowerer.mapTypeOf(strict) ??
                             (fnValued || factoryValued ? dynFallbackType(lowerer, rhs, strict) : null);
+                        // A returned object remains the live CommonJS root; later
+                        // exports.member writes must update that same open object.
+                        if (factoryValued && t?.kind === "record" && lowerer.dynConvertible(t))
+                            t = DYN;
                         if (t && t.kind !== "void") {
                             const g = { id: `%g.${tag}exports`, name: "exports", type: t, mutable: false };
                             lowerer.globalsByDeclNode.set(cjs.expr, g);
@@ -1493,6 +1642,23 @@ export function collectGlobals(lowerer, sf, topStmts) {
             for (const nameNode of boundIdentifiersOf(decl.name)) {
                 const diagsBefore = lowerer.diags.length;
                 try {
+                    // Checked JavaScript factories can expose inferred callables by
+                    // destructuring. Keep each exported binding in module storage so
+                    // separately lowered functions see the initialized value.
+                    if (isJsSourceFile(sf) && !ts.isIdentifier(decl.name) && decl.initializer &&
+                        !decl.type && !hasJsTypeAnnotation(decl) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode))) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                            const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text,
+                                type: DYN, mutable: isLet, source: bindingSource(nameNode),
+                                ...(!isVarDeclared(decl) ? { tdz: true } : {}) };
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
+                            if (isVarDeclared(decl))
+                                noteVarGlobalEntryInit(lowerer, sf, g);
+                        }
+                        continue;
+                    }
                     // Builtin declarations do not always describe the concrete native
                     // callable ABI. Preserve checked-native values in shared storage;
                     // adapting the loader to (string) would replace its validation.
@@ -1543,7 +1709,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     if (isJsSourceFile(sf) && ts.isIdentifier(decl.name) && nameNode === decl.name &&
                         decl.initializer && ts.isObjectLiteralExpression(decl.initializer) &&
                         decl.initializer.properties.some((p) => !ts.isSpreadAssignment(p) &&
-                            (ts.isMethodDeclaration(p) || ts.isAccessor(p) || ts.isComputedPropertyName(p.name)))) {
+                            (ts.isMethodDeclaration(p) || ts.isAccessor(p) || ts.isComputedPropertyName(p.name) ||
+                                ts.isShorthandPropertyAssignment(p) && lowerer.checker.getCallSignatures(lowerer.typeOf(p.name)).length > 0))) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
                             const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet, source: bindingSource(nameNode) };
@@ -1649,9 +1816,16 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
                         ts.isIdentifier(decl.name) && nameNode === decl.name && decl.initializer &&
                         jsDynHoldableInitializer(lowerer, decl.initializer)) {
-                        const fallback = dynFallbackType(lowerer, nameNode, lowerer.typeOf(nameNode));
+                        const initializer = decl.initializer;
+                        const member = ts.isPropertyAccessExpression(initializer) ? nsMemberIdentOf(lowerer, initializer) : null;
+                        const generic = member && lowerer.genericFnOf(member);
+                        const fallback = (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) && !initializer.typeParameters?.length
+                            ? lowerer.lambdaSignature(initializer).funcType
+                            : member && lowerer.globalOf(member)?.type.kind === "dyn" ? DYN
+                                : member && generic?.implicitParams ? lowerer.lowerGenericFnValue(member, generic).type
+                                    : dynFallbackType(lowerer, nameNode, lowerer.typeOf(nameNode));
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
-                        if (symbol && fallback && (fallback.kind === "func" || fallback.kind === "union") && lowerer.dynConvertible(fallback)) {
+                        if (symbol && fallback && (fallback.kind === "dyn" || fallback.kind === "func" || fallback.kind === "union") && lowerer.dynConvertible(fallback)) {
                             if (!lowerer.globalsBySymbol.has(symbol)) {
                                 const g = {
                                     id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text,
@@ -1691,7 +1865,30 @@ export function collectGlobals(lowerer, sf, topStmts) {
                                 // exactly the local rule (uncheckedOverloadHandleCall).
                                 (uncheckedOverloadHandleCall(lowerer, decl.initializer) ? JSVAL : null) : null)
                         : null;
-                    let type = handleT ?? factoryType ?? lowerer.irTypeOf(nameNode);
+                    // Unannotated results of JavaScript calls can carry callable
+                    // objects or heterogeneous unions absent from the native type
+                    // map. Their compiled initializer still validates every crossing.
+                    const callSignature = !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer && ts.isCallExpression(decl.initializer)
+                        ? lowerer.checker.getResolvedSignature(decl.initializer) : undefined;
+                    const callDeclaration = callSignature && lowerer.checker.signatureDeclaration(callSignature);
+                    const inferredJsCall = callDeclaration && isJsSourceFile(callDeclaration.getSourceFile()) &&
+                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode));
+                    let type = handleT ?? factoryType ?? (inferredJsCall ? DYN : lowerer.irTypeOf(nameNode));
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer &&
+                        (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) &&
+                        !decl.initializer.typeParameters?.length) {
+                        type = lowerer.lambdaSignature(decl.initializer).funcType;
+                    }
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
+                        decl.initializer && ts.isCallExpression(decl.initializer) && type.kind === "union") {
+                        const arms = lowerer.unions.get(type.unionId)?.arms;
+                        if (arms?.some((arm) => arm.kind === "record") && arms.every((arm) => isUnitType(arm) || arm.kind === "record"))
+                            type = DYN;
+                    }
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer &&
+                        ts.isNewExpression(decl.initializer) && lowerer.mapTypeOf(lowerer.typeOf(decl.initializer.expression))?.kind === "dyn" &&
+                        !(ts.isIdentifier(decl.initializer.expression) && lowerer.isStdlibSymbol(lowerer.checker.getSymbolAtLocation(decl.initializer.expression))))
+                        type = DYN;
                     // Calls through checked function values retain their object
                     // identity, including symbol keys absent from inferred records.
                     if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "record" &&
@@ -1711,6 +1908,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // a fixed-signature adapter to reconstruct its hidden rest ABI.
                     if (!decl.type && !hasJsTypeAnnotation(decl) && type.kind === "func" && type.rest === true && type.restAbi === undefined)
                         type = DYN;
+                    if (isJsSourceFile(sf) && isLet && !decl.type && !hasJsTypeAnnotation(decl) &&
+                        (type.kind === "object" || jsBindingHasOpenWrites(lowerer, decl)))
+                        type = DYN;
                     // JavaScript call results may retain a checked array supplied by
                     // the caller. A typed global here would copy it on extraction.
                     if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "array" &&
@@ -1793,8 +1993,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // adapter would re-copy at the assignment.
                     if (isJsSourceFile(sf) &&
                         type.kind === "func" &&
-                        type.ret.kind === "record" &&
-                        lowerer.dynConvertible(type.ret) &&
+                        (type.ret.kind === "date" || type.ret.kind === "record" && lowerer.dynConvertible(type.ret)) &&
                         decl.initializer !== undefined &&
                         (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer)) &&
                         decl.initializer.type === undefined &&
@@ -1811,6 +2010,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                             type = DYN;
                     }
                     // Module vars hold real undefined until their declaration runs.
+                    // Unannotated JS function values need that state too: callers
+                    // before the initializer must see undefined and a TypeError.
+                    if (isJsSourceFile(sf) && isVarDeclared(decl) && type.kind === "func" && lowerer.dynConvertible(type))
+                        type = DYN;
                     // Codec records keep that state in the ordinary optional union;
                     // lexical codec declarations retain their separate TDZ guard.
                     const codec = type.kind === "record" && recordTextCodecClass(lowerer.shapes.get(type.shapeId)) !== null;
@@ -2214,7 +2417,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
         // SITE's position instead (below) — their inner class node may
         // even live in another file.
         c.decl && ts.isClassDeclaration(c.decl) && !c.mixinInstance && c.decl.getSourceFile() === sf &&
-            (c.callableBase !== undefined || c.staticFields.length > 0 || (c.staticBlocks?.length ?? 0) > 0 || c.classDecorators !== undefined))
+            (c.callableBase !== undefined || c.def.baseValueGlobal !== undefined || c.staticFields.length > 0 || (c.staticBlocks?.length ?? 0) > 0 || c.classDecorators !== undefined))
             .map((c) => ({ pos: c.decl.getStart(), info: c }));
         // Statics-bearing MIXIN instantiations whose call evaluates in THIS
         // file: their declaration-time code runs when the call does — the