tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/transformers/declarations-syntactic.js

@@ -0,0 +1,1582 @@
+// Answers declaration emit's queries from syntax and the binder: visibility, aliases to keep,
+// overloads and enum values exactly; types from annotations and the isolatedDeclarations
+// rules (literals, `as const`, annotated function expressions). Types that need inference
+// are reported to the tracker and written as `any`.
+import { AsExpression, BigIntLiteral, ObjectLiteralExpression, BindingElement, BindingPattern, ComputedPropertyName, ElementAccessExpression, ExportDeclaration, ExportSpecifier, ExternalModuleReference, FunctionTypeNode, Identifier, ImportAttribute, ImportAttributes, ImportEqualsDeclaration, KeywordTypeNode, LiteralTypeNode, MethodSignatureDeclaration, ModuleDeclaration, NodeVisitor, NumericLiteral, ParameterDeclaration, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertySignatureDeclaration, QualifiedName, SetAccessorDeclaration, GetAccessorDeclaration, HeritageClause, StringLiteral, NoSubstitutionTemplateLiteral, TemplateMiddle, TemplateTail, TypePredicateNode, TupleTypeNode, TypeLiteralNode, TypeOperatorNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, getAsteriskToken, getBody, getExpression, getInitializer, getMembers, getName, getText, getParameters, getSymbol, getType, } from '../ast.js';
+import { isAmbientModule, isFunctionLike, nodeIsPresent } from '../ast-utilities.js';
+import { getContainerFlags } from '../binder.js';
+import { getCombinedModifierFlags, getCombinedNodeFlags, getRootDeclaration, getSourceFileOfNode, hasSyntacticModifier, isEntityNameExpression, isExternalOrCommonJSModule, isGlobalSourceFile, isIdentifierNamed, isModuleAugmentationExternal, isParameterPropertyDeclaration, isStringOrNumericLiteralLike, skipParentheses, } from '../binder-utilities.js';
+import { NameResolver } from '../name-resolver.js';
+import { ModuleKind as ModuleKinds } from '../options.js';
+import { combinePaths, getDirectoryPath, getNormalizedAbsolutePath, normalizePath } from '../path.js';
+import { isIdentifierText } from '../scanner.js';
+import { Symbol, addDeclaration } from '../symbol.js';
+import { DeclarationEmitResolver, SymbolAccessibilityResult, accessible, } from './declarations-resolver.js';
+import { DirectType, InferredType, MaybeConstType, NoResultType, ObjectLiteralType, PseudoChecker, SignatureType, TupleType, UnionType, collectReturnStatements, couldAlreadyReferToUndefined, isConstTypeReference, isInConstContext, lastRequiredParameterIndex, typesOf, undefinedType, } from './declarations-pseudo.js';
+const emptyTable = new Map();
+/** Name resolution without module resolution: an import may name anything. */
+class DeclarationNameResolver extends NameResolver {
+    /** Global symbols merged across files, by each file's symbol. */
+    mergedSymbols;
+    constructor(options, mergedSymbols) {
+        super(options);
+        this.mergedSymbols = mergedSymbols;
+    }
+    getSymbolOfDeclaration(node) {
+        const symbol = getSymbol(node);
+        return symbol === undefined ? undefined : (this.mergedSymbols.get(symbol) ?? symbol);
+    }
+    lookup(symbols, name, meaning) {
+        if ((meaning & 1073741823 /* SymbolFlags.All */) === 0)
+            return undefined;
+        const symbol = symbols.get(name);
+        if (symbol === undefined)
+            return undefined;
+        if ((symbol.flags & meaning) !== 0)
+            return symbol;
+        // The checker resolves the alias; an unresolvable one matches every meaning.
+        return (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 ? symbol : undefined;
+    }
+}
+/** How much of a file's declaration types needed inference. */
+export class InferenceCounts {
+    /** Types without annotations or literal initializers. */
+    fallbacks;
+    /** Of those, the ones written as `any` because only the checker knows them. */
+    unresolved;
+    constructor() {
+        this.fallbacks = 0;
+        this.unresolved = 0;
+    }
+}
+/**
+ * The files of a program by path and its globals merged across script files, as declaration emit
+ * without the checker resolves names. Read-only once built, so checker threads can share one.
+ */
+export class DeclarationGlobals {
+    filesByPath;
+    globals;
+    /** Global symbols merged across files, by each file's symbol. */
+    mergedSymbols;
+    constructor(files, currentDirectory) {
+        this.filesByPath = new Map();
+        this.globals = new Map();
+        this.mergedSymbols = new Map();
+        for (const file of files) {
+            this.filesByPath.set(getNormalizedAbsolutePath(file.fileName, currentDirectory), file);
+            if (!isExternalOrCommonJSModule(file) && file.locals !== undefined)
+                mergeInto(this.globals, file.locals, this.mergedSymbols);
+        }
+    }
+}
+export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
+    options;
+    strictNullChecks;
+    emitResolver;
+    names;
+    pseudo;
+    filesByPath;
+    visibility;
+    aliasesMarked;
+    /** Inference counts by file. */
+    inference;
+    /**
+     * `emitResolver` answers the queries of JavaScript emit and enum values. `indexed` is the program's
+     * `DeclarationGlobals` if they were built before; otherwise they are built from `files`.
+     */
+    constructor(options, files, currentDirectory, emitResolver, indexed = undefined) {
+        super();
+        this.options = options;
+        this.strictNullChecks =
+            options.strictNullChecks !== undefined ? options.strictNullChecks : options.strict !== false;
+        this.emitResolver = emitResolver;
+        const index = indexed !== undefined ? indexed : new DeclarationGlobals(files, currentDirectory);
+        this.names = new DeclarationNameResolver(options, index.mergedSymbols);
+        this.pseudo = new PseudoChecker(this.strictNullChecks, index.mergedSymbols, this.names);
+        this.filesByPath = index.filesByPath;
+        this.visibility = new Map();
+        this.aliasesMarked = new Set();
+        this.inference = new Map();
+        this.names.globals = index.globals;
+    }
+    // Emit queries
+    markLinkedReferences(file) {
+        return this.emitResolver.markLinkedReferences(file);
+    }
+    isReferencedAliasDeclaration(node) {
+        return this.emitResolver.isReferencedAliasDeclaration(node);
+    }
+    isValueAliasDeclaration(node) {
+        return this.emitResolver.isValueAliasDeclaration(node);
+    }
+    isTopLevelValueImportEqualsWithEntityName(node) {
+        return this.emitResolver.isTopLevelValueImportEqualsWithEntityName(node);
+    }
+    // Visibility
+    precalculateDeclarationEmitVisibility(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 meaning = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */;
+        const parent = node.parent;
+        let symbol = undefined;
+        if (node.kind !== 10 /* SyntaxKind.StringLiteral */ && parent.kind === 278 /* SyntaxKind.ExportAssignment */)
+            symbol = this.resolveName(node, getIdentifierText(node), meaning);
+        else if (parent instanceof ExportSpecifier) {
+            const declaration = parent.parent.parent;
+            if (declaration instanceof ExportDeclaration &&
+                declaration.moduleSpecifier === undefined &&
+                node instanceof Identifier &&
+                node.text !== 'default')
+                symbol = this.resolveName(node, node.text, meaning);
+        }
+        const visited = new Set();
+        while (symbol !== undefined && !visited.has(symbol)) {
+            visited.add(symbol);
+            let next = undefined;
+            for (const declaration of symbol.declarations) {
+                this.visibility.set(declaration, true);
+                if (declaration instanceof ImportEqualsDeclaration &&
+                    !(declaration.moduleReference instanceof ExternalModuleReference)) {
+                    const first = getFirstIdentifier(declaration.moduleReference);
+                    next = this.resolveName(declaration, getIdentifierText(first), meaning);
+                }
+            }
+            symbol = next;
+        }
+        return true;
+    }
+    isDeclarationVisible(node) {
+        if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return false;
+        const cached = this.visibility.get(node);
+        if (cached !== undefined)
+            return cached;
+        const visible = this.determineIfDeclarationIsVisible(node);
+        this.visibility.set(node, visible);
+        return visible;
+    }
+    determineIfDeclarationIsVisible(node) {
+        switch (node.kind) {
+            case 331 /* SyntaxKind.JSDocCallbackTag */:
+            case 338 /* SyntaxKind.JSDocTypedefTag */: {
+                // Top-level JSDoc type aliases are exported.
+                const host = node.parent?.parent?.parent;
+                return host !== undefined && host.kind === 307 /* SyntaxKind.SourceFile */;
+            }
+            case 209 /* SyntaxKind.BindingElement */:
+                return this.isDeclarationVisible(node.parent.parent);
+            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */: {
+                if (node instanceof VariableDeclaration &&
+                    node.name instanceof BindingPattern &&
+                    node.name.elements.nodes.length === 0)
+                    return false;
+                if (isExternalModuleAugmentation(node) || isImplicitlyExportedJSDocDeclaration(node))
+                    return true;
+                const parent = getDeclarationContainer(node);
+                // Unexported declarations are visible only in global files; ambient module members are exported.
+                if ((getCombinedModifierFlags(node) & 32 /* ModifierFlags.Export */) === 0 &&
+                    !(node.kind !== 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+                        parent.kind !== 307 /* SyntaxKind.SourceFile */ &&
+                        (parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0))
+                    return isGlobalSourceFile(parent);
+                return this.isDeclarationVisible(parent);
+            }
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 172 /* SyntaxKind.PropertySignature */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 174 /* SyntaxKind.MethodSignature */:
+                if (this.getEffectiveDeclarationFlags(node, 2 /* ModifierFlags.Private */ | 4 /* ModifierFlags.Protected */) !== 0)
+                    return false;
+                return this.isDeclarationVisible(node.parent);
+            case 177 /* SyntaxKind.Constructor */:
+            case 181 /* SyntaxKind.ConstructSignature */:
+            case 180 /* SyntaxKind.CallSignature */:
+            case 182 /* SyntaxKind.IndexSignature */:
+            case 170 /* SyntaxKind.Parameter */:
+            case 269 /* SyntaxKind.ModuleBlock */:
+            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.ConstructorType */:
+            case 188 /* SyntaxKind.TypeLiteral */:
+            case 184 /* SyntaxKind.TypeReference */:
+            case 189 /* SyntaxKind.ArrayType */:
+            case 190 /* SyntaxKind.TupleType */:
+            case 193 /* SyntaxKind.UnionType */:
+            case 194 /* SyntaxKind.IntersectionType */:
+            case 197 /* SyntaxKind.ParenthesizedType */:
+            case 203 /* SyntaxKind.NamedTupleMember */:
+                return this.isDeclarationVisible(node.parent);
+            // Imports are visible only once something refers to them.
+            case 274 /* SyntaxKind.ImportClause */:
+            case 275 /* SyntaxKind.NamespaceImport */:
+            case 277 /* SyntaxKind.ImportSpecifier */:
+                return false;
+            case 169 /* SyntaxKind.TypeParameter */:
+            case 307 /* SyntaxKind.SourceFile */:
+            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+                return true;
+            case 278 /* SyntaxKind.ExportAssignment */:
+                return false;
+            case 282 /* SyntaxKind.ExportSpecifier */: {
+                const declaration = node.parent.parent;
+                if (declaration instanceof ExportDeclaration && declaration.moduleSpecifier === undefined)
+                    return this.isDeclarationVisible(declaration.parent);
+                return false;
+            }
+        }
+        return false;
+    }
+    isEntityNameVisible(entityName, enclosingDeclaration) {
+        if ((entityName.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return new SymbolAccessibilityResult(1 /* SymbolAccessibility.NotAccessible */, [], '', undefined, '');
+        const meaning = getMeaningOfEntityNameReference(entityName);
+        const first = getFirstIdentifier(entityName);
+        const text = getIdentifierText(first);
+        const symbol = this.resolveName(enclosingDeclaration, text, meaning);
+        if (symbol !== undefined && (symbol.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0 && (meaning & 788968 /* SymbolFlags.Type */) !== 0)
+            return accessible([]);
+        if (symbol === undefined && (first.kind === 109 /* SyntaxKind.ThisKeyword */ || text === 'this'))
+            return accessible([]);
+        if (symbol === undefined)
+            return new SymbolAccessibilityResult(3 /* SymbolAccessibility.NotResolved */, [], text, first, '');
+        const visible = this.hasVisibleDeclarations(symbol, true);
+        if (visible !== undefined)
+            return visible;
+        return new SymbolAccessibilityResult(1 /* SymbolAccessibility.NotAccessible */, [], text, first, '');
+    }
+    isSymbolAccessible(symbol, _enclosingDeclaration, _meaning, shouldComputeAliasesToMakeVisible) {
+        if ((symbol.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0)
+            return accessible([]);
+        const visible = this.hasVisibleDeclarations(symbol, shouldComputeAliasesToMakeVisible);
+        if (visible !== undefined)
+            return visible;
+        return new SymbolAccessibilityResult(1 /* SymbolAccessibility.NotAccessible */, [], symbol.name, undefined, '');
+    }
+    /** Accessible if every declaration is visible or can be made so by keeping an unexported statement. */
+    hasVisibleDeclarations(symbol, shouldComputeAliasesToMakeVisible) {
+        const aliases = [];
+        for (const declaration of symbol.declarations) {
+            if (declaration.kind === 79 /* SyntaxKind.Identifier */ || this.isDeclarationVisible(declaration))
+                continue;
+            let statement = undefined;
+            // Imports and unexported declarations can name types if their parent is visible.
+            const anyImport = getAnyImportSyntax(declaration);
+            if (anyImport !== undefined &&
+                !hasSyntacticModifier(anyImport, 32 /* ModifierFlags.Export */) &&
+                this.isDeclarationVisible(anyImport.parent))
+                statement = anyImport;
+            else if (declaration instanceof VariableDeclaration &&
+                declaration.parent.parent.kind === 244 /* SyntaxKind.VariableStatement */ &&
+                !hasSyntacticModifier(declaration.parent.parent, 32 /* ModifierFlags.Export */) &&
+                this.isDeclarationVisible(declaration.parent.parent.parent))
+                statement = declaration.parent.parent;
+            else if (isLateVisibilityPaintedStatement(declaration) &&
+                !hasSyntacticModifier(declaration, 32 /* ModifierFlags.Export */) &&
+                this.isDeclarationVisible(declaration.parent))
+                statement = declaration;
+            else if (declaration instanceof BindingElement && (symbol.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0) {
+                const root = getRootDeclaration(declaration);
+                if (root.kind === 170 /* SyntaxKind.Parameter */)
+                    return undefined;
+                const variableStatement = root.parent?.parent;
+                if (variableStatement === undefined || variableStatement.kind !== 244 /* SyntaxKind.VariableStatement */)
+                    return undefined;
+                // Already exported: nothing to keep.
+                if (hasSyntacticModifier(variableStatement, 32 /* ModifierFlags.Export */))
+                    continue;
+                if (!this.isDeclarationVisible(variableStatement.parent))
+                    return undefined;
+                statement = variableStatement;
+            }
+            if (statement === undefined)
+                return undefined;
+            if (shouldComputeAliasesToMakeVisible) {
+                this.visibility.set(declaration, true);
+                if (aliases.indexOf(statement) < 0)
+                    aliases.push(statement);
+            }
+        }
+        return accessible(aliases);
+    }
+    isNameResolvable(location, name) {
+        return this.resolveName(location, name, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */) !== undefined;
+    }
+    // Modules aren't resolved, so no import is known to be needed by an augmentation.
+    isImportRequiredByAugmentation(_node) {
+        return false;
+    }
+    // Declarations
+    getEffectiveDeclarationFlags(node, flags) {
+        let result = getCombinedModifierFlags(node);
+        const parent = node.parent;
+        // Class and interface members are never implicitly exported or ambient.
+        if (parent !== undefined &&
+            parent.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ &&
+            parent.kind !== 264 /* SyntaxKind.ClassDeclaration */ &&
+            parent.kind !== 232 /* SyntaxKind.ClassExpression */ &&
+            (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0) {
+            const container = getEnclosingContainer(node);
+            if (container !== undefined &&
+                (container.flags & 64 /* NodeFlags.ExportContext */) !== 0 &&
+                (result & 128 /* ModifierFlags.Ambient */) === 0 &&
+                !(parent.kind === 269 /* SyntaxKind.ModuleBlock */ && isGlobalScopeAugmentation(parent.parent)))
+                result |= 32 /* ModifierFlags.Export */;
+            result |= 128 /* ModifierFlags.Ambient */;
+        }
+        return result & flags;
+    }
+    isImplementationOfOverload(node) {
+        if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0 || !nodeIsPresent(getBody(node)))
+            return false;
+        if (node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */)
+            return false;
+        const symbol = this.getSymbolOfDeclaration(node);
+        if (symbol === undefined)
+            return false;
+        const signatures = [];
+        const declarations = symbol.declarations;
+        for (let i = 0; i < declarations.length; i++) {
+            const declaration = declarations[i];
+            if (!isFunctionLike(declaration))
+                continue;
+            // An implementation directly after an overload of the same kind isn't a signature.
+            if (i > 0 && getBody(declaration) !== undefined) {
+                const previous = declarations[i - 1];
+                if (declaration.parent === previous.parent &&
+                    declaration.kind === previous.kind &&
+                    declaration.pos === previous.end)
+                    continue;
+            }
+            signatures.push(declaration);
+        }
+        if (signatures.length > 1)
+            return true;
+        return signatures.length === 1 && signatures[0] !== node && (signatures[0].flags & 4194304 /* NodeFlags.JSDoc */) === 0;
+    }
+    isLateBound(node) {
+        const name = getName(node);
+        if (!(name instanceof ComputedPropertyName))
+            return false;
+        return this.isLateBindableExpression(name.expression);
+    }
+    /** Whether a computed name's expression has a unique symbol or literal type, as far as declarations say. */
+    isLateBindableExpression(expression) {
+        if (!isEntityNameExpression(expression, false))
+            return false;
+        const declaration = this.getEntityDeclaration(expression);
+        return declaration !== undefined && hasLiteralOrUniqueSymbolType(declaration);
+    }
+    /** The declaration `a` or `a.b.c` names: a variable, a member of a namespace, class or enum, or of an object type or literal. */
+    getEntityDeclaration(node) {
+        if (node instanceof Identifier) {
+            const symbol = this.resolveName(node, node.text, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */);
+            if (symbol === undefined)
+                return undefined;
+            const resolved = symbol.exportSymbol ?? symbol;
+            return resolved.valueDeclaration ?? (resolved.declarations.length > 0 ? resolved.declarations[0] : undefined);
+        }
+        if (!(node instanceof PropertyAccessExpression) || !(node.name instanceof Identifier))
+            return undefined;
+        const name = node.name.text;
+        const left = node.expression;
+        if (left.kind === 79 /* SyntaxKind.Identifier */ || left.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+            const symbol = this.resolveEntityNameExpression(left, 111551 /* SymbolFlags.Value */ | 1920 /* SymbolFlags.Namespace */);
+            if (symbol !== undefined && (symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0) {
+                const member = (symbol.exports ?? emptyTable).get(name);
+                if (member !== undefined)
+                    return member.valueDeclaration;
+            }
+        }
+        // A member of a variable's object type or object literal.
+        const container = this.getEntityDeclaration(left);
+        if (!(container instanceof VariableDeclaration))
+            return undefined;
+        const members = container.type instanceof TypeLiteralNode
+            ? container.type.members.nodes
+            : container.initializer !== undefined
+                ? objectLiteralProperties(container.initializer)
+                : [];
+        for (const member of members) {
+            const memberName = getName(member);
+            if (memberName !== undefined && tryGetTextOfPropertyName(memberName) === name)
+                return member;
+        }
+        return undefined;
+    }
+    isDefinitelyReferenceToGlobalSymbolObject(node) {
+        if (!(node instanceof PropertyAccessExpression) || !(node.name instanceof Identifier))
+            return false;
+        const expression = node.expression;
+        if (expression instanceof Identifier)
+            return expression.text === 'Symbol' && this.isGlobalValue(expression, 'Symbol');
+        if (!(expression instanceof PropertyAccessExpression) || !(expression.expression instanceof Identifier))
+            return false;
+        return (expression.expression.text === 'globalThis' &&
+            isIdentifierNamed(expression.name, 'Symbol') &&
+            this.resolveName(expression.expression, 'globalThis', 111551 /* SymbolFlags.Value */) === undefined);
+    }
+    /** Whether `name` at `location` resolves to a declaration of a global file. */
+    isGlobalValue(location, name) {
+        const symbol = this.resolveName(location, name, 111551 /* SymbolFlags.Value */);
+        return symbol !== undefined && this.pseudo.getMergedSymbol(symbol) === this.names.globals.get(name);
+    }
+    isLiteralConstDeclaration(node) {
+        if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return false;
+        const isConst = node instanceof VariableDeclaration
+            ? (getCombinedNodeFlags(node) & 2 /* NodeFlags.Const */) !== 0
+            : (getCombinedModifierFlags(node) & 8 /* ModifierFlags.Readonly */) !== 0 &&
+                !isParameterPropertyDeclaration(node, node.parent);
+        if (!isConst || getType(node) !== undefined)
+            return false;
+        const initializer = getInitializer(node);
+        // A fresh literal type; enum members are too, but need the checker to tell apart.
+        return initializer !== undefined && literalOf(skipParentheses(initializer)) !== undefined;
+    }
+    isOptionalParameter(node) {
+        if (!(node instanceof ParameterDeclaration))
+            return false;
+        if (node.questionToken !== undefined)
+            return true;
+        if (node.initializer === undefined)
+            return false;
+        const parameters = getParameters(node.parent).nodes;
+        return parameters.indexOf(node) >= lastRequiredParameterIndex(parameters);
+    }
+    requiresAddingImplicitUndefined(node, enclosingDeclaration) {
+        if (node === undefined || !(node instanceof ParameterDeclaration) || (node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return false;
+        const required = this.isRequiredInitializedParameter(node, enclosingDeclaration) ||
+            this.isOptionalUninitializedParameterProperty(node);
+        return required && !this.declaredTypeContainsUndefined(node);
+    }
+    isRequiredInitializedParameter(node, enclosingDeclaration) {
+        if (!this.strictNullChecks || this.isOptionalParameter(node) || node.initializer === undefined)
+            return false;
+        if (hasSyntacticModifier(node, 31 /* ModifierFlags.ParameterPropertyModifier */))
+            return enclosingDeclaration !== undefined && isFunctionLike(enclosingDeclaration);
+        return true;
+    }
+    isOptionalUninitializedParameterProperty(node) {
+        return (this.strictNullChecks &&
+            this.isOptionalParameter(node) &&
+            node.initializer === undefined &&
+            hasSyntacticModifier(node, 31 /* ModifierFlags.ParameterPropertyModifier */));
+    }
+    /** Whether an annotation includes `undefined`, or names something unresolved (an error type). */
+    declaredTypeContainsUndefined(node) {
+        const type = node.type;
+        return type !== undefined && this.typeContainsUndefined(type, node);
+    }
+    typeContainsUndefined(type, location) {
+        switch (type.kind) {
+            case 157 /* SyntaxKind.UndefinedKeyword */:
+            case 132 /* SyntaxKind.AnyKeyword */:
+            case 159 /* SyntaxKind.UnknownKeyword */:
+                return true;
+            case 197 /* SyntaxKind.ParenthesizedType */:
+                return this.typeContainsUndefined(getType(type), location);
+            case 193 /* SyntaxKind.UnionType */:
+                for (const member of typesOf(type))
+                    if (this.typeContainsUndefined(member, location))
+                        return true;
+                return false;
+            case 184 /* SyntaxKind.TypeReference */: {
+                // An unresolved name or import is an error type, which counts as containing `undefined`.
+                const symbol = this.resolveName(location, getIdentifierText(getFirstIdentifier(type.typeName)), 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */);
+                return symbol === undefined || (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0;
+            }
+        }
+        return false;
+    }
+    isExpandoFunctionDeclaration(node) {
+        return this.getExpandoPropertyDeclarations(node).length > 0;
+    }
+    getExpandoPropertyDeclarations(node) {
+        const result = [];
+        let host = node;
+        // Properties assigned to a function-valued variable are bound to the function.
+        if (node instanceof VariableDeclaration)
+            host = node.initializer;
+        else if (node.kind !== 263 /* SyntaxKind.FunctionDeclaration */)
+            host = undefined;
+        if (host === undefined || !isFunctionLike(host))
+            return result;
+        const symbol = getSymbol(host);
+        if (symbol === undefined || symbol.exports === undefined)
+            return result;
+        for (const property of symbol.exports.values())
+            if ((property.flags & 67108864 /* SymbolFlags.Assignment */) !== 0 && property.valueDeclaration !== undefined)
+                result.push(property.valueDeclaration);
+        return result;
+    }
+    // Emit queries answered by the reference resolver.
+    getReferencedExportContainer(node, prefixLocals) {
+        return this.emitResolver.getReferencedExportContainer(node, prefixLocals);
+    }
+    getReferencedImportDeclaration(node) {
+        return this.emitResolver.getReferencedImportDeclaration(node);
+    }
+    getReferencedValueDeclaration(node) {
+        return this.emitResolver.getReferencedValueDeclaration(node);
+    }
+    getReferencedValueDeclarations(node) {
+        return this.emitResolver.getReferencedValueDeclarations(node);
+    }
+    getEnumMemberValue(member) {
+        return this.emitResolver.getEnumMemberValue(member);
+    }
+    getConstantValue(node) {
+        return this.emitResolver.getConstantValue(node);
+    }
+    setReferencedImportDeclaration(name, declaration) {
+        this.emitResolver.setReferencedImportDeclaration(name, declaration);
+    }
+    getJsxFactoryEntity(file) {
+        return this.emitResolver.getJsxFactoryEntity(file);
+    }
+    getJsxFragmentFactoryEntity(file) {
+        return this.emitResolver.getJsxFragmentFactoryEntity(file);
+    }
+    getTypeReferenceSerializationKind(typeName, location) {
+        return this.emitResolver.getTypeReferenceSerializationKind(typeName, location);
+    }
+    getResolutionModeOverride(node) {
+        if (!(node instanceof ImportAttributes))
+            return undefined;
+        for (const element of node.attributes.nodes) {
+            if (!(element instanceof ImportAttribute))
+                continue;
+            const name = element.name;
+            if (name === undefined || (name.kind !== 10 /* SyntaxKind.StringLiteral */ && name.kind !== 79 /* SyntaxKind.Identifier */))
+                continue;
+            if (getText(name) !== 'resolution-mode')
+                continue;
+            const value = element.value;
+            if (!(value instanceof StringLiteral))
+                return undefined;
+            if (value.text === 'import')
+                return ModuleKinds.ESNext;
+            if (value.text === 'require')
+                return ModuleKinds.CommonJS;
+        }
+        return undefined;
+    }
+    getSourceFileFromReference(file, reference) {
+        const path = normalizePath(combinePaths(getDirectoryPath(file.fileName), reference.fileName));
+        for (const candidate of [path, path + '.ts', path + '.tsx', path + '.d.ts']) {
+            const found = this.filesByPath.get(candidate);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    }
+    // JavaScript members need the checker.
+    getReferencedMemberValueDeclaration(node) {
+        const symbol = getSymbol(node);
+        return symbol === undefined ? undefined : symbol.valueDeclaration;
+    }
+    isThisPropertyAssignmentDeclarationRedundant(_node) {
+        return false;
+    }
+    getElementAccessExpressionName(node) {
+        if (!(node instanceof ElementAccessExpression))
+            return '';
+        const argument = node.argumentExpression;
+        return isStringOrNumericLiteralLike(argument) ? literalText(argument) : '';
+    }
+    // Type nodes
+    createTypeOfDeclaration(context, declaration, enclosingDeclaration, flags, tracker) {
+        if ((declaration.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return undefined;
+        const writer = new PseudoTypeWriter(this, context, tracker, enclosingDeclaration, flags);
+        const isAccessor = declaration.kind === 178 /* SyntaxKind.GetAccessor */ || declaration.kind === 179 /* SyntaxKind.SetAccessor */;
+        this.pseudo.uncertain = 0;
+        let type = isAccessor ? this.pseudo.getTypeOfAccessor(declaration) : this.pseudo.getTypeOfDeclaration(declaration);
+        if (declaration.kind === 170 /* SyntaxKind.Parameter */ &&
+            this.requiresAddingImplicitUndefined(declaration, enclosingDeclaration) &&
+            !this.pseudoContainsUndefined(type))
+            type = new UnionType([type, undefinedType]);
+        const result = writer.write(type);
+        // Declarations merged across files have the type of their first declaration.
+        if (this.pseudo.uncertain > 0 || this.hasMergedDeclarations(declaration))
+            this.countFallback(declaration, true);
+        return result;
+    }
+    hasMergedDeclarations(declaration) {
+        const symbol = getSymbol(declaration);
+        return symbol !== undefined && this.pseudo.getMergedSymbol(symbol).declarations.length > symbol.declarations.length;
+    }
+    /** Whether a parameter's pseudo-type already has `undefined`, so none is added. */
+    pseudoContainsUndefined(type) {
+        if (type instanceof UnionType) {
+            for (const member of type.types)
+                if (this.pseudoContainsUndefined(member))
+                    return true;
+            return false;
+        }
+        if (type instanceof DirectType)
+            return couldAlreadyReferToUndefined(type) && type.typeNode.kind !== 184 /* SyntaxKind.TypeReference */;
+        return type.kind === 5 /* PseudoTypeKind.Undefined */;
+    }
+    createReturnTypeOfSignatureDeclaration(context, signature, enclosingDeclaration, flags, tracker) {
+        if ((signature.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return undefined;
+        const type = this.pseudo.getReturnTypeOfSignature(signature);
+        const writer = new PseudoTypeWriter(this, context, tracker, enclosingDeclaration, flags);
+        if (type instanceof InferredType && type.isSignatureReturn && type.errorNodes.length === 0) {
+            // A body without returned values is `void`, as the checker infers.
+            const inferredVoid = isTriviallyVoid(signature);
+            if (inferredVoid) {
+                writer.reportFallback(type, false);
+                return context.factory.created(new KeywordTypeNode(115 /* SyntaxKind.VoidKeyword */));
+            }
+        }
+        if (type instanceof NoResultType && getBody(signature) === undefined && signature.kind !== 178 /* SyntaxKind.GetAccessor */) {
+            // A signature without a body or annotation returns `any`.
+            writer.reportFallback(type, false);
+            return undefined;
+        }
+        return writer.write(type);
+    }
+    createTypeParametersOfSignatureDeclaration(_context, signature, _enclosingDeclaration, _flags, _tracker) {
+        this.countFallback(signature, true);
+        return undefined;
+    }
+    createLiteralConstValue(context, node, _tracker) {
+        const initializer = node.kind === 278 /* SyntaxKind.ExportAssignment */ ? getExpression(node) : getInitializer(node);
+        if (initializer === undefined)
+            return undefined;
+        const literal = literalOf(skipParentheses(initializer));
+        if (literal === undefined) {
+            this.countFallback(node, true);
+            return undefined;
+        }
+        const factory = context.factory;
+        switch (literal.kind) {
+            case 111 /* SyntaxKind.TrueKeyword */:
+            case 96 /* SyntaxKind.FalseKeyword */:
+                return factory.createKeywordExpression(literal.kind);
+            case 10 /* SyntaxKind.StringLiteral */:
+            case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+                return factory.createStringLiteral(literalText(literal), 0 /* TokenFlags.None */);
+            case 9 /* SyntaxKind.BigIntLiteral */:
+                return factory.created(new BigIntLiteral(literal.text, 0 /* TokenFlags.None */));
+            case 8 /* SyntaxKind.NumericLiteral */:
+                return createNumberExpression(context, Number(literal.text));
+            case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+                const unary = literal;
+                const operand = unary.operand;
+                if (operand instanceof BigIntLiteral)
+                    return factory.created(new BigIntLiteral(unary.operator === 40 /* SyntaxKind.MinusToken */ ? '-' + operand.text : operand.text, 0 /* TokenFlags.None */));
+                const value = Number(operand.text);
+                return createNumberExpression(context, unary.operator === 40 /* SyntaxKind.MinusToken */ ? -value : value);
+            }
+        }
+        return undefined;
+    }
+    createTypeOfExpression(context, expression, enclosingDeclaration, flags, tracker) {
+        const writer = new PseudoTypeWriter(this, context, tracker, enclosingDeclaration, flags);
+        this.countFallback(expression, true);
+        // An expression's own type: literals aren't widened.
+        const type = this.pseudo.getTypeOfExpression(expression);
+        return writer.write(type instanceof MaybeConstType ? type.constType : type);
+    }
+    createLateBoundIndexSignatures(context, container, enclosingDeclaration, flags, tracker) {
+        // These come from computed names whose types aren't literals or unique symbols; only the
+        // checker knows them. Writing them reports their members' types that need inference.
+        const members = getMembers(container);
+        if (members === undefined)
+            return [];
+        const writer = new PseudoTypeWriter(this, context, tracker, enclosingDeclaration, flags);
+        for (const member of members.nodes) {
+            const name = getName(member);
+            if (!(name instanceof ComputedPropertyName) || !isEntityNameExpression(name.expression, false))
+                continue;
+            if (this.isLateBindableExpression(name.expression))
+                continue;
+            this.countFallback(member, true);
+            if (isFunctionLike(member) && getType(member) === undefined && member.kind !== 179 /* SyntaxKind.SetAccessor */)
+                writer.write(this.pseudo.getReturnTypeOfSignature(member));
+            else if (member.kind === 173 /* SyntaxKind.PropertyDeclaration */ && getType(member) === undefined)
+                writer.write(this.pseudo.getTypeOfDeclaration(member));
+        }
+        return [];
+    }
+    tryJSTypeNodeToTypeNode(_context, typeNode, _enclosingDeclaration, _flags, _tracker) {
+        // JSDoc types are rewritten with their meaning (`String` is `string`), which needs symbols.
+        this.countFallback(typeNode, true);
+        return undefined;
+    }
+    // Helpers
+    /** The symbol of a declaration, merged with same-named globals of other files. */
+    getSymbolOfDeclaration(node) {
+        const symbol = getSymbol(node);
+        return symbol === undefined ? undefined : this.pseudo.getMergedSymbol(symbol);
+    }
+    resolveName(location, name, meaning) {
+        return this.names.resolve(location, name, meaning, undefined, false, false);
+    }
+    /** The symbol of `a` or `a.b.c`, looking members up in namespace and enum exports. */
+    resolveEntityNameExpression(node, meaning) {
+        if (node instanceof Identifier)
+            return this.resolveName(node, node.text, meaning);
+        let left = undefined;
+        let right = undefined;
+        if (node instanceof PropertyAccessExpression) {
+            left = node.expression;
+            right = node.name;
+        }
+        else if (node instanceof QualifiedName) {
+            left = node.left;
+            right = node.right;
+        }
+        if (left !== undefined && right !== undefined) {
+            const namespace = this.resolveEntityNameExpression(left, 1920 /* SymbolFlags.Namespace */);
+            if (namespace === undefined || (namespace.flags & 2097152 /* SymbolFlags.Alias */) !== 0 || !(right instanceof Identifier))
+                return undefined;
+            const member = (namespace.exports ?? emptyTable).get(right.text);
+            return member !== undefined && (member.flags & meaning) !== 0 ? member : undefined;
+        }
+        return undefined;
+    }
+    /** Records a type that needed inference; `unresolved` if it's written as `any`. */
+    countFallback(node, unresolved) {
+        const file = getSourceFileOfNode(node);
+        let counts = this.inference.get(file);
+        if (counts === undefined) {
+            counts = new InferenceCounts();
+            this.inference.set(file, counts);
+        }
+        counts.fallbacks++;
+        if (unresolved)
+            counts.unresolved++;
+        return true;
+    }
+}
+/** Writes pseudo-types as type nodes; types that need inference make the result undefined. */
+class PseudoTypeWriter {
+    resolver;
+    context;
+    tracker;
+    enclosingDeclaration;
+    flags;
+    /** Whether a reused node names something that can't be named where it's written. */
+    reuseFailed;
+    constructor(resolver, context, tracker, enclosingDeclaration, flags) {
+        this.resolver = resolver;
+        this.context = context;
+        this.tracker = tracker;
+        this.enclosingDeclaration = enclosingDeclaration;
+        this.flags = flags;
+        this.reuseFailed = false;
+    }
+    /** Reports where inference was needed, as the checker's node builder does. */
+    reportFallback(type, unresolved) {
+        let location;
+        if (type instanceof InferredType) {
+            if (type.errorNodes.length > 0) {
+                for (const node of type.errorNodes)
+                    this.tracker.reportInferenceFallback(node);
+                return this.resolver.countFallback(type.errorNodes[0], unresolved);
+            }
+            const expression = type.expression;
+            const parent = expression.parent;
+            location =
+                isEntityNameExpression(expression, false) && parent !== undefined && isDeclarationKind(parent.kind)
+                    ? parent
+                    : expression;
+        }
+        else if (type instanceof NoResultType)
+            location = type.declaration;
+        else
+            return false;
+        this.tracker.reportInferenceFallback(location);
+        return this.resolver.countFallback(location, unresolved);
+    }
+    write(type) {
+        const factory = this.context.factory;
+        switch (type.kind) {
+            case 0 /* PseudoTypeKind.Direct */:
+                return this.reuseTypeNode(type.typeNode);
+            case 1 /* PseudoTypeKind.Inferred */: {
+                const inferred = type;
+                // A body without returned values is `void`, as the checker infers.
+                if (inferred.isSignatureReturn && inferred.errorNodes.length === 0 && isTriviallyVoid(inferred.expression)) {
+                    this.reportFallback(type, false);
+                    return this.keyword(115 /* SyntaxKind.VoidKeyword */);
+                }
+                this.reportFallback(type, true);
+                return undefined;
+            }
+            case 2 /* PseudoTypeKind.NoResult */:
+                this.reportFallback(type, true);
+                return undefined;
+            case 3 /* PseudoTypeKind.MaybeConstLocation */: {
+                const maybe = type;
+                return this.write(isInConstContext(maybe.node) ? maybe.constType : maybe.regularType);
+            }
+            case 4 /* PseudoTypeKind.Union */:
+                if (type instanceof UnionType) {
+                    const narrowed = type;
+                    return this.writeUnion(narrowed);
+                }
+                break;
+            case 5 /* PseudoTypeKind.Undefined */:
+                return this.keyword(this.resolver.strictNullChecks ? 157 /* SyntaxKind.UndefinedKeyword */ : 132 /* SyntaxKind.AnyKeyword */);
+            case 6 /* PseudoTypeKind.Null */:
+                if (!this.resolver.strictNullChecks)
+                    return this.keyword(132 /* SyntaxKind.AnyKeyword */);
+                return factory.created(new LiteralTypeNode(factory.createKeywordExpression(105 /* SyntaxKind.NullKeyword */)));
+            case 7 /* PseudoTypeKind.Any */:
+                return this.keyword(132 /* SyntaxKind.AnyKeyword */);
+            case 8 /* PseudoTypeKind.String */:
+                return this.keyword(154 /* SyntaxKind.StringKeyword */);
+            case 9 /* PseudoTypeKind.Number */:
+                return this.keyword(150 /* SyntaxKind.NumberKeyword */);
+            case 10 /* PseudoTypeKind.BigInt */:
+                return this.keyword(163 /* SyntaxKind.BigIntKeyword */);
+            case 11 /* PseudoTypeKind.Boolean */:
+                return this.keyword(135 /* SyntaxKind.BooleanKeyword */);
+            case 12 /* PseudoTypeKind.False */:
+                return factory.created(new LiteralTypeNode(factory.createKeywordExpression(96 /* SyntaxKind.FalseKeyword */)));
+            case 13 /* PseudoTypeKind.True */:
+                return factory.created(new LiteralTypeNode(factory.createKeywordExpression(111 /* SyntaxKind.TrueKeyword */)));
+            case 14 /* PseudoTypeKind.SingleCallSignature */:
+                if (type instanceof SignatureType) {
+                    const narrowed = type;
+                    return this.writeSignature(narrowed);
+                }
+                break;
+            case 15 /* PseudoTypeKind.Tuple */:
+                if (type instanceof TupleType) {
+                    const narrowed = type;
+                    return this.writeTuple(narrowed);
+                }
+                break;
+            case 16 /* PseudoTypeKind.ObjectLiteral */:
+                if (type instanceof ObjectLiteralType) {
+                    const narrowed = type;
+                    return this.writeObjectLiteral(narrowed);
+                }
+                break;
+            case 17 /* PseudoTypeKind.StringLiteral */:
+            case 18 /* PseudoTypeKind.NumericLiteral */:
+            case 19 /* PseudoTypeKind.BigIntLiteral */:
+                return factory.created(new LiteralTypeNode(this.reuseNode(type.node)));
+        }
+        return undefined;
+    }
+    keyword(kind) {
+        return this.context.factory.created(new KeywordTypeNode(kind));
+    }
+    writeUnion(type) {
+        const result = [];
+        let hasElided = false;
+        let failed = false;
+        for (const member of type.types) {
+            if (!this.resolver.strictNullChecks &&
+                (member.kind === 5 /* PseudoTypeKind.Undefined */ || member.kind === 6 /* PseudoTypeKind.Null */)) {
+                hasElided = true;
+                continue;
+            }
+            const node = this.write(member);
+            if (node === undefined)
+                failed = true;
+            else
+                appendUnionMember(result, node);
+        }
+        if (failed)
+            return undefined;
+        if (result.length === 1)
+            return result[0];
+        if (result.length === 0)
+            return this.keyword(hasElided ? 132 /* SyntaxKind.AnyKeyword */ : 146 /* SyntaxKind.NeverKeyword */);
+        return this.context.factory.created(new UnionTypeNode(this.context.factory.createNodeList(result)));
+    }
+    writeSignature(type) {
+        const factory = this.context.factory;
+        const typeParameters = [];
+        for (const parameter of type.typeParameters)
+            typeParameters.push(this.reuseNode(parameter));
+        const parameters = this.writeParameters(type.parameters);
+        const returnType = this.write(type.returnType);
+        if (parameters === undefined || returnType === undefined)
+            return undefined;
+        return factory.created(new FunctionTypeNode(typeParameters.length > 0 ? factory.createNodeList(typeParameters) : undefined, parameters, returnType));
+    }
+    // Writers of composite types write every part, so each part needing inference is reported.
+    writeParameters(parameters) {
+        const result = [];
+        let failed = false;
+        for (const parameter of parameters) {
+            const node = this.writeParameter(parameter);
+            if (node === undefined)
+                failed = true;
+            else
+                result.push(node);
+        }
+        return failed ? undefined : this.context.factory.createNodeList(result);
+    }
+    writeParameter(parameter) {
+        const factory = this.context.factory;
+        const type = this.write(parameter.type);
+        if (type === undefined)
+            return undefined;
+        const result = factory.created(new ParameterDeclaration(undefined, parameter.rest ? factory.createToken(25 /* SyntaxKind.DotDotDotToken */) : undefined, this.cloneParameterName(parameter.name), parameter.optional ? factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, type, undefined));
+        const original = parameter.name.parent;
+        if (original !== undefined && original.kind === 170 /* SyntaxKind.Parameter */)
+            this.context.assignCommentRange(result, original);
+        return result;
+    }
+    /** Parameter names are rewritten from scratch: identifiers as is, binding patterns without initializers. */
+    cloneParameterName(name) {
+        // Rewritten names have no source positions.
+        const clone = name.deepClone();
+        clearPositions(clone);
+        if (clone instanceof BindingPattern) {
+            stripBindingInitializers(clone);
+            this.context.setEmitFlags(clone, 1 /* EmitFlags.SingleLine */ | 131072 /* EmitFlags.NoAsciiEscaping */);
+        }
+        else
+            this.context.setEmitFlags(clone, 131072 /* EmitFlags.NoAsciiEscaping */);
+        return clone;
+    }
+    writeTuple(type) {
+        const factory = this.context.factory;
+        const elements = [];
+        let failed = false;
+        for (const element of type.elements) {
+            const node = this.write(element);
+            if (node === undefined)
+                failed = true;
+            else
+                elements.push(node);
+        }
+        if (failed)
+            return undefined;
+        const tuple = factory.created(new TupleTypeNode(factory.createNodeList(elements)));
+        this.context.addEmitFlags(tuple, 1 /* EmitFlags.SingleLine */);
+        // `as const` arrays are readonly.
+        return factory.created(new TypeOperatorNode(148 /* SyntaxKind.ReadonlyKeyword */, tuple));
+    }
+    writeObjectLiteral(type) {
+        const factory = this.context.factory;
+        const members = type.members;
+        if (members.length === 0) {
+            const empty = factory.created(new TypeLiteralNode(factory.createNodeList([])));
+            this.context.addEmitFlags(empty, 1 /* EmitFlags.SingleLine */);
+            return empty;
+        }
+        const isConst = isInConstContext(members[0].name.parent.parent);
+        const result = [];
+        let failed = false;
+        for (const member of members) {
+            const modifiers = isConst || (member.kind === 1 /* PseudoMemberKind.Property */ && member.readonly)
+                ? factory.createModifierList([factory.createToken(148 /* SyntaxKind.ReadonlyKeyword */)])
+                : undefined;
+            let node = undefined;
+            switch (member.kind) {
+                case 0 /* PseudoMemberKind.Method */: {
+                    const typeParameters = [];
+                    for (const parameter of member.typeParameters)
+                        typeParameters.push(this.reuseNode(parameter));
+                    const typeParameterList = typeParameters.length > 0 ? factory.createNodeList(typeParameters) : undefined;
+                    const parameters = this.writeParameters(member.parameters);
+                    const returnType = this.write(member.type);
+                    if (parameters === undefined || returnType === undefined)
+                        break;
+                    node = isConst
+                        ? factory.created(new PropertySignatureDeclaration(modifiers, this.reuseName(member.name, false), undefined, factory.created(new FunctionTypeNode(typeParameterList, parameters, returnType)), undefined))
+                        : factory.created(new MethodSignatureDeclaration(modifiers, this.reuseName(member.name, true), undefined, typeParameterList, parameters, returnType));
+                    break;
+                }
+                case 1 /* PseudoMemberKind.Property */: {
+                    const propertyType = this.write(member.type);
+                    if (propertyType === undefined)
+                        break;
+                    node = factory.created(new PropertySignatureDeclaration(modifiers, this.reuseName(member.name, false), undefined, propertyType, undefined));
+                    break;
+                }
+                case 2 /* PseudoMemberKind.SetAccessor */: {
+                    const parameters = this.writeParameters(member.parameters);
+                    if (parameters === undefined)
+                        break;
+                    node = factory.created(new SetAccessorDeclaration(undefined, this.reuseName(member.name, false), undefined, parameters, undefined, undefined, undefined));
+                    break;
+                }
+                case 3 /* PseudoMemberKind.GetAccessor */: {
+                    const accessorType = this.write(member.type);
+                    if (accessorType === undefined)
+                        break;
+                    node = factory.created(new GetAccessorDeclaration(undefined, this.reuseName(member.name, false), undefined, factory.createNodeList([]), accessorType, undefined, undefined));
+                    break;
+                }
+            }
+            if (node === undefined) {
+                failed = true;
+                continue;
+            }
+            const declaration = member.name.parent;
+            this.context.setCommentRange(node, declaration.pos, declaration.end);
+            result.push(node);
+        }
+        if (failed)
+            return undefined;
+        const literal = factory.created(new TypeLiteralNode(factory.createNodeList(result)));
+        if ((this.flags & 1024 /* NodeBuilderFlags.MultilineObjectLiterals */) === 0)
+            this.context.addEmitFlags(literal, 1 /* EmitFlags.SingleLine */);
+        return literal;
+    }
+    /** A property name, as an identifier when it can be one. */
+    reuseName(name, isMethod) {
+        const result = this.reuseNode(name);
+        const text = tryGetTextOfPropertyName(result);
+        if (text === undefined)
+            return result;
+        const kind = classifyPropertyName(text, result.kind === 10 /* SyntaxKind.StringLiteral */, isMethod);
+        if (result.kind === 79 /* SyntaxKind.Identifier */ && kind === 0 /* PropertyNameKind.Identifier */)
+            return result;
+        if (result.kind === 10 /* SyntaxKind.StringLiteral */ && kind === 2 /* PropertyNameKind.StringLiteral */)
+            return result;
+        let renamed;
+        if (kind === 0 /* PropertyNameKind.Identifier */)
+            renamed = this.context.factory.createIdentifier(text);
+        else if (kind === 2 /* PropertyNameKind.StringLiteral */)
+            renamed = this.context.factory.createStringLiteral(text, 0 /* TokenFlags.None */);
+        else
+            return result;
+        this.context.setOriginal(renamed, result);
+        renamed.pos = result.pos;
+        renamed.end = result.end;
+        return renamed;
+    }
+    /** A copy of an expression or type parameter from the source. */
+    reuseNode(node) {
+        this.trackEntityNames(node);
+        const clone = node.deepClone();
+        styleReusedNodes(this.context, clone);
+        return clone;
+    }
+    /** A copy of an annotation, with the names it uses checked and their imports kept; undefined if one can't be named. */
+    reuseTypeNode(node) {
+        const failed = this.reuseFailed;
+        this.reuseFailed = false;
+        const result = this.reuseNode(node);
+        const reused = !this.reuseFailed;
+        this.reuseFailed = failed || !reused;
+        if (reused)
+            return result;
+        // The checker writes the type the annotation denotes instead.
+        this.tracker.reportInferenceFallback(node);
+        this.resolver.countFallback(node, true);
+        return undefined;
+    }
+    trackEntityNames(node) {
+        this.markJSDocType(node);
+        node.forEachChild(new EntityNameTracker(this));
+        return this.trackEntityName(node);
+    }
+    /** JSDoc types such as `?T` can't be reused as written. */
+    markJSDocType(node) {
+        if (node.kind >= 308 /* SyntaxKind.FirstJSDocNode */ && node.kind <= 343 /* SyntaxKind.LastJSDocNode */)
+            this.reuseFailed = true;
+        return true;
+    }
+    trackEntityName(node) {
+        let name = undefined;
+        if (node instanceof TypeReferenceNode)
+            name = node.typeName;
+        else if (node instanceof TypeQueryNode)
+            name = node.exprName;
+        else if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */)
+            name = node.expression;
+        if (name === undefined || !(isEntityNameExpression(name, false) || name instanceof QualifiedName))
+            return false;
+        const first = getFirstIdentifier(name);
+        if (!(first instanceof Identifier))
+            return false;
+        const meaning = getMeaningOfEntityNameReference(name);
+        const symbol = this.resolver.resolveName(first, first.text, meaning);
+        if (symbol === undefined || isSignatureLocal(symbol))
+            return false;
+        // `typeof x` in the declaration of `x` is circular.
+        const declaration = symbol.valueDeclaration;
+        if (node instanceof TypeQueryNode &&
+            declaration !== undefined &&
+            declaration.pos <= node.pos &&
+            node.end <= declaration.end &&
+            getSourceFileOfNode(declaration) === getSourceFileOfNode(node)) {
+            this.reuseFailed = true;
+            return false;
+        }
+        const result = this.resolver.isSymbolAccessible(symbol, this.enclosingDeclaration, meaning, false);
+        if (result.accessibility !== 0 /* SymbolAccessibility.Accessible */) {
+            this.reuseFailed = true;
+            return false;
+        }
+        return this.tracker.trackSymbol(symbol, this.enclosingDeclaration, meaning);
+    }
+}
+/** Parameters and type parameters are in scope where the signature's types are written. */
+function isSignatureLocal(symbol) {
+    const declaration = symbol.valueDeclaration ?? (symbol.declarations.length > 0 ? symbol.declarations[0] : undefined);
+    return (declaration !== undefined &&
+        (declaration.kind === 170 /* SyntaxKind.Parameter */ || declaration.kind === 169 /* SyntaxKind.TypeParameter */));
+}
+class EntityNameTracker extends NodeVisitor {
+    writer;
+    constructor(writer) {
+        super();
+        this.writer = writer;
+    }
+    visitNode(node) {
+        this.writer.markJSDocType(node);
+        this.writer.trackEntityName(node);
+        return node.forEachChild(this);
+    }
+}
+/** Single-line tuples and mapped types, and string literals without escapes, as tsgo's node reuse. */
+function styleReusedNodes(context, node) {
+    const kind = node.kind;
+    if (kind === 190 /* SyntaxKind.TupleType */ || kind === 201 /* SyntaxKind.MappedType */)
+        context.addEmitFlags(node, 1 /* EmitFlags.SingleLine */);
+    else if (kind === 10 /* SyntaxKind.StringLiteral */ || kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */)
+        context.addEmitFlags(node, 131072 /* EmitFlags.NoAsciiEscaping */);
+    node.forEachChild(new ReusedNodeStyler(context));
+    return true;
+}
+class ReusedNodeStyler extends NodeVisitor {
+    context;
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    visitNode(node) {
+        styleReusedNodes(this.context, node);
+        return false;
+    }
+}
+function clearPositions(node) {
+    node.pos = -1;
+    node.end = -1;
+    node.forEachChild(new PositionClearer());
+    return true;
+}
+class PositionClearer extends NodeVisitor {
+    visitNode(node) {
+        clearPositions(node);
+        return false;
+    }
+}
+function stripBindingInitializers(pattern) {
+    for (const element of pattern.elements.nodes) {
+        if (!(element instanceof BindingElement))
+            continue;
+        element.initializer = undefined;
+        if (element.name instanceof BindingPattern)
+            stripBindingInitializers(element.name);
+    }
+    return true;
+}
+function appendUnionMember(result, node) {
+    if (node instanceof UnionTypeNode) {
+        for (const member of node.types.nodes)
+            appendUnionMember(result, member);
+        return true;
+    }
+    if (node.kind === 157 /* SyntaxKind.UndefinedKeyword */)
+        for (const existing of result)
+            if (existing.kind === 157 /* SyntaxKind.UndefinedKeyword */)
+                return false;
+    result.push(node);
+    return true;
+}
+function classifyPropertyName(name, stringNamed, isMethod) {
+    if (isMethod && name === 'new')
+        return 2 /* PropertyNameKind.StringLiteral */;
+    if (isIdentifierText(name))
+        return 0 /* PropertyNameKind.Identifier */;
+    return !stringNamed && String(Number(name)) === name && Number(name) >= 0
+        ? 1 /* PropertyNameKind.NumericLiteral */
+        : 2 /* PropertyNameKind.StringLiteral */;
+}
+export function tryGetTextOfPropertyName(name) {
+    switch (name.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            return literalText(name);
+        case 168 /* SyntaxKind.ComputedPropertyName */: {
+            const expression = name.expression;
+            return isStringOrNumericLiteralLike(expression) ? literalText(expression) : undefined;
+        }
+    }
+    return undefined;
+}
+/** Whether a declaration's type is a literal or `unique symbol`: a computed name it names is late-bound. */
+function hasLiteralOrUniqueSymbolType(declaration) {
+    if (declaration.kind === 306 /* SyntaxKind.EnumMember */)
+        return true;
+    const type = getType(declaration);
+    if (type !== undefined)
+        return ((type instanceof TypeOperatorNode && type.operator === 158 /* SyntaxKind.UniqueKeyword */) ||
+            type.kind === 202 /* SyntaxKind.LiteralType */);
+    const initializer = getInitializer(declaration);
+    if (initializer === undefined)
+        return false;
+    const value = skipParentheses(initializer);
+    // `x as const` has a literal type wherever it is.
+    if (value instanceof AsExpression && isConstTypeReference(value.type))
+        return isStringOrNumericLiteralLike(skipParentheses(value.expression));
+    if (declaration instanceof VariableDeclaration) {
+        if ((getCombinedNodeFlags(declaration) & 2 /* NodeFlags.Const */) === 0)
+            return false;
+        // `const sym = Symbol()` is a unique symbol.
+        if (value.kind === 214 /* SyntaxKind.CallExpression */ && isIdentifierNamed(getExpression(value), 'Symbol'))
+            return true;
+        return isStringOrNumericLiteralLike(value);
+    }
+    if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+        return hasSyntacticModifier(declaration, 8 /* ModifierFlags.Readonly */) && isStringOrNumericLiteralLike(value);
+    if (declaration.kind === 303 /* SyntaxKind.PropertyAssignment */)
+        return isInConstContext(value) && isStringOrNumericLiteralLike(value);
+    return false;
+}
+/** The properties of an object literal, through `as const`. */
+function objectLiteralProperties(node) {
+    let current = skipParentheses(node);
+    if (current instanceof AsExpression && isConstTypeReference(current.type))
+        current = skipParentheses(current.expression);
+    return current instanceof ObjectLiteralExpression ? current.properties.nodes : [];
+}
+/** Whether a function's body returns no values, so its inferred return type is `void`. */
+function isTriviallyVoid(fn) {
+    const body = getBody(fn);
+    if (body === undefined || body.kind !== 242 /* SyntaxKind.Block */)
+        return false;
+    if (hasSyntacticModifier(fn, 1024 /* ModifierFlags.Async */) || getAsteriskToken(fn) !== undefined)
+        return false;
+    for (const statement of collectReturnStatements(body))
+        if (statement.expression !== undefined)
+            return false;
+    switch (fn.kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            return true;
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+            // Without an implicit return, function expressions return `never`.
+            return (fn.flags & 256 /* NodeFlags.HasImplicitReturn */) !== 0;
+    }
+    return false;
+}
+function createNumberExpression(context, value) {
+    const factory = context.factory;
+    if (value !== value)
+        return factory.createIdentifier('NaN');
+    if (value === Infinity)
+        return factory.createIdentifier('Infinity');
+    if (value === -Infinity)
+        return factory.created(new PrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, factory.createIdentifier('Infinity')));
+    if (value < 0)
+        return factory.created(new PrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, factory.createNumericLiteral(String(-value))));
+    return factory.createNumericLiteral(String(value));
+}
+/** The literal a const declaration's initializer is, if it has a literal type. */
+function literalOf(node) {
+    switch (node.kind) {
+        case 111 /* SyntaxKind.TrueKeyword */:
+        case 96 /* SyntaxKind.FalseKeyword */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            return node;
+        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            const unary = node;
+            const operand = unary.operand.kind;
+            if (unary.operator === 40 /* SyntaxKind.MinusToken */ &&
+                (operand === 8 /* SyntaxKind.NumericLiteral */ || operand === 9 /* SyntaxKind.BigIntLiteral */))
+                return node;
+            if (unary.operator === 39 /* SyntaxKind.PlusToken */ && operand === 8 /* SyntaxKind.NumericLiteral */)
+                return node;
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function literalText(node) {
+    if (node instanceof Identifier)
+        return node.text;
+    if (node instanceof PrivateIdentifier)
+        return node.text;
+    if (node instanceof StringLiteral)
+        return node.text;
+    if (node instanceof NumericLiteral)
+        return node.text;
+    if (node instanceof NoSubstitutionTemplateLiteral)
+        return node.text;
+    if (node instanceof BigIntLiteral)
+        return node.text;
+    if (node instanceof TemplateMiddle)
+        return node.text;
+    if (node instanceof TemplateTail)
+        return node.text;
+    return '';
+}
+function getIdentifierText(node) {
+    return node instanceof Identifier ? node.text : '';
+}
+function getFirstIdentifier(node) {
+    let current = node;
+    for (;;) {
+        if (current instanceof QualifiedName)
+            current = current.left;
+        else if (current instanceof PropertyAccessExpression)
+            current = current.expression;
+        else
+            return current;
+    }
+}
+/** What a reference to an entity name means: a value, a namespace or a type. */
+export function getMeaningOfEntityNameReference(entityName) {
+    const parent = entityName.parent;
+    if (parent.kind === 187 /* SyntaxKind.TypeQuery */ ||
+        (parent.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */ && !isPartOfTypeNode(parent)) ||
+        parent.kind === 168 /* SyntaxKind.ComputedPropertyName */ ||
+        (parent.kind === 183 /* SyntaxKind.TypePredicate */ && getTypePredicateParameterName(parent) === entityName) ||
+        parent.kind === 227 /* SyntaxKind.BinaryExpression */)
+        return 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */;
+    if (entityName.kind === 167 /* SyntaxKind.QualifiedName */ ||
+        entityName.kind === 212 /* SyntaxKind.PropertyAccessExpression */ ||
+        parent.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ ||
+        (parent instanceof QualifiedName && parent.left === entityName) ||
+        (parent instanceof PropertyAccessExpression && parent.expression === entityName) ||
+        (parent instanceof ElementAccessExpression && parent.expression === entityName))
+        return 1920 /* SymbolFlags.Namespace */;
+    return 788968 /* SymbolFlags.Type */;
+}
+function getTypePredicateParameterName(node) {
+    return node instanceof TypePredicateNode ? node.parameterName : undefined;
+}
+/** Whether a heritage clause element is a type: an interface's `extends` or a class's `implements`. */
+function isPartOfTypeNode(node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return false;
+    if (parent instanceof HeritageClause)
+        return (!(parent.parent.kind === 264 /* SyntaxKind.ClassDeclaration */ || parent.parent.kind === 232 /* SyntaxKind.ClassExpression */) ||
+            parent.token === 118 /* SyntaxKind.ImplementsKeyword */);
+    return (parent !== undefined &&
+        (parent.kind === 324 /* SyntaxKind.JSDocImplementsTag */ || parent.kind === 323 /* SyntaxKind.JSDocAugmentsTag */));
+}
+function isDeclarationKind(kind) {
+    switch (kind) {
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 170 /* SyntaxKind.Parameter */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 209 /* SyntaxKind.BindingElement */:
+        case 278 /* SyntaxKind.ExportAssignment */:
+        case 306 /* SyntaxKind.EnumMember */:
+            return true;
+    }
+    return false;
+}
+export function getAnyImportSyntax(node) {
+    switch (node.kind) {
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            return node;
+        case 274 /* SyntaxKind.ImportClause */:
+            return node.parent;
+        case 275 /* SyntaxKind.NamespaceImport */:
+            return node.parent?.parent;
+        case 277 /* SyntaxKind.ImportSpecifier */:
+            return node.parent?.parent?.parent;
+    }
+    return undefined;
+}
+export function isLateVisibilityPaintedStatement(node) {
+    switch (node.kind) {
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 244 /* SyntaxKind.VariableStatement */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+            return true;
+    }
+    return false;
+}
+/** The node whose scope holds a declaration: a source file, module block or other container. */
+export function getDeclarationContainer(node) {
+    let current = getRootDeclaration(node);
+    while (current !== undefined) {
+        switch (current.kind) {
+            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclarationList */:
+            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 276 /* SyntaxKind.NamedImports */:
+            case 275 /* SyntaxKind.NamespaceImport */:
+            case 274 /* SyntaxKind.ImportClause */:
+                current = current.parent;
+                continue;
+        }
+        return current.parent;
+    }
+    throw new Error('A declaration has no container');
+}
+function getEnclosingContainer(node) {
+    for (let current = node.parent; current !== undefined; current = current.parent)
+        if ((getContainerFlags(current) & 1 /* ContainerFlags.IsContainer */) !== 0)
+            return current;
+    return undefined;
+}
+function isGlobalScopeAugmentation(node) {
+    return node instanceof ModuleDeclaration && node.keyword === 162 /* SyntaxKind.GlobalKeyword */;
+}
+export function isExternalModuleAugmentation(node) {
+    return isAmbientModule(node) && isModuleAugmentationExternal(node);
+}
+function isImplicitlyExportedJSDocDeclaration(node) {
+    const parent = node.parent;
+    if (parent === undefined || parent.kind !== 307 /* SyntaxKind.SourceFile */)
+        return false;
+    if (!isExternalOrCommonJSModule(parent))
+        return false;
+    if (node.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+        return true;
+    return node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && (node.flags & 8 /* NodeFlags.Reparsed */) !== 0;
+}
+/** Merges global symbol tables as the checker does; conflicting declarations stay apart. */
+function mergeInto(target, source, mergedSymbols) {
+    for (const [name, symbol] of source) {
+        const existing = target.get(name);
+        if (existing === undefined) {
+            target.set(name, symbol);
+            continue;
+        }
+        if ((existing.flags & getExcludedSymbolFlags(symbol.flags)) !== 0 &&
+            ((existing.flags | symbol.flags) & 67108864 /* SymbolFlags.Assignment */) === 0)
+            continue;
+        let merged = existing;
+        if (mergedSymbols.get(existing) !== existing) {
+            // The first merge replaces the first file's symbol with a copy.
+            merged = new Symbol(existing.flags, name);
+            merged.declarations = existing.declarations.slice();
+            merged.valueDeclaration = existing.valueDeclaration;
+            merged.exports = copyTable(existing.exports);
+            merged.members = copyTable(existing.members);
+            mergedSymbols.set(existing, merged);
+            mergedSymbols.set(merged, merged);
+            target.set(name, merged);
+        }
+        merged.flags |= symbol.flags;
+        for (const declaration of symbol.declarations)
+            addDeclaration(merged, declaration);
+        merged.valueDeclaration ??= symbol.valueDeclaration;
+        if (symbol.exports !== undefined) {
+            merged.exports ??= new Map();
+            mergeInto(merged.exports, symbol.exports, mergedSymbols);
+        }
+        if (symbol.members !== undefined) {
+            merged.members ??= new Map();
+            mergeInto(merged.members, symbol.members, mergedSymbols);
+        }
+        mergedSymbols.set(symbol, merged);
+    }
+    return true;
+}
+function copyTable(table) {
+    return table === undefined ? undefined : new Map(table);
+}
+/** The flags a declaration with `flags` conflicts with. */
+function getExcludedSymbolFlags(flags) {
+    let result = 0 /* SymbolFlags.None */;
+    if ((flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0)
+        result |= 111551 /* SymbolFlags.BlockScopedVariableExcludes */;
+    if ((flags & 1 /* SymbolFlags.FunctionScopedVariable */) !== 0)
+        result |= 111550 /* SymbolFlags.FunctionScopedVariableExcludes */;
+    if ((flags & 4 /* SymbolFlags.Property */) !== 0)
+        result |= 13243 /* SymbolFlags.PropertyExcludes */;
+    if ((flags & 8 /* SymbolFlags.EnumMember */) !== 0)
+        result |= 900095 /* SymbolFlags.EnumMemberExcludes */;
+    if ((flags & 16 /* SymbolFlags.Function */) !== 0)
+        result |= 110991 /* SymbolFlags.FunctionExcludes */;
+    if ((flags & 32 /* SymbolFlags.Class */) !== 0)
+        result |= 899503 /* SymbolFlags.ClassExcludes */;
+    if ((flags & 64 /* SymbolFlags.Interface */) !== 0)
+        result |= 788872 /* SymbolFlags.InterfaceExcludes */;
+    if ((flags & 256 /* SymbolFlags.RegularEnum */) !== 0)
+        result |= 899327 /* SymbolFlags.RegularEnumExcludes */;
+    if ((flags & 128 /* SymbolFlags.ConstEnum */) !== 0)
+        result |= 899967 /* SymbolFlags.ConstEnumExcludes */;
+    if ((flags & 512 /* SymbolFlags.ValueModule */) !== 0)
+        result |= 110735 /* SymbolFlags.ValueModuleExcludes */;
+    if ((flags & 8192 /* SymbolFlags.Method */) !== 0)
+        result |= 103359 /* SymbolFlags.MethodExcludes */;
+    if ((flags & 32768 /* SymbolFlags.GetAccessor */) !== 0)
+        result |= 46011 /* SymbolFlags.GetAccessorExcludes */;
+    if ((flags & 65536 /* SymbolFlags.SetAccessor */) !== 0)
+        result |= 78779 /* SymbolFlags.SetAccessorExcludes */;
+    if ((flags & 262144 /* SymbolFlags.TypeParameter */) !== 0)
+        result |= 526824 /* SymbolFlags.TypeParameterExcludes */;
+    if ((flags & 524288 /* SymbolFlags.TypeAlias */) !== 0)
+        result |= 788968 /* SymbolFlags.TypeAliasExcludes */;
+    if ((flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+        result |= 2097152 /* SymbolFlags.AliasExcludes */;
+    return result;
+}
+class AliasMarker extends NodeVisitor {
+    resolver;
+    constructor(resolver) {
+        super();
+        this.resolver = resolver;
+    }
+    visitNode(node) {
+        switch (node.kind) {
+            case 278 /* SyntaxKind.ExportAssignment */: {
+                const expression = getExpression(node);
+                if (expression instanceof Identifier)
+                    this.resolver.markLinkedAliases(expression);
+                return false;
+            }
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                if (node instanceof ExportSpecifier)
+                    this.resolver.markLinkedAliases(node.propertyName ?? node.name);
+                return false;
+            // Exports are statements of files and namespaces.
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleBlock */:
+            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.NamedExports */:
+                return node.forEachChild(this);
+        }
+        return false;
+    }
+}