tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/checker-emit-resolver.js

@@ -0,0 +1,579 @@
+// Declaration emit's queries answered by the checker, as tsgo's emit resolver: visibility and
+// accessibility from resolved symbols, and type nodes built from types. JavaScript emit's
+// queries, enum values and references between files are answered syntactically, except how
+// decorator metadata serializes a type reference, which comes from the referenced type.
+import { BigIntLiteral, BinaryExpression, ElementAccessExpression, ExportAssignment, ExportSpecifier, ExpressionStatement, ImportEqualsDeclaration, IndexSignatureDeclaration, NodeVisitor, PrefixUnaryExpression, PropertyAccessExpression, PropertyDeclaration, SourceFile, VariableDeclaration, Token, getBody, getExpression, getName, getPostfixToken, getQuestionToken, getText, getSymbol, } from './ast.js';
+import { nodeIsPresent } from './ast-utilities.js';
+import { getAssignmentDeclarationKind, getCombinedModifierFlags, getCombinedNodeFlags, getSourceFileOfNode, isEntityNameExpression, isParameterPropertyDeclaration, isStringOrNumericLiteralLike, } from './binder-utilities.js';
+import { getEffectiveDeclarationFlags } from './checker-declarations.js';
+import { getBaseTypes, getDeclaredTypeOfSymbol, isConstructorType } from './checker-declared-types.js';
+import { getResolvedSymbol } from './checker-expressions.js';
+import { tryGetNameFromEntityNameExpression } from './checker-narrowing.js';
+import { getIndexInfosOfType, getIndexSymbol, getPropertiesOfType, getPropertyOfType, getSignaturesOfType, } from './checker-members.js';
+import { getExternalModuleFileFromDeclaration, getTargetOfExportSpecifier, getTypeOnlyAliasDeclarationOfMeaning, isTypeOnlyImportOrExportDeclaration, } from './checker-modules.js';
+import { getIndexInfosOfIndexSymbol, getSignatureFromDeclaration, getSignaturesOfSymbol, } from './checker-signatures.js';
+import { getTypeOfSymbol, getWidenedType, isReadonlySymbol } from './checker-symbol-types.js';
+import { getExportsOfModule, getFirstIdentifier, getGlobalSymbol, getGlobalValueSymbol, getMergedSymbol, getMembersOfSymbol, getSymbolOfDeclaration, resolveAlias, resolveEntityName, resolveName, } from './checker-symbols.js';
+import { isArrayType, isErrorType, isFreshLiteralType, isTupleType } from './checker-type-factory.js';
+import { isTypeAssignableToKind } from './checker-type-operators.js';
+import { hasLateBindableName } from './checker-utilities.js';
+import { NodeBuilder, isEntityNameVisible, isOptionalParameter } from './node-builder.js';
+import { getRegularTypeOfExpression, newPseudoChecker, requiresAddingImplicitUndefinedForDeclaration, } from './node-builder-pseudo.js';
+import { symbolToExpression } from './node-builder-names.js';
+import { tryReuseExistingNode } from './node-builder-reuse.js';
+import { isTypeIdenticalTo } from './relations.js';
+import { beginDeclarationEmitVisibility, isDeclarationVisible, isSymbolAccessible, markDeclarationVisible, } from './symbol-accessibility.js';
+import { DeclarationEmitResolver, } from './transformers/declarations-resolver.js';
+import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
+const declarationEmitInternalFlags = 8 /* NodeBuilderInternalFlags.AllowUnresolvedNames */;
+const aliasMeaning = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */;
+export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
+    checker;
+    /** Answers the queries that don't need types. */
+    syntactic;
+    aliasesMarked;
+    constructor(checker, syntactic) {
+        super();
+        this.checker = checker;
+        this.syntactic = syntactic;
+        this.aliasesMarked = new Set();
+    }
+    // JavaScript emit
+    markLinkedReferences(file) {
+        return this.syntactic.markLinkedReferences(file);
+    }
+    isReferencedAliasDeclaration(node) {
+        return this.syntactic.isReferencedAliasDeclaration(node);
+    }
+    isValueAliasDeclaration(node) {
+        return this.syntactic.isValueAliasDeclaration(node);
+    }
+    isTopLevelValueImportEqualsWithEntityName(node) {
+        return this.syntactic.isTopLevelValueImportEqualsWithEntityName(node);
+    }
+    getTypeReferenceSerializationKind(typeName, location) {
+        return getTypeReferenceSerializationKind(this.checker, typeName, location);
+    }
+    getReferencedExportContainer(node, prefixLocals) {
+        return this.syntactic.getReferencedExportContainer(node, prefixLocals);
+    }
+    getReferencedImportDeclaration(node) {
+        return this.syntactic.getReferencedImportDeclaration(node);
+    }
+    getReferencedValueDeclaration(node) {
+        return this.syntactic.getReferencedValueDeclaration(node);
+    }
+    getReferencedValueDeclarations(node) {
+        return this.syntactic.getReferencedValueDeclarations(node);
+    }
+    getEnumMemberValue(member) {
+        return this.syntactic.getEnumMemberValue(member);
+    }
+    setReferencedImportDeclaration(name, declaration) {
+        this.syntactic.setReferencedImportDeclaration(name, declaration);
+    }
+    getJsxFactoryEntity(file) {
+        return this.syntactic.getJsxFactoryEntity(file);
+    }
+    getJsxFragmentFactoryEntity(file) {
+        return this.syntactic.getJsxFragmentFactoryEntity(file);
+    }
+    getConstantValue(node) {
+        return this.syntactic.getConstantValue(node);
+    }
+    // Visibility
+    precalculateDeclarationEmitVisibility(file) {
+        beginDeclarationEmitVisibility(this.checker, file);
+        if (this.aliasesMarked.has(file))
+            return false;
+        this.aliasesMarked.add(file);
+        file.forEachChild(new AliasMarker(this));
+        return true;
+    }
+    /** Marks the declarations an export names visible, following `import x = a.b` chains. */
+    markLinkedAliases(node) {
+        const c = this.checker;
+        const parent = node.parent;
+        let exportSymbol = undefined;
+        if (node.kind !== 10 /* SyntaxKind.StringLiteral */ &&
+            parent !== undefined &&
+            (parent.kind === 278 /* SyntaxKind.ExportAssignment */ || isCommonJSModuleExports(parent)))
+            exportSymbol = resolveName(c, node, getText(node), aliasMeaning, undefined, false, false);
+        else if (parent !== undefined && parent.kind === 282 /* SyntaxKind.ExportSpecifier */)
+            exportSymbol = getTargetOfExportSpecifier(c, parent, aliasMeaning, false);
+        const visited = new Set();
+        while (exportSymbol !== undefined && !visited.has(exportSymbol)) {
+            visited.add(exportSymbol);
+            let next = undefined;
+            for (const declaration of exportSymbol.declarations) {
+                markDeclarationVisible(c, declaration);
+                if (declaration instanceof ImportEqualsDeclaration &&
+                    declaration.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */) {
+                    const first = getFirstIdentifier(declaration.moduleReference);
+                    next = resolveName(c, declaration, getText(first), aliasMeaning, undefined, false, false);
+                }
+            }
+            exportSymbol = next;
+        }
+        return true;
+    }
+    isDeclarationVisible(node) {
+        return isDeclarationVisible(this.checker, node);
+    }
+    isEntityNameVisible(entityName, enclosingDeclaration) {
+        return isEntityNameVisible(this.checker, entityName, enclosingDeclaration, true);
+    }
+    isSymbolAccessible(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible) {
+        return isSymbolAccessible(this.checker, symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible);
+    }
+    isNameResolvable(location, name) {
+        const meaning = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */;
+        return resolveName(this.checker, location, name, meaning, undefined, false, false) !== undefined;
+    }
+    isImportRequiredByAugmentation(node) {
+        if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return false;
+        const c = this.checker;
+        const file = getSourceFileOfNode(node);
+        if (file.symbol === undefined)
+            return false;
+        const importTarget = getExternalModuleFileFromDeclaration(c, node);
+        if (importTarget === undefined || importTarget === file)
+            return false;
+        for (const s of getExportsOfModule(c, file.symbol).values()) {
+            const merged = getMergedSymbol(c, s);
+            if (merged === s)
+                continue;
+            for (const d of merged.declarations)
+                if (getSourceFileOfNode(d) === importTarget)
+                    return true;
+        }
+        return false;
+    }
+    // Declarations
+    getEffectiveDeclarationFlags(node, flags) {
+        return getEffectiveDeclarationFlags(node, flags);
+    }
+    isImplementationOfOverload(node) {
+        if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0 || !nodeIsPresent(getBody(node)))
+            return false;
+        // Accessors have up to two signatures but never overloads.
+        if (node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */)
+            return false;
+        const c = this.checker;
+        const signatures = getSignaturesOfSymbol(c, getSymbolOfDeclaration(c, node));
+        if (signatures.length > 1)
+            return true;
+        if (signatures.length === 1) {
+            const declaration = signatures[0].declaration;
+            if (declaration !== node && declaration !== undefined && (declaration.flags & 4194304 /* NodeFlags.JSDoc */) === 0)
+                return true;
+        }
+        return false;
+    }
+    isLateBound(node) {
+        if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return false;
+        const symbol = getSymbolOfDeclaration(this.checker, node);
+        return symbol !== undefined && (symbol.checkFlags & 4096 /* CheckFlags.Late */) !== 0;
+    }
+    isDefinitelyReferenceToGlobalSymbolObject(node) {
+        if (!(node instanceof PropertyAccessExpression) || node.name.kind !== 79 /* SyntaxKind.Identifier */)
+            return false;
+        const c = this.checker;
+        const expression = node.expression;
+        if (expression.kind === 79 /* SyntaxKind.Identifier */) {
+            if (getText(expression) !== 'Symbol')
+                return false;
+            // `Symbol` doesn't resolve or is the global `Symbol`.
+            return (getResolvedSymbol(c, expression) ===
+                getGlobalSymbol(c, 'Symbol', 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */, undefined));
+        }
+        if (!(expression instanceof PropertyAccessExpression))
+            return false;
+        const inner = expression.expression;
+        if (inner.kind !== 79 /* SyntaxKind.Identifier */ ||
+            getText(inner) !== 'globalThis' ||
+            getText(expression.name) !== 'Symbol')
+            return false;
+        return getResolvedSymbol(c, inner) === c.globalThisSymbol;
+    }
+    isLiteralConstDeclaration(node) {
+        if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return false;
+        const isConstVariable = node instanceof VariableDeclaration && (getCombinedNodeFlags(node) & 7 /* NodeFlags.BlockScoped */) === 2 /* NodeFlags.Const */;
+        if (!isDeclarationReadonly(node) && !isConstVariable)
+            return false;
+        const c = this.checker;
+        const symbol = getSymbolOfDeclaration(c, node);
+        return symbol !== undefined && isFreshLiteralType(getTypeOfSymbol(c, symbol));
+    }
+    isOptionalParameter(node) {
+        return isOptionalParameter(this.checker, node);
+    }
+    requiresAddingImplicitUndefined(node, enclosingDeclaration) {
+        return requiresAddingImplicitUndefinedForDeclaration(this.checker, node, undefined, enclosingDeclaration);
+    }
+    isExpandoFunctionDeclaration(node) {
+        if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return false;
+        for (const p of this.getPropertiesOfContainerFunction(node))
+            if (p.valueDeclaration !== undefined && p.valueDeclaration.kind === 227 /* SyntaxKind.BinaryExpression */)
+                return true;
+        return false;
+    }
+    getExpandoPropertyDeclarations(node) {
+        const result = [];
+        for (const p of this.getPropertiesOfContainerFunction(node))
+            if (p.valueDeclaration !== undefined && p.valueDeclaration.kind === 227 /* SyntaxKind.BinaryExpression */)
+                result.push(p.valueDeclaration);
+        return result;
+    }
+    getPropertiesOfContainerFunction(node) {
+        const c = this.checker;
+        const symbol = getSymbolOfDeclaration(c, node);
+        if (symbol === undefined)
+            return [];
+        return getPropertiesOfType(c, getTypeOfSymbol(c, symbol));
+    }
+    getResolutionModeOverride(node) {
+        return this.syntactic.getResolutionModeOverride(node);
+    }
+    getSourceFileFromReference(file, reference) {
+        return this.syntactic.getSourceFileFromReference(file, reference);
+    }
+    // JavaScript
+    getReferencedMemberValueDeclaration(node) {
+        return this.syntactic.getReferencedMemberValueDeclaration(node);
+    }
+    isThisPropertyAssignmentDeclarationRedundant(node) {
+        const c = this.checker;
+        const s = getSymbolOfDeclaration(c, node);
+        if (s === undefined || s.parent === undefined)
+            return false;
+        const parentType = getDeclaredTypeOfSymbol(c, s.parent);
+        for (const base of getBaseTypes(c, parentType)) {
+            const baseProp = getPropertyOfType(c, base, s.name);
+            if (baseProp === undefined)
+                continue;
+            if ((baseProp.flags & (98304 /* SymbolFlags.Accessor */ | 8192 /* SymbolFlags.Method */ | 16 /* SymbolFlags.Function */)) !== 0)
+                return true;
+            if (isReadonlySymbol(c, baseProp) === isReadonlySymbol(c, s) &&
+                (s.flags & 16777216 /* SymbolFlags.Optional */) === (baseProp.flags & 16777216 /* SymbolFlags.Optional */) &&
+                isTypeIdenticalTo(c, getTypeOfSymbol(c, s), getTypeOfSymbol(c, baseProp)))
+                return true;
+        }
+        return false;
+    }
+    getElementAccessExpressionName(node) {
+        if (!(node instanceof ElementAccessExpression) || (node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return '';
+        const argument = node.argumentExpression;
+        if (isStringOrNumericLiteralLike(argument))
+            return getText(argument);
+        if (isEntityNameExpression(argument, false))
+            return tryGetNameFromEntityNameExpression(this.checker, argument) ?? '';
+        return '';
+    }
+    // Type nodes
+    builder(context, enclosingDeclaration, flags, tracker) {
+        const b = new NodeBuilder(this.checker, enclosingDeclaration, flags, declarationEmitInternalFlags, tracker, context);
+        b.pseudo = newPseudoChecker(this.checker);
+        b.declarationOrder = true;
+        return b;
+    }
+    createTypeOfDeclaration(context, declaration, enclosingDeclaration, flags, tracker) {
+        const original = context.parseNode(declaration);
+        if (original === undefined)
+            return undefined;
+        const b = this.builder(context, enclosingDeclaration, flags | 1024 /* NodeBuilderFlags.MultilineObjectLiterals */, tracker);
+        const symbol = getSymbolOfDeclaration(this.checker, declaration);
+        return b.finish(b.serializeTypeForDeclaration(declaration, undefined, symbol, true));
+    }
+    createReturnTypeOfSignatureDeclaration(context, signature, enclosingDeclaration, flags, tracker) {
+        const original = context.parseNode(signature);
+        if (original === undefined)
+            return undefined;
+        const b = this.builder(context, enclosingDeclaration, flags, tracker);
+        const sig = getSignatureFromDeclaration(this.checker, original);
+        const cleanup = b.enterSignatureScope(sig);
+        const result = b.serializeReturnTypeForSignatureEx(sig, true);
+        cleanup();
+        return b.finish(result);
+    }
+    createTypeParametersOfSignatureDeclaration(context, signature, enclosingDeclaration, flags, tracker) {
+        const original = context.parseNode(signature);
+        if (original === undefined)
+            return undefined;
+        const symbol = getSymbolOfDeclaration(this.checker, original);
+        if (symbol === undefined)
+            return undefined;
+        const b = this.builder(context, enclosingDeclaration, flags, tracker);
+        const result = b.finish(b.typeParametersToTypeParameterDeclarations(symbol));
+        return result !== undefined && result.length > 0 ? result : undefined;
+    }
+    createLiteralConstValue(context, nodeIn, tracker) {
+        const c = this.checker;
+        const node = context.parseNode(nodeIn) ?? nodeIn;
+        const symbol = getSymbolOfDeclaration(c, node);
+        if (symbol === undefined)
+            return undefined;
+        const t = getTypeOfSymbol(c, symbol);
+        const factory = context.factory;
+        if ((t.flags & 98304 /* TypeFlags.EnumLike */) !== 0 && t.symbol !== undefined) {
+            const b = this.builder(context, node, 0 /* NodeBuilderFlags.None */, tracker);
+            return b.finish(symbolToExpression(b, t.symbol, 111551 /* SymbolFlags.Value */));
+        }
+        if (t === c.trueType)
+            return factory.createKeywordExpression(111 /* SyntaxKind.TrueKeyword */);
+        if (t === c.falseType)
+            return factory.createKeywordExpression(96 /* SyntaxKind.FalseKeyword */);
+        if ((t.flags & 15360 /* TypeFlags.Literal */) === 0)
+            return undefined;
+        return literalValueToExpression(context, t);
+    }
+    createTypeOfExpression(context, expression, enclosingDeclaration, flags, tracker) {
+        const original = context.parseNode(expression);
+        if (original === undefined)
+            return undefined;
+        const b = this.builder(context, enclosingDeclaration, flags | 1024 /* NodeBuilderFlags.MultilineObjectLiterals */, tracker);
+        return b.finish(b.typeToTypeNode(getWidenedType(this.checker, getRegularTypeOfExpression(this.checker, original))));
+    }
+    createLateBoundIndexSignatures(context, containerIn, enclosingDeclaration, flags, tracker) {
+        const c = this.checker;
+        const container = context.parseNode(containerIn) ?? containerIn;
+        // The declaration's own symbol: members merged in from other files aren't written here.
+        const sym = getSymbol(container);
+        if (sym === undefined)
+            return [];
+        const staticInfos = getIndexInfosOfType(c, getTypeOfSymbol(c, sym));
+        const instanceIndexSymbol = getIndexSymbol(c, sym);
+        let instanceInfos = [];
+        if (instanceIndexSymbol !== undefined) {
+            const siblingSymbols = [...getMembersOfSymbol(c, sym).values()];
+            instanceInfos = getIndexInfosOfIndexSymbol(c, instanceIndexSymbol, siblingSymbols);
+        }
+        const factory = context.factory;
+        const result = [];
+        const lists = [staticInfos, instanceInfos];
+        for (let i = 0; i < lists.length; i++) {
+            const isStatic = i === 0;
+            for (const info of lists[i]) {
+                if (info.declaration !== undefined)
+                    continue;
+                // Inherited, but looks late-bound as it has no declarations.
+                if (info === c.anyBaseTypeIndexInfo)
+                    continue;
+                if (info.components.length > 0) {
+                    if (areComponentsSerializable(c, info.components, enclosingDeclaration)) {
+                        for (const component of info.components) {
+                            // Late-bound members of the index signature are kept as members.
+                            if (hasLateBindableName(c, component))
+                                continue;
+                            const name = getName(component);
+                            const first = getFirstIdentifier(getExpression(name));
+                            const resolved = resolveName(c, first, getText(first), 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */, undefined, true, false);
+                            if (resolved !== undefined)
+                                tracker.trackSymbol(resolved, enclosingDeclaration, 111551 /* SymbolFlags.Value */);
+                            const modifiers = [];
+                            if (isStatic)
+                                modifiers.push(factory.createToken(125 /* SyntaxKind.StaticKeyword */));
+                            if (info.isReadonly)
+                                modifiers.push(factory.createToken(148 /* SyntaxKind.ReadonlyKeyword */));
+                            const componentSymbol = getSymbolOfDeclaration(c, component);
+                            const b = this.builder(context, enclosingDeclaration, flags, tracker);
+                            const typeNode = componentSymbol === undefined
+                                ? undefined
+                                : b.finish(b.typeToTypeNode(getTypeOfSymbol(c, componentSymbol)));
+                            result.push(factory.created(new PropertyDeclaration(modifiers.length > 0 ? factory.createModifierList(modifiers) : undefined, name, getQuestionTokenOf(component), typeNode, undefined)));
+                        }
+                        continue;
+                    }
+                }
+                const b = this.builder(context, enclosingDeclaration, flags, tracker);
+                let node = b.finish(b.indexInfoToIndexSignatureDeclaration(info, undefined));
+                if (node !== undefined && isStatic)
+                    node = addStaticModifier(context, node);
+                if (node !== undefined)
+                    result.push(node);
+            }
+        }
+        return result;
+    }
+    tryJSTypeNodeToTypeNode(context, typeNode, enclosingDeclaration, flags, tracker) {
+        const original = context.parseNode(typeNode) ?? typeNode;
+        const b = this.builder(context, enclosingDeclaration, flags, tracker);
+        return b.finish(tryReuseExistingNode(b, original));
+    }
+}
+/** Visits every node, marking the declarations exports name visible. */
+/** JavaScript emit's resolver, with decorator metadata's type references serialized from the checker's types. */
+export class CheckerEmitResolver extends SyntacticEmitResolver {
+    checker;
+    constructor(options, referenceResolver, checker) {
+        super(options, referenceResolver);
+        this.checker = checker;
+    }
+    getTypeReferenceSerializationKind(typeName, location) {
+        return getTypeReferenceSerializationKind(this.checker, typeName, location);
+    }
+}
+/**
+ * How decorator metadata serializes a reference to `typeName` from `location`, as tsgo's
+ * `GetTypeReferenceSerializationKind`: the name of a class or another value with construct
+ * signatures that is reachable at runtime, else the kind of the declared type it names.
+ */
+export function getTypeReferenceSerializationKind(c, typeName, location) {
+    if (location === undefined)
+        return 0 /* TypeReferenceSerializationKind.Unknown */;
+    // The value must be reachable at runtime.
+    let isTypeOnly = false;
+    if (typeName.kind === 167 /* SyntaxKind.QualifiedName */) {
+        const root = resolveEntityName(c, getFirstIdentifier(typeName), 111551 /* SymbolFlags.Value */, true, true, location);
+        if (root !== undefined && root.declarations.length > 0)
+            isTypeOnly = root.declarations.every(isTypeOnlyImportOrExportDeclaration);
+    }
+    const valueSymbol = resolveEntityName(c, typeName, 111551 /* SymbolFlags.Value */, true, true, location);
+    let resolvedValue = valueSymbol;
+    if (valueSymbol !== undefined && (valueSymbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+        resolvedValue = resolveAlias(c, valueSymbol);
+    if (valueSymbol !== undefined &&
+        getTypeOnlyAliasDeclarationOfMeaning(c, valueSymbol, 111551 /* SymbolFlags.Value */) !== undefined)
+        isTypeOnly = true;
+    // The type gives a more specific constructor, and tells whether the value is reachable when it doesn't resolve.
+    const typeSymbol = resolveEntityName(c, typeName, 788968 /* SymbolFlags.Type */, true, true, location);
+    let resolvedType = typeSymbol;
+    if (typeSymbol !== undefined && (typeSymbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+        resolvedType = resolveAlias(c, typeSymbol);
+    if (typeSymbol !== undefined && getTypeOnlyAliasDeclarationOfMeaning(c, typeSymbol, 788968 /* SymbolFlags.Type */) !== undefined)
+        isTypeOnly = true;
+    if (resolvedValue !== undefined && resolvedValue === resolvedType) {
+        const promise = getGlobalValueSymbol(c, 'Promise', false);
+        if (promise !== undefined && resolvedValue === promise)
+            return 9 /* TypeReferenceSerializationKind.Promise */;
+        if (isConstructorType(c, getTypeOfSymbol(c, resolvedValue)))
+            return isTypeOnly
+                ? 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */
+                : 1 /* TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue */;
+    }
+    if (resolvedType === undefined)
+        return isTypeOnly ? 11 /* TypeReferenceSerializationKind.ObjectType */ : 0 /* TypeReferenceSerializationKind.Unknown */;
+    const t = getDeclaredTypeOfSymbol(c, resolvedType);
+    if (isErrorType(c, t))
+        return isTypeOnly ? 11 /* TypeReferenceSerializationKind.ObjectType */ : 0 /* TypeReferenceSerializationKind.Unknown */;
+    if ((t.flags & 3 /* TypeFlags.AnyOrUnknown */) !== 0)
+        return 11 /* TypeReferenceSerializationKind.ObjectType */;
+    if (isTypeAssignableToKind(c, t, 16 /* TypeFlags.Void */ | 12 /* TypeFlags.Nullable */ | 262144 /* TypeFlags.Never */))
+        return 2 /* TypeReferenceSerializationKind.VoidNullableOrNeverType */;
+    if (isTypeAssignableToKind(c, t, 8448 /* TypeFlags.BooleanLike */))
+        return 6 /* TypeReferenceSerializationKind.BooleanType */;
+    if (isTypeAssignableToKind(c, t, 67648 /* TypeFlags.NumberLike */))
+        return 3 /* TypeReferenceSerializationKind.NumberLikeType */;
+    if (isTypeAssignableToKind(c, t, 4224 /* TypeFlags.BigIntLike */))
+        return 4 /* TypeReferenceSerializationKind.BigIntLikeType */;
+    if (isTypeAssignableToKind(c, t, 12583968 /* TypeFlags.StringLike */))
+        return 5 /* TypeReferenceSerializationKind.StringLikeType */;
+    if (isTupleType(t))
+        return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
+    if (isTypeAssignableToKind(c, t, 16896 /* TypeFlags.ESSymbolLike */))
+        return 8 /* TypeReferenceSerializationKind.ESSymbolType */;
+    if (isFunctionType(c, t))
+        return 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */;
+    if (isArrayType(c, t))
+        return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
+    return 11 /* TypeReferenceSerializationKind.ObjectType */;
+}
+function isFunctionType(c, t) {
+    return (t.flags & 1048576 /* TypeFlags.Object */) !== 0 && getSignaturesOfType(c, t, 0 /* SignatureKind.Call */).length > 0;
+}
+class AliasMarker extends NodeVisitor {
+    resolver;
+    constructor(resolver) {
+        super();
+        this.resolver = resolver;
+    }
+    visitNode(node) {
+        if (node instanceof BinaryExpression) {
+            if (isCommonJSModuleExports(node) && node.right.kind === 79 /* SyntaxKind.Identifier */)
+                this.resolver.markLinkedAliases(node.right);
+        }
+        else if (node instanceof ExportAssignment) {
+            if (node.expression.kind === 79 /* SyntaxKind.Identifier */)
+                this.resolver.markLinkedAliases(node.expression);
+        }
+        else if (node instanceof ExportSpecifier)
+            this.resolver.markLinkedAliases(node.propertyName ?? node.name);
+        return node.forEachChild(this);
+    }
+}
+/** `module.exports = x` or `exports.y = x` at the top of a CommonJS module. */
+function isCommonJSModuleExports(node) {
+    if (!(node instanceof BinaryExpression))
+        return false;
+    const statement = node.parent;
+    if (!(statement instanceof ExpressionStatement))
+        return false;
+    const file = statement.parent;
+    if (!(file instanceof SourceFile) || file.commonJSModuleIndicator === undefined)
+        return false;
+    const kind = getAssignmentDeclarationKind(node);
+    return kind === 1 /* JSDeclarationKind.ModuleExports */ || kind === 2 /* JSDeclarationKind.ExportsProperty */;
+}
+function isDeclarationReadonly(node) {
+    return ((getCombinedModifierFlags(node) & 8 /* ModifierFlags.Readonly */) !== 0 &&
+        !(node.parent !== undefined && isParameterPropertyDeclaration(node, node.parent)));
+}
+function isEntityNameExpressionNode(node) {
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return true;
+    return (node instanceof PropertyAccessExpression &&
+        node.name.kind === 79 /* SyntaxKind.Identifier */ &&
+        isEntityNameExpressionNode(node.expression));
+}
+function areComponentsSerializable(c, components, enclosingDeclaration) {
+    for (const component of components) {
+        const name = getName(component);
+        if (name === undefined ||
+            name.kind !== 168 /* SyntaxKind.ComputedPropertyName */ ||
+            !isEntityNameExpressionNode(getExpression(name)) ||
+            isEntityNameVisible(c, getExpression(name), enclosingDeclaration, false).accessibility !==
+                0 /* SymbolAccessibility.Accessible */)
+            return false;
+    }
+    return true;
+}
+function getQuestionTokenOf(node) {
+    const token = getQuestionToken(node) ?? getPostfixToken(node);
+    return token instanceof Token && token.kind === 57 /* SyntaxKind.QuestionToken */ ? token : undefined;
+}
+/** The initializer for a literal type's value: a string, number or bigint literal. */
+function literalValueToExpression(context, t) {
+    const factory = context.factory;
+    if ((t.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+        return factory.createStringLiteral(t.stringValue, 0 /* TokenFlags.None */);
+    if ((t.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0) {
+        const value = t.numberValue;
+        if (value === Infinity)
+            return factory.createIdentifier('Infinity');
+        if (value === -Infinity)
+            return factory.created(new PrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, factory.createIdentifier('Infinity')));
+        if (Number.isNaN(value))
+            return factory.createIdentifier('NaN');
+        if (value < 0)
+            return factory.created(new PrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, factory.createNumericLiteral(String(-value))));
+        return factory.createNumericLiteral(String(value));
+    }
+    if ((t.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
+        return factory.created(new BigIntLiteral(t.stringValue + 'n', 0 /* TokenFlags.None */));
+    return undefined;
+}
+function addStaticModifier(context, node) {
+    if (!(node instanceof IndexSignatureDeclaration))
+        return node;
+    const factory = context.factory;
+    const modifiers = [factory.createToken(125 /* SyntaxKind.StaticKeyword */)];
+    if (node.modifiers !== undefined)
+        for (const m of node.modifiers.nodes)
+            modifiers.push(m);
+    return factory.created(new IndexSignatureDeclaration(factory.createModifierList(modifiers), node.parameters, node.type));
+}

package/dist/api/compiler/checker-evaluator.d.ts

@@ -0,0 +1,27 @@
+import { type Node } from './ast.js';
+import type { Checker } from './checker.js';
+export declare const enum EvaluatedKind {
+    None = 0,
+    Number = 1,
+    String = 2
+}
+/** How a value was evaluated, for the isolatedModules checks of enum members. */
+export declare const enum EvaluatedFlags {
+    None = 0,
+    /** Written as a string: a string literal, a template, or `+` with one. */
+    SyntacticallyString = 1,
+    /** Read from a declaration in another file. */
+    ResolvedOtherFiles = 2
+}
+export declare class EvaluatorResult {
+    kind: EvaluatedKind;
+    numberValue: number;
+    stringValue: string;
+    flags: EvaluatedFlags;
+    static number(value: number): EvaluatorResult;
+    static string(value: string): EvaluatorResult;
+}
+/** The constant value of an enum member initializer, if it has one. */
+export declare function evaluateEnumMember(c: Checker, expr: Node, member: Node): EvaluatorResult;
+/** The constant value of `expr`, evaluated at `location`. */
+export declare function evaluate(c: Checker, expr: Node, location: Node): EvaluatorResult;