tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/node-builder-names.js

@@ -0,0 +1,854 @@
+// Naming symbols in built nodes: the chain of symbols reaching a symbol from the enclosing
+// declaration, written as an entity name, `import("…")` type, indexed access or expression.
+import { ComputedPropertyName, ElementAccessExpression, ExpressionWithTypeArguments, ImportAttribute, ImportAttributes, ImportTypeNode, IndexedAccessTypeNode, LiteralTypeNode, ParenthesizedTypeNode, PrefixUnaryExpression, PropertyAccessExpression, QualifiedName, SourceFile, StringLiteral, TypeQueryNode, TypeReferenceNode, getArguments, getExpression, getInitializer, getModuleSpecifier, getName, getSymbol, getText, } from './ast.js';
+import { declarationNameToString, getDeclarationOfKind, getNameOfDeclaration, getSourceFileOfNode, isModuleAugmentationExternal, } from './binder-utilities.js';
+import { getExternalModuleName, isAmbientModule, isGlobalScopeAugmentation, isRequireCall } from './ast-utilities.js';
+import { getSymbolAtLocation } from './checker-services.js';
+import { checkExpression } from './checker-expressions.js';
+import { getExportsOfSymbol, getMembersOfSymbol, isAmbientModuleSymbolName, resolveAlias } from './checker-symbols.js';
+import { compareSymbols } from './checker-type-factory.js';
+import { isLateBoundName } from './checker-utilities.js';
+import { isExternalModuleNameRelative, pathIsRelative } from './path.js';
+import { ModuleSpecifierHost, ModuleSpecifierPreferences, countPathComponents, getModuleSpecifiersForFile, } from './module-specifiers.js';
+import { ModuleKind, ModuleResolutionKind, getModuleResolutionKind } from './options.js';
+import { isExternalModuleAugmentation } from './transformers/declarations-syntactic.js';
+import { isIdentifierText } from './scanner.js';
+import { getAccessibleSymbolChain, getAliasForSymbolInContainer, getContainersOfSymbol, getFileSymbolIfFileSymbolExportEqualsContainer, getQualifiedLeftMeaning, getSymbolIfSameReference, hasNonGlobalAugmentationExternalModuleDeclaration, needsQualification, } from './symbol-accessibility.js';
+import { classifyPropertyName, isNumericLiteralName } from './node-builder.js';
+import { declarationCount, escapeInternalSymbolName, getDeclarations, getSymbolId, } from './symbol.js';
+// ---- Symbol chains
+/** The chain of symbols naming `symbol`, reported to the tracker. */
+export function lookupSymbolChain(b, symbol, meaning, yieldModuleSymbol) {
+    b.trackSymbol(symbol, b.enclosingDeclaration, meaning);
+    // Qualified only with somewhere to qualify from, and never for type parameters.
+    if ((symbol.flags & 262144 /* SymbolFlags.TypeParameter */) === 0 &&
+        (b.enclosingDeclaration !== undefined || (b.flags & 64 /* NodeBuilderFlags.UseFullyQualifiedType */) !== 0) &&
+        (b.internalFlags & 4 /* NodeBuilderInternalFlags.DoNotIncludeSymbolChain */) === 0)
+        return getSymbolChain(b, symbol, meaning, true, yieldModuleSymbol);
+    return [symbol];
+}
+/** `endOfChain` is false for parents, which may be omitted. */
+function getSymbolChain(b, symbol, meaning, endOfChain, yieldModuleSymbol) {
+    const c = b.c;
+    let chain = getAccessibleSymbolChain(c, symbol, b.enclosingDeclaration, meaning, (b.flags & 128 /* NodeBuilderFlags.UseOnlyExternalAliasing */) !== 0);
+    const qualifierMeaning = chain.length > 1 ? getQualifiedLeftMeaning(meaning) : meaning;
+    if (chain.length === 0 || needsQualification(c, chain[0], b.enclosingDeclaration, qualifierMeaning)) {
+        // Go up and add the parent.
+        const root = chain.length > 0 ? chain[0] : symbol;
+        const parents = getContainersOfSymbol(c, root, b.enclosingDeclaration, meaning);
+        if (parents.length > 0) {
+            const specifiers = [];
+            const order = [];
+            for (const p of parents) {
+                order.push(specifiers.length);
+                specifiers.push(hasNonGlobalAugmentationExternalModuleDeclaration(p)
+                    ? getSpecifierForModuleSymbol(b, p, ModuleKind.None)
+                    : '');
+            }
+            order.sort((x, y) => compareByBestName(b, parents[x], specifiers[x], parents[y], specifiers[y]) || x - y);
+            for (const index of order) {
+                const parent = parents[index];
+                const parentChain = getSymbolChain(b, parent, getQualifiedLeftMeaning(meaning), false, yieldModuleSymbol);
+                if (parentChain === undefined || parentChain.length === 0)
+                    continue;
+                const exportEquals = parent.exports?.get("export=" /* InternalSymbolName.ExportEquals */);
+                if (exportEquals !== undefined && getSymbolIfSameReference(c, exportEquals, symbol) !== undefined) {
+                    // The parent's `export =` is the symbol itself: no alias to look up.
+                    chain = parentChain;
+                    break;
+                }
+                const next = chain.length > 0 ? chain : [getAliasForSymbolInContainer(c, parent, symbol) ?? symbol];
+                chain = parentChain.concat(next);
+                break;
+            }
+        }
+    }
+    if (chain.length > 0)
+        return chain;
+    // The end of a chain is always written; an anonymous type parent never is.
+    if (endOfChain || (symbol.flags & (2048 /* SymbolFlags.TypeLiteral */ | 4096 /* SymbolFlags.ObjectLiteral */)) === 0) {
+        // An external module parent isn't written: `x` rather than `"foo/bar".x`.
+        if (!endOfChain && !yieldModuleSymbol && hasNonGlobalAugmentationExternalModuleDeclaration(symbol))
+            return undefined;
+        return [symbol];
+    }
+    return undefined;
+}
+function compareByBestName(b, a, specifierA, other, specifierB) {
+    if (specifierA.length > 0 && specifierB.length > 0) {
+        const isBRelative = pathIsRelative(specifierB);
+        if (pathIsRelative(specifierA) === isBRelative)
+            return countPathComponents(specifierA) - countPathComponents(specifierB);
+        return isBRelative ? -1 : 1;
+    }
+    return compareSymbols(b.c, a, other);
+}
+// ---- Type nodes
+/** A type node naming `symbol` with `mask`: a type reference, `typeof`, indexed access or `import("…")`. */
+export function symbolToTypeNode(b, symbol, mask, typeArguments) {
+    // Outside the current scope, the module isn't needed.
+    const chain = lookupSymbolChain(b, symbol, mask, (b.flags & 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */) === 0);
+    if (chain.length === 0)
+        return undefined;
+    const isTypeOf = mask === 111551 /* SymbolFlags.Value */;
+    if (hasNonGlobalAugmentationExternalModuleDeclaration(chain[0])) {
+        // A module root needs an `import` type.
+        const nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(b, chain, chain.length - 1, 1, typeArguments) : undefined;
+        const typeParameterNodes = typeArguments ?? lookupTypeParameterNodes(b, chain, 0);
+        let specifier = '';
+        let attributes = undefined;
+        const c = b.c;
+        const resolution = getModuleResolutionKind(c.compilerOptions);
+        const nodeNext = resolution === ModuleResolutionKind.Node16 || resolution === ModuleResolutionKind.NodeNext;
+        const contextFile = b.enclosingDeclaration === undefined
+            ? undefined
+            : getSourceFileOfNode(b.context.mostOriginal(b.enclosingDeclaration));
+        if (nodeNext) {
+            // An `import` type of an ES module from a file of another format resolves only in ESM mode.
+            const targetFile = getSourceFileOfModule(chain[0]);
+            if (targetFile !== undefined && contextFile !== undefined) {
+                const targetFormat = c.host.getEmitModuleFormatOfFile(targetFile);
+                if (targetFormat === ModuleKind.ESNext && targetFormat !== c.host.getEmitModuleFormatOfFile(contextFile)) {
+                    specifier = getSpecifierForModuleSymbol(b, chain[0], ModuleKind.ESNext);
+                    attributes = resolutionModeAttributes(b, 'import');
+                }
+            }
+        }
+        if (specifier === '')
+            specifier = getSpecifierForModuleSymbol(b, chain[0], ModuleKind.None);
+        if ((b.flags & 67108864 /* NodeBuilderFlags.AllowNodeModulesRelativePaths */) === 0 && specifier.includes('/node_modules/')) {
+            const oldSpecifier = specifier;
+            if (nodeNext && contextFile !== undefined) {
+                // The other mode may reach the module portably.
+                const swappedMode = c.host.getEmitModuleFormatOfFile(contextFile) === ModuleKind.ESNext ? ModuleKind.CommonJS : ModuleKind.ESNext;
+                specifier = getSpecifierForModuleSymbol(b, chain[0], swappedMode);
+                if (specifier.includes('/node_modules/'))
+                    specifier = oldSpecifier;
+                else
+                    attributes = resolutionModeAttributes(b, swappedMode === ModuleKind.ESNext ? 'import' : 'require');
+            }
+            if (attributes === undefined) {
+                // A reference into `node_modules` is likely to break when published.
+                b.encounteredError = true;
+                b.tracker.reportLikelyUnsafeImportRequiredError(oldSpecifier, symbol.name);
+            }
+        }
+        const literal = b.created(new LiteralTypeNode(b.stringLiteral(specifier, false)));
+        b.approximateLength += specifier.length + 10;
+        if (nonRootParts === undefined || isEntityName(nonRootParts))
+            return b.created(new ImportTypeNode(isTypeOf, literal, attributes, nonRootParts, typeParameterNodes));
+        const splitNode = getTopmostIndexedAccessType(nonRootParts);
+        const qualifier = splitNode.objectType.typeName;
+        return b.created(new IndexedAccessTypeNode(b.created(new ImportTypeNode(isTypeOf, literal, attributes, qualifier, typeParameterNodes)), splitNode.indexType));
+    }
+    const entityName = createAccessFromSymbolChain(b, chain, chain.length - 1, 0, typeArguments);
+    // Indexed accesses can't be `typeof`.
+    if (entityName instanceof IndexedAccessTypeNode)
+        return entityName;
+    if (isEntityName(entityName))
+        return isTypeOf
+            ? b.created(new TypeQueryNode(entityName, undefined))
+            : b.created(new TypeReferenceNode(entityName, typeArguments));
+    if (isTypeOf && entityName instanceof ExpressionWithTypeArguments)
+        return b.created(new TypeQueryNode(entityName.expression.deepClone(), entityName.typeArguments));
+    return entityName;
+}
+function isEntityName(node) {
+    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 167 /* SyntaxKind.QualifiedName */;
+}
+/** `with { "resolution-mode": "import" }` or `"require"`. */
+function resolutionModeAttributes(b, mode) {
+    const attribute = b.created(new ImportAttribute(b.stringLiteral('resolution-mode', false), b.stringLiteral(mode, false)));
+    return b.created(new ImportAttributes(117 /* SyntaxKind.WithKeyword */, b.list([attribute]), false));
+}
+function getTopmostIndexedAccessType(node) {
+    const objectType = node.objectType;
+    return objectType instanceof IndexedAccessTypeNode ? getTopmostIndexedAccessType(objectType) : node;
+}
+function createAccessFromSymbolChain(b, chain, index, stopper, overrideTypeArguments) {
+    const c = b.c;
+    const typeParameterNodes = index !== chain.length - 1 ? lookupTypeParameterNodes(b, chain, index) : overrideTypeArguments;
+    const symbol = chain[index];
+    const parent = index > 0 ? chain[index - 1] : undefined;
+    let symbolName = '';
+    if (index === 0) {
+        b.flags |= 16777216 /* NodeBuilderFlags.InInitialEntityName */;
+        symbolName = getNameOfSymbolAsWritten(b, symbol);
+        b.approximateLength += symbolName.length + 1;
+        b.flags ^= 16777216 /* NodeBuilderFlags.InInitialEntityName */;
+    }
+    else if (parent !== undefined) {
+        // A reference to the symbol within its parent, for export aliases.
+        const exports = getExportsOfSymbol(c, parent);
+        const direct = exports.get(symbol.name);
+        if (symbol.name !== "export=" /* InternalSymbolName.ExportEquals */ &&
+            !isLateBoundName(symbol.name) &&
+            direct !== undefined &&
+            getSymbolIfSameReference(c, direct, symbol) !== undefined)
+            symbolName = symbol.name;
+        else {
+            const candidates = [];
+            const names = [];
+            for (const [name, exported] of exports)
+                if (getSymbolIfSameReference(c, exported, symbol) !== undefined &&
+                    !isLateBoundName(name) &&
+                    name !== "export=" /* InternalSymbolName.ExportEquals */) {
+                    candidates.push(exported);
+                    names.push(name);
+                }
+            if (candidates.length > 0) {
+                let best = 0;
+                for (let i = 1; i < candidates.length; i++)
+                    if (compareSymbols(c, candidates[i], candidates[best]) < 0)
+                        best = i;
+                symbolName = names[best];
+            }
+        }
+    }
+    if (symbolName.length === 0) {
+        let name = undefined;
+        for (const d of getDeclarations(symbol)) {
+            name = getNameOfDeclaration(d);
+            if (name !== undefined)
+                break;
+        }
+        if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && isEntityName(getExpression(name))) {
+            const lhs = createAccessFromSymbolChain(b, chain, index - 1, stopper, overrideTypeArguments);
+            if (isEntityName(lhs))
+                return b.created(new IndexedAccessTypeNode(b.created(new ParenthesizedTypeNode(b.created(new TypeQueryNode(lhs, undefined)))), b.created(new TypeQueryNode(getExpression(name), undefined))));
+            return lhs;
+        }
+        symbolName = getNameOfSymbolAsWritten(b, symbol);
+    }
+    b.approximateLength += symbolName.length + 1;
+    if ((b.flags & 16 /* NodeBuilderFlags.ForbidIndexedAccessSymbolReferences */) === 0 && parent !== undefined) {
+        const member = getMembersOfSymbol(c, parent).get(symbol.name);
+        if (member !== undefined && getSymbolIfSameReference(c, member, symbol) !== undefined) {
+            // An indexed access.
+            const lhs = createAccessFromSymbolChain(b, chain, index - 1, stopper, overrideTypeArguments);
+            const literal = b.created(new LiteralTypeNode(b.stringLiteral(symbolName, false)));
+            if (lhs instanceof IndexedAccessTypeNode)
+                return b.created(new IndexedAccessTypeNode(lhs, literal));
+            return b.created(new IndexedAccessTypeNode(b.created(new TypeReferenceNode(lhs, typeParameterNodes)), literal));
+        }
+    }
+    const identifier = b.identifier(symbolName);
+    b.context.addEmitFlags(identifier, 131072 /* EmitFlags.NoAsciiEscaping */);
+    if (index > stopper) {
+        const lhs = createAccessFromSymbolChain(b, chain, index - 1, stopper, overrideTypeArguments);
+        if ((b.flags & 1073741824 /* NodeBuilderFlags.UseInstantiationExpressions */) === 0 ||
+            (isEntityName(lhs) && (typeParameterNodes === undefined || typeParameterNodes.nodes.length === 0)))
+            return b.created(new QualifiedName(lhs, identifier));
+        return createExpressionWithTypeArguments(b, b.created(new PropertyAccessExpression(createAccessExpression(b, lhs), undefined, identifier, 0 /* NodeFlags.None */)), typeParameterNodes);
+    }
+    return identifier;
+}
+/** `ref`'s names appended to the reference `root`, for an outer type parameter group. */
+export function appendReferenceToType(b, root, ref) {
+    if (root instanceof ImportTypeNode)
+        return appendReferenceToImportType(b, root, ref);
+    if (root instanceof TypeReferenceNode)
+        return appendReferenceToTypeReference(b, root, ref);
+    let expr = createAccessExpression(b, root);
+    for (const id of getAccessStack(ref))
+        expr = b.created(new PropertyAccessExpression(expr, undefined, id, 0 /* NodeFlags.None */));
+    return expr;
+}
+function appendReferenceToImportType(b, root, ref) {
+    // Type arguments of the root are dropped, as tsgo does.
+    let qualifier = root.qualifier;
+    for (const id of getAccessStack(ref))
+        qualifier = qualifier === undefined ? id : b.created(new QualifiedName(qualifier, id));
+    return b.factory.updateImportTypeNode(root, root.isTypeOf, root.argument, root.attributes, qualifier, referenceTypeArguments(ref));
+}
+function appendReferenceToTypeReference(b, root, ref) {
+    if ((b.flags & 1073741824 /* NodeBuilderFlags.UseInstantiationExpressions */) !== 0 &&
+        root.typeArguments !== undefined &&
+        root.typeArguments.nodes.length !== 0) {
+        let expr = createExpressionWithTypeArguments(b, createAccessExpression(b, root.typeName), root.typeArguments);
+        for (const id of getAccessStack(ref))
+            expr = b.created(new PropertyAccessExpression(expr, undefined, id, 0 /* NodeFlags.None */));
+        return expr;
+    }
+    let typeName = root.typeName;
+    for (const id of getAccessStack(ref))
+        typeName = b.created(new QualifiedName(typeName, id));
+    return b.factory.updateTypeReferenceNode(root, typeName, referenceTypeArguments(ref));
+}
+function referenceTypeArguments(ref) {
+    return ref instanceof TypeReferenceNode ? ref.typeArguments : undefined;
+}
+function getAccessStack(ref) {
+    let state = ref.typeName;
+    const ids = [];
+    while (state instanceof QualifiedName) {
+        ids.unshift(state.right);
+        state = state.left;
+    }
+    ids.unshift(state);
+    return ids;
+}
+function createAccessExpression(b, node) {
+    if (node instanceof QualifiedName)
+        return b.created(new PropertyAccessExpression(createAccessExpression(b, node.left), undefined, node.right.deepClone(), 0 /* NodeFlags.None */));
+    return node.deepClone();
+}
+function createExpressionWithTypeArguments(b, expr, typeArguments) {
+    if (typeArguments === undefined || typeArguments.nodes.length === 0)
+        return expr;
+    return b.created(new ExpressionWithTypeArguments(expr, typeArguments));
+}
+// ---- Entity names and expressions
+/** An entity name for `symbol`; with `expectsIdentifier`, a qualified name is an error unless allowed. */
+export function symbolToName(b, symbol, meaning, expectsIdentifier) {
+    const chain = lookupSymbolChain(b, symbol, meaning, false);
+    if (expectsIdentifier &&
+        chain.length !== 1 &&
+        !b.encounteredError &&
+        (b.flags & 65536 /* NodeBuilderFlags.AllowQualifiedNameInPlaceOfIdentifier */) !== 0)
+        b.encounteredError = true;
+    return createEntityNameFromSymbolChain(b, chain, chain.length - 1);
+}
+function createEntityNameFromSymbolChain(b, chain, index) {
+    const symbol = chain[index];
+    if (index === 0)
+        b.flags |= 16777216 /* NodeBuilderFlags.InInitialEntityName */;
+    const symbolName = getNameOfSymbolAsWritten(b, symbol);
+    if (index === 0)
+        b.flags ^= 16777216 /* NodeBuilderFlags.InInitialEntityName */;
+    const identifier = b.identifier(symbolName);
+    b.context.addEmitFlags(identifier, 131072 /* EmitFlags.NoAsciiEscaping */);
+    if (index > 0)
+        return b.created(new QualifiedName(createEntityNameFromSymbolChain(b, chain, index - 1), identifier));
+    return identifier;
+}
+/** The symbol's name qualified by its parents' names, without looking up a chain. */
+export function symbolToEntityNameNode(b, symbol) {
+    const identifier = b.identifier(symbol.name);
+    if (symbol.parent !== undefined)
+        return b.created(new QualifiedName(symbolToEntityNameNode(b, symbol.parent), identifier));
+    return identifier;
+}
+export function symbolToExpression(b, symbol, meaning) {
+    const chain = lookupSymbolChain(b, symbol, meaning, false);
+    return createExpressionFromSymbolChain(b, chain, chain.length - 1);
+}
+function createExpressionFromSymbolChain(b, chain, index) {
+    const typeParameterNodes = lookupExpressionChainTypeArgumentNodes(b, chain, index);
+    const symbol = chain[index];
+    if (index === 0)
+        b.flags |= 16777216 /* NodeBuilderFlags.InInitialEntityName */;
+    let symbolName = getNameOfSymbolAsWritten(b, symbol);
+    if (index === 0)
+        b.flags ^= 16777216 /* NodeBuilderFlags.InInitialEntityName */;
+    if (startsWithQuote(symbolName) && hasNonGlobalAugmentationExternalModuleDeclaration(symbol)) {
+        const specifier = getSpecifierForModuleSymbol(b, symbol, ModuleKind.None);
+        b.approximateLength += 2 + specifier.length;
+        return b.stringLiteral(specifier, false);
+    }
+    if (index === 0 || canUsePropertyAccess(symbolName)) {
+        const identifier = b.identifier(symbolName);
+        b.context.addEmitFlags(identifier, 131072 /* EmitFlags.NoAsciiEscaping */);
+        b.approximateLength += 1 + symbolName.length;
+        if (index > 0) {
+            const result = b.created(new PropertyAccessExpression(createExpressionFromSymbolChain(b, chain, index - 1), undefined, identifier, 0 /* NodeFlags.None */));
+            b.context.addEmitFlags(result, 16384 /* EmitFlags.NoIndentation */);
+            return createExpressionWithTypeArguments(b, result, typeParameterNodes);
+        }
+        return createExpressionWithTypeArguments(b, identifier, typeParameterNodes);
+    }
+    if (symbolName.startsWith('['))
+        symbolName = symbolName.substring(1, symbolName.length - 1);
+    let expression = undefined;
+    if (startsWithQuote(symbolName) && (symbol.flags & 8 /* SymbolFlags.EnumMember */) === 0) {
+        const literalText = unquote(symbolName);
+        b.approximateLength += literalText.length + 2;
+        expression = b.stringLiteral(literalText, symbolName.charCodeAt(0) === 0x27);
+    }
+    else if (String(Number(symbolName)) === symbolName) {
+        b.approximateLength += symbolName.length;
+        expression = b.factory.createNumericLiteral(symbolName);
+    }
+    if (expression === undefined) {
+        b.approximateLength += symbolName.length;
+        expression = b.identifier(symbolName);
+        b.context.addEmitFlags(expression, 131072 /* EmitFlags.NoAsciiEscaping */);
+    }
+    b.approximateLength += 2;
+    return createExpressionWithTypeArguments(b, b.created(new ElementAccessExpression(createExpressionFromSymbolChain(b, chain, index - 1), undefined, expression, 0 /* NodeFlags.None */)), typeParameterNodes);
+}
+function canUsePropertyAccess(name) {
+    if (name.length === 0)
+        return false;
+    if (name.startsWith('#'))
+        return name.length > 1 && isIdentifierText(name.substring(1));
+    return isIdentifierText(name);
+}
+function startsWithQuote(s) {
+    return s.startsWith("'") || s.startsWith('"');
+}
+function unquote(s) {
+    if (s.length >= 2 &&
+        (s.charCodeAt(0) === 0x22 || s.charCodeAt(0) === 0x27) &&
+        s.charCodeAt(s.length - 1) === s.charCodeAt(0))
+        return s.substring(1, s.length - 1);
+    return s;
+}
+// ---- Type arguments in qualified names
+function shouldWriteTypeParametersInQualifiedName(b, chain, index) {
+    return (b.flags & 512 /* NodeBuilderFlags.WriteTypeParametersInQualifiedName */) !== 0 && index < chain.length - 1;
+}
+function lookupTypeParameterNodes(b, chain, index) {
+    const symbolId = getSymbolId(chain[index]);
+    const symbolList = b.typeParameterSymbolList ?? new Set();
+    if (symbolList.has(symbolId))
+        return undefined;
+    symbolList.add(symbolId);
+    b.typeParameterSymbolList = symbolList;
+    if (shouldWriteTypeParametersInQualifiedName(b, chain, index)) {
+        const typeArgumentNodes = lookupInstantiatedTypeArgumentNodes(b, chain, index);
+        if (typeArgumentNodes !== undefined)
+            return typeArgumentNodes;
+        const typeParameterNodes = b.typeParametersToTypeParameterDeclarations(chain[index]);
+        return typeParameterNodes.length > 0 ? b.list(typeParameterNodes) : undefined;
+    }
+    return undefined;
+}
+function lookupInstantiatedTypeArgumentNodes(b, chain, index) {
+    if (!shouldWriteTypeParametersInQualifiedName(b, chain, index))
+        return undefined;
+    const symbol = chain[index];
+    const nextSymbol = chain[index + 1];
+    if ((nextSymbol.checkFlags & 1 /* CheckFlags.Instantiated */) === 0)
+        return undefined;
+    const target = (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 ? resolveAlias(b.c, symbol) : symbol;
+    let params = b.getTypeParametersOfClassOrInterface(target);
+    const mapper = b.c.symbolMappers.get(getSymbolId(nextSymbol));
+    if (mapper !== undefined) {
+        const mapped = [];
+        for (const p of params)
+            mapped.push(mapper.map(p));
+        params = mapped;
+    }
+    return b.mapToTypeNodes(params, false);
+}
+function lookupExpressionChainTypeArgumentNodes(b, chain, index) {
+    if (!shouldWriteTypeParametersInQualifiedName(b, chain, index))
+        return undefined;
+    const symbolId = getSymbolId(chain[index]);
+    const symbolList = b.typeParameterSymbolList ?? new Set();
+    if (symbolList.has(symbolId))
+        return undefined;
+    symbolList.add(symbolId);
+    b.typeParameterSymbolList = symbolList;
+    const typeArgumentNodes = lookupInstantiatedTypeArgumentNodes(b, chain, index);
+    if (typeArgumentNodes !== undefined)
+        return typeArgumentNodes;
+    const typeParameterNodes = b.typeParametersToTypeParameterDeclarations(chain[index]);
+    return typeParameterNodes.length > 0 ? b.list(typeParameterNodes) : undefined;
+}
+// ---- Names as written
+function isDefaultBindingContext(node) {
+    return node.kind === 307 /* SyntaxKind.SourceFile */ || isAmbientModule(node);
+}
+function findDefaultBindingContext(node) {
+    for (let current = node; current !== undefined; current = current.parent)
+        if (isDefaultBindingContext(current))
+            return current;
+    return undefined;
+}
+function getNameOfSymbolFromNameType(b, symbol) {
+    const nameType = b.c.symbolNameTypes.get(getSymbolId(symbol));
+    if (nameType === undefined)
+        return '';
+    if ((nameType.flags & 3072 /* TypeFlags.StringOrNumberLiteral */) !== 0) {
+        const literal = nameType;
+        const name = (nameType.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 ? literal.stringValue : String(literal.numberValue);
+        if (!isIdentifierText(name) && !isNumericLiteralName(name))
+            return (nameType.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 ? quoteString(name) : name;
+        if (isNumericLiteralName(name) && name.startsWith('-'))
+            return '[' + name + ']';
+        return name;
+    }
+    if ((nameType.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
+        return '[' + getNameOfSymbolAsWritten(b, nameType.symbol) + ']';
+    return '';
+}
+/** A JSON-style double quoted string, as tsgo's `valueToString`. */
+function quoteString(s) {
+    return JSON.stringify(s);
+}
+/**
+ * A readable name for a symbol, not for the right of a `.`: quoted if from a string literal,
+ * and a number as written (`0o11`, not `9`).
+ */
+export function getNameOfSymbolAsWritten(b, symbol) {
+    const remapped = b.remappedSymbolReferences.get(getSymbolId(symbol));
+    if (remapped !== undefined)
+        symbol = remapped;
+    if (symbol.name === "default" /* InternalSymbolName.Default */ &&
+        (b.flags & 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */) === 0 &&
+        // Not the first part of an entity name, synthesized, or from another binding context.
+        ((b.flags & 16777216 /* NodeBuilderFlags.InInitialEntityName */) === 0 ||
+            declarationCount(symbol) === 0 ||
+            (b.enclosingDeclaration !== undefined &&
+                findDefaultBindingContext(symbol.declaration) !== findDefaultBindingContext(b.enclosingDeclaration))))
+        return 'default';
+    if (declarationCount(symbol) > 0) {
+        let name = undefined;
+        for (const d of getDeclarations(symbol)) {
+            name = getNameOfDeclaration(d);
+            if (name !== undefined)
+                break;
+        }
+        if (name !== undefined) {
+            if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && (symbol.checkFlags & 4096 /* CheckFlags.Late */) === 0) {
+                const nameType = b.c.symbolNameTypes.get(getSymbolId(symbol));
+                if (nameType !== undefined && (nameType.flags & 3072 /* TypeFlags.StringOrNumberLiteral */) !== 0) {
+                    const result = getNameOfSymbolFromNameType(b, symbol);
+                    if (result.length > 0)
+                        return result;
+                }
+            }
+            return declarationNameToString(getSourceFileOfNode(name), name);
+        }
+        const declaration = symbol.declaration;
+        const parent = declaration.parent;
+        if (parent !== undefined && parent.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+            const parentName = getName(parent);
+            return declarationNameToString(getSourceFileOfNode(parentName), parentName);
+        }
+        switch (declaration.kind) {
+            case 232 /* SyntaxKind.ClassExpression */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.ArrowFunction */:
+                if (!b.encounteredError && (b.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */) === 0)
+                    b.encounteredError = true;
+                return declaration.kind === 232 /* SyntaxKind.ClassExpression */ ? '(Anonymous class)' : '(Anonymous function)';
+        }
+    }
+    const name = getNameOfSymbolFromNameType(b, symbol);
+    if (name.length > 0)
+        return name;
+    return escapeInternalSymbolName(symbol.name);
+}
+// ---- Property names
+function isStringNamed(b, d) {
+    const name = getNameOfDeclaration(d);
+    if (name === undefined)
+        return false;
+    if (name instanceof ComputedPropertyName)
+        return (checkExpression(b.c, name.expression).flags & 12583968 /* TypeFlags.StringLike */) !== 0;
+    if (name instanceof ElementAccessExpression)
+        return (checkExpression(b.c, name.argumentExpression).flags & 12583968 /* TypeFlags.StringLike */) !== 0;
+    return name.kind === 10 /* SyntaxKind.StringLiteral */;
+}
+function isSingleQuotedStringNamed(d) {
+    const name = getNameOfDeclaration(d);
+    return name instanceof StringLiteral && (name.tokenFlags & 65536 /* TokenFlags.SingleQuote */) !== 0;
+}
+/** The name node of a property. */
+export function getPropertyNameNodeForSymbol(b, symbol) {
+    // A private name is the declaration's.
+    const valueDeclaration = symbol.valueDeclaration;
+    if (valueDeclaration !== undefined) {
+        const declarationName = getName(valueDeclaration);
+        if (declarationName !== undefined && declarationName.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+            return b.cloneSynthesized(declarationName);
+    }
+    const declarations = getDeclarations(symbol);
+    let stringNamed = declarations.length !== 0;
+    for (const d of declarations)
+        if (!isStringNamed(b, d)) {
+            stringNamed = false;
+            break;
+        }
+    let singleQuote = declarations.length !== 0;
+    for (const d of declarations)
+        if (!isSingleQuotedStringNamed(d)) {
+            singleQuote = false;
+            break;
+        }
+    const isMethod = (symbol.flags & 8192 /* SymbolFlags.Method */) !== 0;
+    const fromNameType = getPropertyNameNodeForSymbolFromNameType(b, symbol, singleQuote, stringNamed, isMethod);
+    if (fromNameType !== undefined)
+        return fromNameType;
+    let name = symbol.name;
+    const privateNamePrefix = '￾#';
+    if (name.startsWith(privateNamePrefix)) {
+        // Symbol ids are unstable: `#123@#x` becomes `__#private@#x`.
+        let rest = name.substring(privateNamePrefix.length);
+        let i = 0;
+        while (i < rest.length && rest.charCodeAt(i) >= 0x30 && rest.charCodeAt(i) <= 0x39)
+            i++;
+        rest = rest.substring(i);
+        name = '__#private' + rest;
+    }
+    return createPropertyNameNodeForIdentifierOrLiteral(b, name, singleQuote, stringNamed, isMethod);
+}
+function createPropertyNameNodeForIdentifierOrLiteral(b, name, singleQuote, stringNamed, isMethod) {
+    switch (classifyPropertyName(name, stringNamed, isMethod)) {
+        case 0:
+            return b.identifier(name);
+        case 1:
+            return b.factory.createNumericLiteral(name);
+    }
+    return b.factory.createStringLiteral(name, singleQuote ? 65536 /* TokenFlags.SingleQuote */ : 0 /* TokenFlags.None */);
+}
+function getPropertyNameNodeForSymbolFromNameType(b, symbol, singleQuote, stringNamed, isMethod) {
+    const nameType = b.c.symbolNameTypes.get(getSymbolId(symbol));
+    if (nameType === undefined)
+        return undefined;
+    if ((nameType.flags & 3072 /* TypeFlags.StringOrNumberLiteral */) !== 0) {
+        const literal = nameType;
+        const name = (nameType.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 ? literal.stringValue : String(literal.numberValue);
+        if (!isIdentifierText(name) && (stringNamed || !isNumericLiteralName(name)))
+            return b.factory.createStringLiteral(name, singleQuote ? 65536 /* TokenFlags.SingleQuote */ : 0 /* TokenFlags.None */);
+        if (isNumericLiteralName(name) && name.startsWith('-'))
+            return b.created(new ComputedPropertyName(b.created(new PrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, b.factory.createNumericLiteral(name.substring(1))))));
+        return createPropertyNameNodeForIdentifierOrLiteral(b, name, singleQuote, stringNamed, isMethod);
+    }
+    if ((nameType.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
+        return b.created(new ComputedPropertyName(symbolToExpression(b, nameType.symbol, 111551 /* SymbolFlags.Value */)));
+    return undefined;
+}
+// ---- Module specifiers
+/**
+ * The specifier an `import("…")` type names a module with: an ambient module's name, the file
+ * name without an enclosing file, else what module specifier generation gives for the enclosing
+ * file. `overrideImportMode` is `None` for the mode of the enclosing import or file.
+ */
+export function getSpecifierForModuleSymbol(b, symbol, overrideImportMode) {
+    const c = b.c;
+    let file = asSourceFile(getDeclarationOfKind(symbol, 307 /* SyntaxKind.SourceFile */));
+    if (file === undefined)
+        for (const d of getDeclarations(symbol)) {
+            const equivalent = getFileSymbolIfFileSymbolExportEqualsContainer(c, d, symbol);
+            if (equivalent !== undefined) {
+                file = asSourceFile(getDeclarationOfKind(equivalent, 307 /* SyntaxKind.SourceFile */));
+                break;
+            }
+        }
+    if (file === undefined && isAmbientModuleSymbolName(symbol.name))
+        return symbol.name.substring(1, symbol.name.length - 1);
+    const contextFile = b.enclosingFile;
+    if (contextFile === undefined) {
+        if (isAmbientModuleSymbolName(symbol.name))
+            return symbol.name.substring(1, symbol.name.length - 1);
+        const moduleFile = getSourceFileOfModule(symbol);
+        return moduleFile === undefined ? '' : moduleFile.fileName;
+    }
+    const enclosingDeclaration = b.enclosingDeclaration === undefined ? undefined : b.context.mostOriginal(b.enclosingDeclaration);
+    const originalModuleSpecifier = enclosingDeclaration !== undefined && canHaveModuleSpecifier(enclosingDeclaration)
+        ? tryGetModuleSpecifierFromDeclaration(enclosingDeclaration)
+        : undefined;
+    let resolutionMode = overrideImportMode;
+    if (resolutionMode === ModuleKind.None)
+        resolutionMode =
+            originalModuleSpecifier !== undefined
+                ? c.host.getModeForUsageLocation(contextFile, originalModuleSpecifier)
+                : c.host.getDefaultResolutionModeForFile(contextFile);
+    const key = getSymbolId(symbol) + '|' + contextFile.path + '|' + resolutionMode;
+    const cached = c.moduleSpecifiers.get(key);
+    if (cached !== undefined)
+        return cached;
+    // Declaration emit prefers project-relative specifiers, with `.js` extensions in ES modules.
+    const preferences = new ModuleSpecifierPreferences('project-relative', resolutionMode === ModuleKind.ESNext ? 'js' : '');
+    const specifiers = getModuleSpecifiers(c, symbol, contextFile, preferences, overrideImportMode);
+    const specifier = specifiers.length > 0 ? specifiers[0] : '';
+    c.moduleSpecifiers.set(key, specifier);
+    return specifier;
+}
+/** Specifiers `importingFile` can import the module `moduleSymbol` with, best first. */
+export function getModuleSpecifiers(c, moduleSymbol, importingFile, preferences, overrideImportMode) {
+    const ambient = tryGetModuleNameFromAmbientModule(c, moduleSymbol);
+    if (ambient !== '')
+        return [ambient];
+    const moduleFile = getSourceFileOfModule(moduleSymbol);
+    if (moduleFile === undefined)
+        return [];
+    const host = getModuleSpecifierHost(c);
+    // A referenced project's declaration output is named by its source.
+    return getModuleSpecifiersForFile(importingFile, host.getSourceOfProjectReferenceIfOutputIncluded(moduleFile), c.compilerOptions, host, preferences, overrideImportMode, false);
+}
+function getModuleSpecifierHost(c) {
+    let host = c.host.getModuleSpecifierHost();
+    if (host === undefined) {
+        host = c.fallbackModuleSpecifierHost;
+        if (host === undefined) {
+            host = new CheckerModuleSpecifierHost(c);
+            c.fallbackModuleSpecifierHost = host;
+        }
+    }
+    return host;
+}
+/** The name of an ambient module declaring `moduleSymbol`, or of the one whose `export =` it is, else `''`. */
+function tryGetModuleNameFromAmbientModule(c, moduleSymbol) {
+    for (const d of getDeclarations(moduleSymbol)) {
+        const name = isModuleWithStringLiteralName(d) ? getName(d) : undefined;
+        if (name !== undefined && (!isModuleAugmentationExternal(d) || !isExternalModuleNameRelative(getText(name))))
+            return getText(name);
+    }
+    // A namespace exported with `export =` from an ambient module: `import { c } from "m"` names
+    // `ns.c` for `declare module "m" { namespace ns { class c {} } export = ns; }`.
+    for (const d of getDeclarations(moduleSymbol)) {
+        if (d.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
+            continue;
+        let container = d;
+        while (container !== undefined && !isModuleWithStringLiteralName(container))
+            container = container.parent;
+        if (container === undefined || container.parent === undefined || container.parent.kind !== 307 /* SyntaxKind.SourceFile */)
+            continue;
+        const exportEquals = getSymbol(container)?.exports?.get("export=" /* InternalSymbolName.ExportEquals */);
+        const assignment = exportEquals?.valueDeclaration;
+        if (assignment === undefined || assignment.kind !== 278 /* SyntaxKind.ExportAssignment */)
+            continue;
+        let exported = getSymbolAtLocation(c, getExpression(assignment));
+        if (exported === undefined)
+            continue;
+        if ((exported.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+            exported = resolveAlias(c, exported);
+        if (exported === getSymbol(d))
+            return getText(getName(container));
+    }
+    return '';
+}
+function isModuleWithStringLiteralName(node) {
+    return node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && getName(node)?.kind === 10 /* SyntaxKind.StringLiteral */;
+}
+function canHaveModuleSpecifier(node) {
+    switch (node.kind) {
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 209 /* SyntaxKind.BindingElement */:
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 279 /* SyntaxKind.ExportDeclaration */:
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 274 /* SyntaxKind.ImportClause */:
+        case 281 /* SyntaxKind.NamespaceExport */:
+        case 275 /* SyntaxKind.NamespaceImport */:
+        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 206 /* SyntaxKind.ImportType */:
+            return true;
+    }
+    return false;
+}
+/** The string literal module specifier of an import, export, `require` or `import("…")` type declaration. */
+function tryGetModuleSpecifierFromDeclaration(node) {
+    let specifier;
+    switch (node.kind) {
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 209 /* SyntaxKind.BindingElement */: {
+            let call = getInitializer(node);
+            while (call !== undefined && !isRequireCall(call, true))
+                call = call.parent;
+            specifier = call === undefined ? undefined : getArguments(call).nodes[0];
+            break;
+        }
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 279 /* SyntaxKind.ExportDeclaration */:
+            specifier = getModuleSpecifier(node);
+            break;
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            specifier = getExternalModuleName(node);
+            break;
+        case 274 /* SyntaxKind.ImportClause */:
+        case 281 /* SyntaxKind.NamespaceExport */:
+            specifier = getModuleSpecifier(node.parent);
+            break;
+        case 275 /* SyntaxKind.NamespaceImport */:
+        case 282 /* SyntaxKind.ExportSpecifier */:
+            specifier = getModuleSpecifier(node.parent.parent);
+            break;
+        case 277 /* SyntaxKind.ImportSpecifier */:
+            specifier = getModuleSpecifier(node.parent.parent.parent);
+            break;
+        case 206 /* SyntaxKind.ImportType */: {
+            const argument = node.argument;
+            specifier = argument instanceof LiteralTypeNode ? argument.literal : undefined;
+            break;
+        }
+    }
+    return specifier !== undefined && specifier.kind === 10 /* SyntaxKind.StringLiteral */ ? specifier : undefined;
+}
+/**
+ * Specifier generation without a program, as the checker of single files uses: relative paths
+ * between the checker's files.
+ */
+class CheckerModuleSpecifierHost extends ModuleSpecifierHost {
+    c;
+    constructor(c) {
+        super();
+        this.c = c;
+    }
+    getCurrentDirectory() {
+        return '';
+    }
+    useCaseSensitiveFileNames() {
+        return true;
+    }
+    getSymlinkCache() {
+        return undefined;
+    }
+    getGlobalTypingsCacheLocation() {
+        return '';
+    }
+    getProjectReferenceOutputDts(_path) {
+        return '';
+    }
+    getRedirectTargets(_path) {
+        return [];
+    }
+    getSourceOfProjectReferenceIfOutputIncluded(file) {
+        return file.fileName;
+    }
+    fileExists(path) {
+        for (const file of this.c.files)
+            if (file.fileName === path)
+                return true;
+        return false;
+    }
+    getNearestAncestorDirectoryWithPackageJson(_directory) {
+        return '';
+    }
+    getPackageJsonInfo(_packageJsonPath) {
+        return undefined;
+    }
+    getDefaultResolutionModeForFile(file) {
+        return this.c.host.getDefaultResolutionModeForFile(file);
+    }
+    getResolvedModuleFromModuleSpecifier(_file, _specifier) {
+        return undefined;
+    }
+    getModeForUsageLocation(file, specifier) {
+        return this.c.host.getModeForUsageLocation(file, specifier);
+    }
+    getOutputPathsHost() {
+        return new FallbackOutputPathsHost();
+    }
+}
+class FallbackOutputPathsHost {
+    currentDirectory = '';
+    useCaseSensitiveFileNames = true;
+    commonSourceDirectory() {
+        return '';
+    }
+}
+function asSourceFile(node) {
+    if (node === undefined)
+        return undefined;
+    if (node instanceof SourceFile)
+        return node;
+    return undefined;
+}
+/** The file of a module: its value declaration's, else that of a declaration that isn't an augmentation. */
+function getSourceFileOfModule(symbol) {
+    let d = symbol.valueDeclaration;
+    if (d === undefined)
+        for (const declaration of getDeclarations(symbol))
+            if (!isExternalModuleAugmentation(declaration) && !isGlobalScopeAugmentation(declaration)) {
+                d = declaration;
+                break;
+            }
+    return d === undefined ? undefined : getSourceFileOfNode(d);
+}