tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/transformers/reference-resolver.js

@@ -0,0 +1,1155 @@
+// Name resolution for emit without a checker: which declaration an identifier refers to, the
+// container exporting it, and constant values of enum members, from the binder's symbols with
+// global declarations merged across script files and imports resolved between program files.
+import { ElementAccessExpression, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, Identifier, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ModuleDeclaration, NamespaceImport, NumericLiteral, ParenthesizedExpression, PrefixUnaryExpression, PropertyAccessExpression, QualifiedName, SourceFile, BinaryExpression, NoSubstitutionTemplateLiteral, StringLiteral, TemplateExpression, TemplateMiddle, TemplateSpan, TemplateTail, VariableDeclaration, ExternalModuleReference, getInitializer, getIsTypeOnly, getModuleSpecifier, getLocals, getName, getSymbol, getType, } from '../ast.js';
+import { isFunctionLike } from '../ast-utilities.js';
+import { getCombinedNodeFlags, getRootDeclaration, getSourceFileOfNode, isEnumConst, isExternalOrCommonJSModule, } from '../binder-utilities.js';
+import { NameResolver } from '../name-resolver.js';
+import { isSameNode } from './utilities.js';
+import { pathIsRelative } from '../path.js';
+import { shouldPreserveConstEnums } from '../options.js';
+import { Symbol, addDeclaration } from '../symbol.js';
+/** The result of evaluating a constant expression, as the checker's evaluator returns it. */
+export class Evaluation {
+    kind;
+    number;
+    string;
+    isSyntacticallyString;
+    resolvedOtherFiles;
+    hasExternalReferences;
+    constructor(kind, numberValue, stringValue, isSyntacticallyString, resolvedOtherFiles, hasExternalReferences) {
+        this.kind = kind;
+        this.number = numberValue;
+        this.string = stringValue;
+        this.isSyntacticallyString = isSyntacticallyString;
+        this.resolvedOtherFiles = resolvedOtherFiles;
+        this.hasExternalReferences = hasExternalReferences;
+    }
+    /** The value as a string, as `+` concatenates it. */
+    text() {
+        return this.kind === 2 /* ConstantKind.String */ ? this.string : String(this.number);
+    }
+    withFlags(isSyntacticallyString, resolvedOtherFiles, hasExternalReferences) {
+        return new Evaluation(this.kind, this.number, this.string, isSyntacticallyString, resolvedOtherFiles, hasExternalReferences);
+    }
+}
+export function numberEvaluation(value) {
+    return new Evaluation(1 /* ConstantKind.Number */, value, '', false, false, false);
+}
+export function stringEvaluation(value, isSyntacticallyString) {
+    return new Evaluation(2 /* ConstantKind.String */, 0, value, isSyntacticallyString, false, false);
+}
+export const noEvaluation = new Evaluation(0 /* ConstantKind.None */, 0, '', false, false, false);
+function noValue(isSyntacticallyString, resolvedOtherFiles, hasExternalReferences) {
+    return new Evaluation(0 /* ConstantKind.None */, 0, '', isSyntacticallyString, resolvedOtherFiles, hasExternalReferences);
+}
+/** Finds the program file a module specifier names. */
+export class ModuleLookup {
+}
+class NoModules extends ModuleLookup {
+    resolveModule(_location, _file, _specifier) {
+        return undefined;
+    }
+}
+/** The global symbol table, with declarations of script files merged as the checker merges them. */
+export class MergedGlobals {
+    table;
+    merged;
+    aliases;
+    constructor() {
+        this.table = new Map();
+        this.merged = new Map();
+        this.aliases = undefined;
+    }
+    /** Merges the globals of `files`, resolving aliases they merge with through `aliases`. */
+    merge(files, aliases) {
+        this.aliases = aliases;
+        this.mergeFiles(files);
+        // Aliases are resolved only while merging: resolvers of other threads can share the tables.
+        this.aliases = undefined;
+        return true;
+    }
+    mergeFiles(files) {
+        for (const file of files) {
+            if (isExternalOrCommonJSModule(file))
+                continue;
+            const locals = getLocals(file);
+            if (locals !== undefined)
+                this.mergeTable(this.table, locals, undefined);
+        }
+        for (const file of files) {
+            for (const augmentation of file.moduleAugmentations) {
+                const declaration = augmentation.parent;
+                if (!(declaration instanceof ModuleDeclaration) || declaration.keyword !== 162 /* SyntaxKind.GlobalKeyword */)
+                    continue;
+                const symbol = getSymbol(declaration);
+                if (symbol !== undefined && symbol.exports !== undefined)
+                    this.mergeTable(this.table, symbol.exports, undefined);
+            }
+        }
+        return true;
+    }
+    getMergedSymbol(symbol) {
+        const merged = this.merged.get(symbol);
+        return merged !== undefined ? merged : symbol;
+    }
+    mergeTable(target, source, parent) {
+        for (const [name, sourceSymbol] of source) {
+            const targetSymbol = target.get(name);
+            if (targetSymbol === undefined) {
+                target.set(name, this.getMergedSymbol(sourceSymbol));
+                continue;
+            }
+            const merged = this.mergeSymbol(targetSymbol, sourceSymbol);
+            if (parent !== undefined && (merged.flags & 33554432 /* SymbolFlags.Transient */) !== 0)
+                merged.parent = parent;
+            target.set(name, merged);
+        }
+        return true;
+    }
+    mergeSymbol(target, source) {
+        if ((target.flags & excludedSymbolFlags(source.flags)) !== 0 &&
+            ((source.flags | target.flags) & 67108864 /* SymbolFlags.Assignment */) === 0)
+            return target;
+        if (source === target)
+            return target;
+        let result = target;
+        if ((target.flags & 33554432 /* SymbolFlags.Transient */) === 0) {
+            // Like the checker, an alias merges by its target: the merge clones what it resolves to.
+            let resolved = target;
+            if ((target.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && this.aliases !== undefined)
+                resolved = this.aliases.resolveAlias(target);
+            if (resolved === undefined)
+                return source;
+            // A conflict with what an alias resolves to replaces the alias.
+            if ((resolved.flags & excludedSymbolFlags(source.flags)) !== 0 &&
+                ((source.flags | resolved.flags) & 67108864 /* SymbolFlags.Assignment */) === 0)
+                return source;
+            result = new Symbol(resolved.flags | 33554432 /* SymbolFlags.Transient */, resolved.name);
+            result.declarations = resolved.declarations.slice();
+            result.parent = resolved.parent;
+            result.valueDeclaration = resolved.valueDeclaration;
+            result.members = resolved.members === undefined ? undefined : new Map(resolved.members);
+            result.exports = resolved.exports === undefined ? undefined : new Map(resolved.exports);
+            this.merged.set(resolved, result);
+        }
+        if ((source.flags & 512 /* SymbolFlags.ValueModule */) !== 0 &&
+            (result.flags & 512 /* SymbolFlags.ValueModule */) !== 0 &&
+            (result.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) !== 0 &&
+            (source.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) === 0)
+            result.flags &= ~268435456 /* SymbolFlags.ConstEnumOnlyModule */;
+        let sourceFlags = source.flags;
+        if ((result.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) === 0)
+            sourceFlags &= ~268435456 /* SymbolFlags.ConstEnumOnlyModule */;
+        result.flags |= sourceFlags;
+        if (source.valueDeclaration !== undefined)
+            setValueDeclaration(result, source.valueDeclaration);
+        for (let i = 0; i < source.declarations.length; i++)
+            addDeclaration(result, source.declarations[i]);
+        if (source.members !== undefined) {
+            if (result.members === undefined)
+                result.members = new Map();
+            this.mergeTable(result.members, source.members, undefined);
+        }
+        if (source.exports !== undefined) {
+            if (result.exports === undefined)
+                result.exports = new Map();
+            this.mergeTable(result.exports, source.exports, result);
+        }
+        this.merged.set(source, result);
+        return result;
+    }
+}
+function setValueDeclaration(symbol, node) {
+    const current = symbol.valueDeclaration;
+    if (current === undefined ||
+        (!((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && (current.flags & 8388608 /* NodeFlags.Ambient */) === 0) &&
+            current.kind !== node.kind &&
+            current.kind === 268 /* SyntaxKind.ModuleDeclaration */))
+        symbol.valueDeclaration = node;
+    return true;
+}
+function excludedSymbolFlags(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;
+}
+/** Resolves names against merged symbols. */
+class MergedNameResolver extends NameResolver {
+    merged;
+    aliases;
+    constructor(options, merged) {
+        super(options);
+        this.merged = merged;
+        this.globals = merged.table;
+        this.aliases = undefined;
+    }
+    getSymbolOfDeclaration(node) {
+        const symbol = getSymbol(node);
+        return symbol === undefined ? undefined : this.merged.getMergedSymbol(symbol);
+    }
+    /** As the checker: an alias has the meanings of what it resolves to. */
+    lookup(symbols, name, meaning) {
+        if (meaning === 0 /* SymbolFlags.None */)
+            return undefined;
+        const symbol = symbols.get(name);
+        if (symbol === undefined)
+            return undefined;
+        if ((symbol.flags & meaning) !== 0)
+            return symbol;
+        const aliases = this.aliases;
+        if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && aliases !== undefined)
+            return (aliases.getSymbolFlags(symbol, false, false) & meaning) !== 0 ? symbol : undefined;
+        return undefined;
+    }
+}
+const valueMeaning = 1048576 /* SymbolFlags.ExportValue */ | 111551 /* SymbolFlags.Value */ | 2097152 /* SymbolFlags.Alias */;
+const maxAliasDepth = 64;
+export class ReferenceResolver {
+    options;
+    merged;
+    names;
+    modules;
+    enumValues;
+    computedEnums;
+    aliasTargets;
+    /** Value symbols of identifiers resolved as expressions, as the checker caches them. */
+    resolvedSymbols;
+    unresolvedReferences;
+    unresolvedAliases;
+    resolvingAliases;
+    /** The module each module specifier names (`null` for none), by specifier. */
+    specifierModules;
+    /** Results of `isTypeOnlyAliasChain`, for queries outside alias resolution. */
+    typeOnlyChains;
+    /** With `merged`, the globals of `files` as another resolver merged them (`EmitIndexes`), not merged again. */
+    constructor(options, files, modules, merged = undefined) {
+        this.options = options;
+        this.merged = merged !== undefined ? merged : new MergedGlobals();
+        this.names = new MergedNameResolver(options, this.merged);
+        this.modules = modules !== undefined ? modules : new NoModules();
+        this.enumValues = new Map();
+        this.computedEnums = new Set();
+        this.aliasTargets = new Map();
+        this.resolvedSymbols = new Map();
+        this.unresolvedReferences = new Set();
+        this.unresolvedAliases = new Set();
+        this.resolvingAliases = new Set();
+        this.specifierModules = new Map();
+        this.typeOnlyChains = new Map();
+        this.names.aliases = this;
+        if (merged === undefined)
+            this.merged.merge(files, this);
+    }
+    getMergedSymbol(symbol) {
+        return this.merged.getMergedSymbol(symbol);
+    }
+    getSymbolOfDeclaration(node) {
+        return this.names.getSymbolOfDeclaration(node);
+    }
+    resolveName(location, name, meaning) {
+        return this.names.resolve(location, name, meaning, undefined, false, false);
+    }
+    /** The value an identifier in an expression refers to, cached for later queries of the identifier. */
+    getResolvedSymbol(node) {
+        const cached = this.resolvedSymbols.get(node);
+        if (cached !== undefined)
+            return cached;
+        if (this.unresolvedReferences.has(node))
+            return undefined;
+        const symbol = this.resolveName(node, node.text, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */);
+        if (symbol === undefined)
+            this.unresolvedReferences.add(node);
+        else
+            this.resolvedSymbols.set(node, symbol);
+        return symbol;
+    }
+    getReferencedValueSymbol(reference, startInDeclarationContainer) {
+        // An identifier resolved as an expression keeps that meaning, as with the checker's cache.
+        const cached = this.resolvedSymbols.get(reference);
+        if (cached !== undefined)
+            return cached;
+        if (this.unresolvedReferences.has(reference))
+            return undefined;
+        let location = reference;
+        const parent = reference.parent;
+        if (startInDeclarationContainer && parent !== undefined && isSameNode(getName(parent), reference)) {
+            const container = getDeclarationContainer(parent);
+            if (container !== undefined)
+                location = container;
+        }
+        return this.resolveName(location, reference.text, valueMeaning);
+    }
+    getParentOfSymbol(symbol) {
+        const parent = symbol.parent;
+        return parent === undefined ? undefined : this.getMergedSymbol(parent);
+    }
+    getExportSymbolOfValueSymbolIfExported(symbol) {
+        const exportSymbol = symbol.exportSymbol;
+        if ((symbol.flags & 1048576 /* SymbolFlags.ExportValue */) !== 0 && exportSymbol !== undefined)
+            return this.getMergedSymbol(exportSymbol);
+        return this.getMergedSymbol(symbol);
+    }
+    /** The source file, namespace or enum whose export `node` refers to, if it refers to an export. */
+    getReferencedExportContainer(node, prefixLocals) {
+        const parent = node.parent;
+        const startInDeclarationContainer = parent !== undefined &&
+            (parent.kind === 268 /* SyntaxKind.ModuleDeclaration */ || parent.kind === 267 /* SyntaxKind.EnumDeclaration */) &&
+            isSameNode(getName(parent), node);
+        let symbol = this.getReferencedValueSymbol(node, startInDeclarationContainer);
+        if (symbol === undefined)
+            return undefined;
+        if ((symbol.flags & 1048576 /* SymbolFlags.ExportValue */) !== 0) {
+            const local = symbol.exportSymbol;
+            if (local === undefined)
+                return undefined;
+            const exportSymbol = this.getMergedSymbol(local);
+            if (!prefixLocals &&
+                (exportSymbol.flags & 944 /* SymbolFlags.ExportHasLocal */) !== 0 &&
+                (exportSymbol.flags & 3 /* SymbolFlags.Variable */) === 0)
+                return undefined;
+            symbol = exportSymbol;
+        }
+        const parentSymbol = this.getParentOfSymbol(symbol);
+        if (parentSymbol === undefined)
+            return undefined;
+        const valueDeclaration = parentSymbol.valueDeclaration;
+        if ((parentSymbol.flags & 512 /* SymbolFlags.ValueModule */) !== 0 &&
+            valueDeclaration !== undefined &&
+            valueDeclaration.kind === 307 /* SyntaxKind.SourceFile */)
+            return valueDeclaration === getSourceFileOfNode(node) ? valueDeclaration : undefined;
+        for (let current = node.parent; current !== undefined; current = current.parent) {
+            if ((current.kind === 268 /* SyntaxKind.ModuleDeclaration */ || current.kind === 267 /* SyntaxKind.EnumDeclaration */) &&
+                this.getSymbolOfDeclaration(current) === parentSymbol)
+                return current;
+        }
+        return undefined;
+    }
+    /** The import declaring the alias `node` refers to, unless a local value shadows it. */
+    getReferencedImportDeclaration(node) {
+        // As the checker: an identifier that didn't resolve as a value may still name an alias.
+        const reference = node;
+        let symbol = this.resolvedSymbols.get(reference);
+        if (symbol === undefined)
+            symbol = this.resolveName(node, node.text, valueMeaning);
+        if (symbol === undefined ||
+            !isNonLocalAlias(symbol, 111551 /* SymbolFlags.Value */) ||
+            this.getTypeOnlyAliasDeclarationFor(symbol, 111551 /* SymbolFlags.Value */))
+            return undefined;
+        return getDeclarationOfAliasSymbol(symbol);
+    }
+    /** Whether an alias reaches a type-only declaration before a symbol with `meaning`. */
+    getTypeOnlyAliasDeclarationFor(symbol, meaning) {
+        let current = symbol;
+        for (let depth = 0; depth < maxAliasDepth; depth++) {
+            if ((current.flags & 2097152 /* SymbolFlags.Alias */) === 0 || (current.flags & meaning) !== 0)
+                return false;
+            const resolved = this.resolveAlias(current);
+            if (this.isTypeOnlyAliasChain(current))
+                return true;
+            if (resolved === undefined || resolved === current)
+                return false;
+            current = resolved;
+        }
+        return false;
+    }
+    getReferencedValueDeclaration(node) {
+        const symbol = this.getReferencedValueSymbol(node, false);
+        return symbol === undefined ? undefined : this.getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
+    }
+    getReferencedValueDeclarations(node) {
+        const resolved = this.getReferencedValueSymbol(node, false);
+        if (resolved === undefined)
+            return undefined;
+        const symbol = this.getExportSymbolOfValueSymbolIfExported(resolved);
+        const declarations = [];
+        for (const declaration of symbol.declarations)
+            if (isValueDeclarationKind(declaration.kind))
+                declarations.push(declaration);
+        return declarations;
+    }
+    // Aliases
+    /** The export `name` of a namespace, enum or module. */
+    getExportOfSymbol(symbol, name) {
+        const declaration = symbol.valueDeclaration;
+        if (declaration instanceof SourceFile)
+            return this.getExportOfModule(symbol, name);
+        const exports = symbol.exports;
+        const member = exports === undefined ? undefined : exports.get(name);
+        return member === undefined ? undefined : this.getMergedSymbol(member);
+    }
+    isTypeOnlyAliasSymbol(symbol) {
+        return this.isTypeOnlyAlias(symbol);
+    }
+    /** Whether an alias is declared type-only; as in the checker, a default import counts only if its module resolves. */
+    isTypeOnlyAlias(symbol) {
+        const declaration = getDeclarationOfAliasSymbol(symbol);
+        if (declaration instanceof ImportClause) {
+            const importDeclaration = declaration.parent;
+            if (importDeclaration === undefined ||
+                this.resolveModuleSpecifier(declaration, getModuleSpecifierOf(importDeclaration)) === undefined)
+                return false;
+        }
+        if (isTypeOnlyAlias(symbol))
+            return true;
+        // An import found through `export type * from`.
+        if (declaration === undefined)
+            return false;
+        const imported = importedNameOf(declaration);
+        const moduleDeclaration = moduleDeclarationOfSpecifier(declaration);
+        if (imported === undefined || moduleDeclaration === undefined)
+            return false;
+        const moduleSymbol = this.resolveModuleSpecifier(declaration, getModuleSpecifierOf(moduleDeclaration));
+        return moduleSymbol !== undefined && this.isExportedThroughTypeOnlyStar(moduleSymbol, imported, new Set());
+    }
+    /** Whether a module's export `name` comes from another module through an `export type *` on the way. */
+    isExportedThroughTypeOnlyStar(moduleSymbol, name, visited) {
+        if (visited.has(moduleSymbol))
+            return false;
+        visited.add(moduleSymbol);
+        const exports = moduleSymbol.exports;
+        if (exports === undefined || exports.has(name) || name === "default" /* InternalSymbolName.Default */)
+            return false;
+        const star = exports.get("\uFFFEexport" /* InternalSymbolName.ExportStar */);
+        if (star === undefined)
+            return false;
+        for (const declaration of star.declarations) {
+            if (!(declaration instanceof ExportDeclaration))
+                continue;
+            const target = this.resolveExternalModuleSymbol(this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier));
+            if (target === undefined || this.getExportFromTable(target, name, new Set()) === undefined)
+                continue;
+            return declaration.isTypeOnly || this.isExportedThroughTypeOnlyStar(target, name, visited);
+        }
+        return false;
+    }
+    /** Whether a symbol is declared in the global scope. */
+    isGlobalSymbol(symbol) {
+        if (symbol.declarations.length === 0)
+            return false;
+        const container = getDeclarationContainer(symbol.declarations[0]);
+        return container instanceof SourceFile && !isExternalOrCommonJSModule(container);
+    }
+    /** Whether a symbol is a value at runtime: const enums aren't unless preserved. */
+    isValueSymbol(symbol) {
+        return ((symbol.flags & 111551 /* SymbolFlags.Value */) !== 0 &&
+            (shouldPreserveConstEnums(this.options) ||
+                ((symbol.flags & 128 /* SymbolFlags.ConstEnum */) === 0 && (symbol.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) === 0)));
+    }
+    /** Whether an alias refers to a value, counting unresolved aliases as values; `excludeTypeOnly` stops at type-only imports. */
+    isAliasResolvedToValue(symbol, excludeTypeOnly) {
+        const resolved = this.resolveAlias(symbol);
+        if (resolved === undefined)
+            return !excludeTypeOnly || !this.isTypeOnlyAliasChain(symbol);
+        const target = this.getExportSymbolOfValueSymbolIfExported(resolved);
+        return ((this.getSymbolFlags(symbol, excludeTypeOnly, true) & 111551 /* SymbolFlags.Value */) !== 0 &&
+            (shouldPreserveConstEnums(this.options) ||
+                ((target.flags & 128 /* SymbolFlags.ConstEnum */) === 0 && (target.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) === 0)));
+    }
+    /**
+     * Whether an alias is type-only, itself or through the aliases it directly names. Cached unless an
+     * alias is being resolved, when the answer can depend on which.
+     */
+    isTypeOnlyAliasChain(symbol) {
+        if (this.resolvingAliases.size > 0)
+            return this.computeTypeOnlyAliasChain(symbol);
+        let result = this.typeOnlyChains.get(symbol);
+        if (result === undefined) {
+            result = this.computeTypeOnlyAliasChain(symbol);
+            this.typeOnlyChains.set(symbol, result);
+        }
+        return result;
+    }
+    computeTypeOnlyAliasChain(symbol) {
+        let current = symbol;
+        for (let depth = 0; depth < maxAliasDepth && (current.flags & 2097152 /* SymbolFlags.Alias */) !== 0; depth++) {
+            if (this.isTypeOnlyAlias(current))
+                return true;
+            const declaration = getDeclarationOfAliasSymbol(current);
+            const next = declaration === undefined ? undefined : this.getTargetOfAliasDeclaration(declaration);
+            // Only a pure alias passes on its type-only-ness.
+            if (next === undefined || !isPureAlias(next))
+                return false;
+            current = next;
+        }
+        return false;
+    }
+    /** The symbol an alias ultimately refers to, or undefined if it can't be resolved. */
+    resolveAlias(symbol) {
+        if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0)
+            return symbol;
+        const cached = this.aliasTargets.get(symbol);
+        if (cached !== undefined)
+            return cached;
+        if (this.unresolvedAliases.has(symbol) || this.resolvingAliases.has(symbol))
+            return undefined;
+        this.resolvingAliases.add(symbol);
+        const declaration = getDeclarationOfAliasSymbol(symbol);
+        const next = declaration === undefined ? undefined : this.getTargetOfAliasDeclaration(declaration);
+        // Only a pure alias is followed; one merged with other meanings is the target itself.
+        const target = next === undefined ? undefined : isPureAlias(next) ? this.resolveAlias(next) : next;
+        this.resolvingAliases.delete(symbol);
+        if (target === undefined)
+            this.unresolvedAliases.add(symbol);
+        else
+            this.aliasTargets.set(symbol, target);
+        return target;
+    }
+    /** The flags of a symbol and the aliases it resolves through; all flags for an unresolved alias. */
+    getSymbolFlags(start, excludeTypeOnly, excludeLocal) {
+        let symbol = start;
+        let flags = excludeLocal ? 0 /* SymbolFlags.None */ : symbol.flags;
+        const seen = new Set();
+        while ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+            if (excludeTypeOnly && this.isTypeOnlyAliasChain(symbol))
+                break;
+            const resolved = this.resolveAlias(symbol);
+            if (resolved === undefined)
+                return 1073741823 /* SymbolFlags.All */;
+            const target = this.getExportSymbolOfValueSymbolIfExported(resolved);
+            if ((target.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+                if (target === symbol || seen.has(target))
+                    break;
+                seen.add(symbol);
+                seen.add(target);
+            }
+            flags |= target.flags;
+            symbol = target;
+        }
+        return flags;
+    }
+    getTargetOfAliasDeclaration(node) {
+        if (node instanceof ImportEqualsDeclaration) {
+            const reference = node.moduleReference;
+            if (reference instanceof ExternalModuleReference)
+                return this.resolveExternalModuleSymbol(this.resolveModuleSpecifier(node, reference.expression));
+            // `import a = b` names a namespace; `import a = b.c` anything.
+            const meaning = reference instanceof Identifier
+                ? 1920 /* SymbolFlags.Namespace */
+                : 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */;
+            return this.resolveEntityName(reference, meaning, true);
+        }
+        if (node instanceof ImportClause) {
+            const declaration = node.parent;
+            if (declaration === undefined)
+                return undefined;
+            const moduleSymbol = this.resolveModuleSpecifier(node, getModuleSpecifierOf(declaration));
+            if (moduleSymbol === undefined)
+                return undefined;
+            const exported = this.getExportOfModule(moduleSymbol, "default" /* InternalSymbolName.Default */);
+            return exported !== undefined ? exported : this.resolveExternalModuleSymbol(moduleSymbol);
+        }
+        if (node instanceof NamespaceImport) {
+            const clause = node.parent;
+            const declaration = clause === undefined ? undefined : clause.parent;
+            if (declaration === undefined)
+                return undefined;
+            return this.resolveExternalModuleSymbol(this.resolveModuleSpecifier(node, getModuleSpecifierOf(declaration)));
+        }
+        if (node instanceof ImportSpecifier) {
+            const declaration = node.parent === undefined ? undefined : node.parent.parent;
+            const importDeclaration = declaration === undefined ? undefined : declaration.parent;
+            if (importDeclaration === undefined)
+                return undefined;
+            const moduleSymbol = this.resolveModuleSpecifier(node, getModuleSpecifierOf(importDeclaration));
+            if (moduleSymbol === undefined)
+                return undefined;
+            const name = node.propertyName !== undefined ? node.propertyName : node.name;
+            return this.getExportOfModule(moduleSymbol, moduleExportNameText(name));
+        }
+        if (node instanceof ExportSpecifier) {
+            const exportDeclaration = node.parent === undefined ? undefined : node.parent.parent;
+            const local = node.propertyName !== undefined ? node.propertyName : node.name;
+            if (exportDeclaration instanceof ExportDeclaration && exportDeclaration.moduleSpecifier !== undefined) {
+                const moduleSymbol = this.resolveModuleSpecifier(node, exportDeclaration.moduleSpecifier);
+                return moduleSymbol === undefined
+                    ? undefined
+                    : this.getExportOfModule(moduleSymbol, moduleExportNameText(local));
+            }
+            if (!(local instanceof Identifier))
+                return undefined;
+            return this.resolveName(local, local.text, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */);
+        }
+        if (node instanceof ExportAssignment) {
+            const expression = node.expression;
+            if (expression.kind === 79 /* SyntaxKind.Identifier */ || expression.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+                return this.resolveEntityName(expression, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, true);
+            return getSymbol(node);
+        }
+        return undefined;
+    }
+    /** The module an implicit import of `file`, such as the JSX runtime, refers to. */
+    resolveImplicitImport(file, name) {
+        const specifier = new StringLiteral(name, 0 /* TokenFlags.None */);
+        const declaration = new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, undefined, specifier, undefined);
+        specifier.parent = declaration;
+        declaration.parent = file;
+        return this.resolveModuleSpecifier(specifier, specifier);
+    }
+    /** The module `specifier` names; `location` is in the same file. */
+    resolveModuleSpecifier(location, specifier) {
+        if (specifier === undefined)
+            return undefined;
+        const cached = this.specifierModules.get(specifier);
+        if (cached !== undefined)
+            return cached === null ? undefined : cached;
+        const result = this.computeModuleOfSpecifier(location, specifier);
+        this.specifierModules.set(specifier, result === undefined ? null : result);
+        return result;
+    }
+    computeModuleOfSpecifier(location, specifier) {
+        const name = stringLiteralText(specifier);
+        if (name === undefined)
+            return undefined;
+        // Ambient modules, `declare module "m"`, come first for names that aren't relative.
+        if (!pathIsRelative(name)) {
+            const ambient = this.merged.table.get('"' + name + '"');
+            if (ambient !== undefined && (ambient.flags & 1536 /* SymbolFlags.Module */) !== 0)
+                return ambient;
+        }
+        const file = this.modules.resolveModule(specifier, getSourceFileOfNode(location), name);
+        if (file === undefined)
+            return undefined;
+        const symbol = getSymbol(file);
+        return symbol === undefined ? undefined : this.getMergedSymbol(symbol);
+    }
+    /** The `export =` target of a module, or the module itself. */
+    resolveExternalModuleSymbol(moduleSymbol) {
+        if (moduleSymbol === undefined || moduleSymbol.exports === undefined)
+            return moduleSymbol;
+        const exportEquals = moduleSymbol.exports.get("export=" /* InternalSymbolName.ExportEquals */);
+        if (exportEquals === undefined)
+            return moduleSymbol;
+        const resolved = this.resolveAlias(exportEquals);
+        return resolved !== undefined ? resolved : exportEquals;
+    }
+    getExportOfModule(moduleSymbol, name) {
+        const target = this.resolveExternalModuleSymbol(moduleSymbol);
+        if (target === undefined)
+            return undefined;
+        const visited = new Set();
+        return this.getExportFromTable(target, name, visited);
+    }
+    getExportFromTable(moduleSymbol, name, visited) {
+        if (visited.has(moduleSymbol))
+            return undefined;
+        visited.add(moduleSymbol);
+        const exports = moduleSymbol.exports;
+        if (exports === undefined)
+            return undefined;
+        // The export itself, an alias the caller resolves, so type-only exports pass on.
+        const direct = exports.get(name);
+        if (direct !== undefined)
+            return this.getMergedSymbol(direct);
+        if (name === "default" /* InternalSymbolName.Default */)
+            return undefined;
+        const star = exports.get("\uFFFEexport" /* InternalSymbolName.ExportStar */);
+        if (star === undefined)
+            return undefined;
+        for (const declaration of star.declarations) {
+            if (!(declaration instanceof ExportDeclaration))
+                continue;
+            const target = this.resolveExternalModuleSymbol(this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier));
+            if (target === undefined)
+                continue;
+            const found = this.getExportFromTable(target, name, visited);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    }
+    /** The symbol an identifier or dotted name refers to with `meaning`, through aliases unless `dontResolveAlias`. */
+    resolveEntityName(name, meaning, dontResolveAlias) {
+        let symbol;
+        if (name instanceof Identifier) {
+            const resolved = this.resolveName(name, name.text, meaning | 2097152 /* SymbolFlags.Alias */);
+            symbol = resolved === undefined ? undefined : this.getMergedSymbol(resolved);
+        }
+        else if (name.kind === 167 /* SyntaxKind.QualifiedName */ || name.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+            const left = entityNameLeft(name);
+            const right = entityNameRight(name);
+            if (left === undefined || !(right instanceof Identifier))
+                return undefined;
+            const namespace = this.resolveEntityName(left, 1920 /* SymbolFlags.Namespace */, false);
+            if (namespace === undefined)
+                return undefined;
+            const exports = namespace.exports;
+            let member = exports === undefined ? undefined : exports.get(right.text);
+            // A namespace merged with an alias also has the members of what the alias names, as its type does.
+            if (member === undefined && (namespace.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+                const target = this.resolveAlias(namespace);
+                const targetExports = target === undefined ? undefined : target.exports;
+                if (targetExports !== undefined)
+                    member = targetExports.get(right.text);
+            }
+            if (member === undefined || (member.flags & (meaning | 2097152 /* SymbolFlags.Alias */)) === 0)
+                return undefined;
+            symbol = this.getMergedSymbol(member);
+        }
+        else
+            return undefined;
+        if (symbol === undefined)
+            return undefined;
+        if (!dontResolveAlias && (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+            const target = this.resolveAlias(symbol);
+            return target === undefined ? undefined : this.getMergedSymbol(target);
+        }
+        return symbol;
+    }
+    // Constant values
+    /** The value of an enum member, computing the values of its whole declaration. */
+    getEnumMemberValue(member) {
+        const declaration = member.parent;
+        if (declaration instanceof EnumDeclaration)
+            this.computeEnumMemberValues(declaration);
+        const value = this.enumValues.get(member);
+        return value !== undefined ? value : noEvaluation;
+    }
+    /** The inlined value of a const enum member access such as `E.A` or `E["A"]`. */
+    getConstantValue(node) {
+        if (node instanceof EnumMember)
+            return this.getEnumMemberValue(node);
+        let symbol;
+        if (node instanceof PropertyAccessExpression) {
+            if (isEntityNameExpressionNode(node))
+                symbol = this.resolveEntityName(node, 111551 /* SymbolFlags.Value */, false);
+        }
+        else if (node instanceof ElementAccessExpression) {
+            const argument = stringLiteralText(node.argumentExpression);
+            if (isEntityNameExpressionNode(node.expression) && argument !== undefined) {
+                const root = this.resolveEntityName(node.expression, 111551 /* SymbolFlags.Value */, false);
+                const exports = root === undefined ? undefined : root.exports;
+                const member = exports === undefined ? undefined : exports.get(argument);
+                if (member !== undefined)
+                    symbol = this.getMergedSymbol(member);
+            }
+        }
+        if (symbol === undefined || (symbol.flags & 8 /* SymbolFlags.EnumMember */) === 0)
+            return noEvaluation;
+        const declaration = symbol.valueDeclaration;
+        if (declaration === undefined || declaration.parent === undefined || !isEnumConst(declaration.parent))
+            return noEvaluation;
+        return this.getEnumMemberValue(declaration);
+    }
+    computeEnumMemberValues(node) {
+        if (this.computedEnums.has(node))
+            return false;
+        this.computedEnums.add(node);
+        const members = node.members.nodes;
+        let hasAutoValue = true;
+        let autoValue = 0;
+        for (const member of members) {
+            let result = noEvaluation;
+            if (member instanceof EnumMember) {
+                if (member.initializer !== undefined)
+                    result = this.evaluate(member.initializer, member);
+                else if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && !isEnumConst(node))
+                    result = noEvaluation;
+                else if (hasAutoValue)
+                    result = numberEvaluation(autoValue);
+            }
+            this.enumValues.set(member, result);
+            hasAutoValue = result.kind === 1 /* ConstantKind.Number */;
+            if (hasAutoValue)
+                autoValue = result.number + 1;
+        }
+        return true;
+    }
+    /** Evaluates a constant expression at `location`, as the checker's evaluator does. */
+    evaluate(node, location) {
+        const expression = skipEvaluationParentheses(node);
+        if (expression instanceof PrefixUnaryExpression) {
+            const operand = this.evaluate(expression.operand, location);
+            if (operand.kind === 1 /* ConstantKind.Number */) {
+                const value = operand.number;
+                switch (expression.operator) {
+                    case 39 /* SyntaxKind.PlusToken */:
+                        return numberEvaluation(value).withFlags(false, operand.resolvedOtherFiles, operand.hasExternalReferences);
+                    case 40 /* SyntaxKind.MinusToken */:
+                        return numberEvaluation(-value).withFlags(false, operand.resolvedOtherFiles, operand.hasExternalReferences);
+                    case 54 /* SyntaxKind.TildeToken */:
+                        return numberEvaluation(~value).withFlags(false, operand.resolvedOtherFiles, operand.hasExternalReferences);
+                }
+            }
+            return noValue(false, operand.resolvedOtherFiles, operand.hasExternalReferences);
+        }
+        if (expression instanceof BinaryExpression)
+            return this.evaluateBinary(expression, location);
+        if (expression instanceof StringLiteral)
+            return stringEvaluation(expression.text, true);
+        if (expression instanceof NoSubstitutionTemplateLiteral)
+            return stringEvaluation(expression.text, true);
+        if (expression instanceof TemplateExpression)
+            return this.evaluateTemplate(expression, location);
+        if (expression instanceof NumericLiteral)
+            return numberEvaluation(Number(expression.text));
+        if (expression instanceof Identifier)
+            return this.evaluateEntity(expression, location);
+        if (expression instanceof PropertyAccessExpression) {
+            if (isEntityNameExpressionNode(expression.expression))
+                return this.evaluateEntity(expression, location);
+        }
+        else if (expression instanceof ElementAccessExpression) {
+            if (isEntityNameExpressionNode(expression.expression))
+                return this.evaluateEntity(expression, location);
+        }
+        return noEvaluation;
+    }
+    evaluateBinary(expression, location) {
+        const left = this.evaluate(expression.left, location);
+        const right = this.evaluate(expression.right, location);
+        const operator = expression.operatorToken.kind;
+        const isSyntacticallyString = (left.isSyntacticallyString || right.isSyntacticallyString) && operator === 39 /* SyntaxKind.PlusToken */;
+        const resolvedOtherFiles = left.resolvedOtherFiles || right.resolvedOtherFiles;
+        const hasExternalReferences = left.hasExternalReferences || right.hasExternalReferences;
+        if (left.kind === 1 /* ConstantKind.Number */ && right.kind === 1 /* ConstantKind.Number */) {
+            const value = binaryNumber(operator, left.number, right.number);
+            if (value.kind !== 0 /* ConstantKind.None */)
+                return value.withFlags(isSyntacticallyString, resolvedOtherFiles, hasExternalReferences);
+        }
+        if (left.kind !== 0 /* ConstantKind.None */ && right.kind !== 0 /* ConstantKind.None */ && operator === 39 /* SyntaxKind.PlusToken */)
+            return stringEvaluation(left.text() + right.text(), isSyntacticallyString).withFlags(isSyntacticallyString, resolvedOtherFiles, hasExternalReferences);
+        return noValue(isSyntacticallyString, resolvedOtherFiles, hasExternalReferences);
+    }
+    evaluateTemplate(expression, location) {
+        let text = expression.head.text;
+        let resolvedOtherFiles = false;
+        let hasExternalReferences = false;
+        const spans = expression.templateSpans.nodes;
+        for (const span of spans) {
+            if (!(span instanceof TemplateSpan))
+                return noValue(true, false, false);
+            const value = this.evaluate(span.expression, location);
+            if (value.kind === 0 /* ConstantKind.None */)
+                return noValue(true, false, false);
+            text += value.text() + literalText(span.literal);
+            resolvedOtherFiles = resolvedOtherFiles || value.resolvedOtherFiles;
+            hasExternalReferences = hasExternalReferences || value.hasExternalReferences;
+        }
+        return stringEvaluation(text, true).withFlags(true, resolvedOtherFiles, hasExternalReferences);
+    }
+    evaluateEntity(expression, location) {
+        if (expression instanceof ElementAccessExpression) {
+            const argument = stringLiteralText(expression.argumentExpression);
+            if (argument === undefined)
+                return noEvaluation;
+            const root = this.resolveEntityName(expression.expression, 111551 /* SymbolFlags.Value */, false);
+            if (root === undefined || (root.flags & 384 /* SymbolFlags.Enum */) === 0 || root.exports === undefined)
+                return noEvaluation;
+            const member = root.exports.get(argument);
+            if (member === undefined)
+                return noEvaluation;
+            return this.evaluateEnumMemberSymbol(this.getMergedSymbol(member), location);
+        }
+        const symbol = this.resolveEntityName(expression, 111551 /* SymbolFlags.Value */, false);
+        if (symbol === undefined)
+            return noEvaluation;
+        if (expression instanceof Identifier && (expression.text === 'Infinity' || expression.text === 'NaN')) {
+            // A global `Infinity` or `NaN`; without lib files these don't resolve at all.
+            if (symbol.declarations.length > 0 && isAmbientGlobal(symbol))
+                return numberEvaluation(expression.text === 'NaN' ? NaN : Infinity);
+        }
+        if ((symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0)
+            return this.evaluateEnumMemberSymbol(symbol, location);
+        if (isConstantVariable(symbol)) {
+            const declaration = symbol.valueDeclaration;
+            if (declaration instanceof VariableDeclaration &&
+                getType(declaration) === undefined &&
+                declaration.initializer !== undefined &&
+                (location === undefined || (declaration !== location && isDeclaredBeforeUse(declaration, location)))) {
+                const result = this.evaluate(declaration.initializer, declaration);
+                if (location !== undefined && getSourceFileOfNode(location) !== getSourceFileOfNode(declaration))
+                    return result.withFlags(false, true, true);
+                return result.withFlags(result.isSyntacticallyString, result.resolvedOtherFiles, true);
+            }
+        }
+        return noEvaluation;
+    }
+    evaluateEnumMemberSymbol(symbol, location) {
+        const declaration = symbol.valueDeclaration;
+        if (location === undefined)
+            return declaration === undefined ? noEvaluation : this.getEnumMemberValue(declaration);
+        if (declaration === undefined || declaration === location)
+            return noEvaluation;
+        if (!isDeclaredBeforeUse(declaration, location))
+            return numberEvaluation(0);
+        const value = this.getEnumMemberValue(declaration);
+        if (location.parent !== declaration.parent)
+            return value.withFlags(value.isSyntacticallyString, value.resolvedOtherFiles, true);
+        return value;
+    }
+}
+function binaryNumber(operator, left, right) {
+    switch (operator) {
+        case 51 /* SyntaxKind.BarToken */:
+            return numberEvaluation(left | right);
+        case 50 /* SyntaxKind.AmpersandToken */:
+            return numberEvaluation(left & right);
+        case 48 /* SyntaxKind.GreaterThanGreaterThanToken */:
+            return numberEvaluation(left >> right);
+        case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */:
+            return numberEvaluation(left >>> right);
+        case 47 /* SyntaxKind.LessThanLessThanToken */:
+            return numberEvaluation(left << right);
+        case 52 /* SyntaxKind.CaretToken */:
+            return numberEvaluation(left ^ right);
+        case 41 /* SyntaxKind.AsteriskToken */:
+            return numberEvaluation(left * right);
+        case 43 /* SyntaxKind.SlashToken */:
+            return numberEvaluation(left / right);
+        case 39 /* SyntaxKind.PlusToken */:
+            return numberEvaluation(left + right);
+        case 40 /* SyntaxKind.MinusToken */:
+            return numberEvaluation(left - right);
+        case 44 /* SyntaxKind.PercentToken */:
+            return numberEvaluation(left % right);
+        case 42 /* SyntaxKind.AsteriskAsteriskToken */:
+            return numberEvaluation(left ** right);
+    }
+    return noEvaluation;
+}
+function literalText(node) {
+    if (node instanceof TemplateMiddle)
+        return node.text;
+    if (node instanceof TemplateTail)
+        return node.text;
+    return '';
+}
+/** Skips parentheses only: type assertions and `!` break evaluation, as in the checker. */
+function skipEvaluationParentheses(node) {
+    let current = node;
+    while (current instanceof ParenthesizedExpression)
+        current = current.expression;
+    return current;
+}
+/** The text of a string literal or no-substitution template literal. */
+export function stringLiteralText(node) {
+    if (node instanceof StringLiteral)
+        return node.text;
+    if (node instanceof NoSubstitutionTemplateLiteral)
+        return node.text;
+    return undefined;
+}
+function entityNameLeft(node) {
+    if (node instanceof QualifiedName)
+        return node.left;
+    if (node instanceof PropertyAccessExpression)
+        return node.expression;
+    return undefined;
+}
+function entityNameRight(node) {
+    if (node instanceof QualifiedName)
+        return node.right;
+    if (node instanceof PropertyAccessExpression)
+        return node.name;
+    return undefined;
+}
+export function isEntityNameExpressionNode(node) {
+    if (node instanceof Identifier)
+        return true;
+    if (node instanceof PropertyAccessExpression)
+        return node.name instanceof Identifier && isEntityNameExpressionNode(node.expression);
+    return false;
+}
+function isAmbientGlobal(symbol) {
+    for (let i = 0; i < symbol.declarations.length; i++)
+        if ((symbol.declarations[i].flags & 8388608 /* NodeFlags.Ambient */) === 0)
+            return false;
+    return true;
+}
+function isConstantVariable(symbol) {
+    if ((symbol.flags & 3 /* SymbolFlags.Variable */) === 0)
+        return false;
+    const declaration = symbol.valueDeclaration;
+    return declaration !== undefined && (getCombinedNodeFlags(declaration) & 6 /* NodeFlags.Constant */) !== 0;
+}
+/** Whether `declaration` precedes `usage`, or `usage` runs later, as for the checker's block-scoped use check. */
+function isDeclaredBeforeUse(declaration, usage) {
+    if (getSourceFileOfNode(declaration) !== getSourceFileOfNode(usage))
+        return true;
+    if ((usage.flags & (4194304 /* NodeFlags.JSDoc */ | 8388608 /* NodeFlags.Ambient */)) !== 0)
+        return true;
+    if (declaration.pos <= usage.pos) {
+        if (declaration.kind === 209 /* SyntaxKind.BindingElement */) {
+            const root = getRootDeclaration(declaration);
+            return root === declaration || isDeclaredBeforeUse(root, usage);
+        }
+        if (declaration instanceof VariableDeclaration)
+            return !isInInitializerOf(declaration, usage);
+        return true;
+    }
+    // A use inside a function or class body runs after the declaration.
+    const container = declaration.parent;
+    for (let current = usage.parent; current !== undefined && current !== container; current = current.parent)
+        if (isFunctionLike(current))
+            return true;
+    return false;
+}
+function isInInitializerOf(declaration, usage) {
+    const initializer = getInitializer(declaration);
+    if (initializer === undefined)
+        return false;
+    for (let current = usage; current !== undefined; current = current.parent) {
+        if (current === initializer)
+            return true;
+        if (isSameNode(current, declaration) || isFunctionLike(current))
+            return false;
+    }
+    return false;
+}
+function getDeclarationContainer(node) {
+    for (let current = getRootDeclaration(node); current !== undefined; current = current.parent) {
+        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 */:
+                continue;
+        }
+        return current.parent;
+    }
+    return undefined;
+}
+/** An alias without other meanings. */
+function isPureAlias(symbol) {
+    return isNonLocalAlias(symbol, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */);
+}
+function isNonLocalAlias(symbol, excludes) {
+    return (symbol.flags & (2097152 /* SymbolFlags.Alias */ | excludes)) === 2097152 /* SymbolFlags.Alias */;
+}
+function isAliasSymbolDeclaration(node) {
+    switch (node.kind) {
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 275 /* SyntaxKind.NamespaceImport */:
+        case 281 /* SyntaxKind.NamespaceExport */:
+        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 282 /* SyntaxKind.ExportSpecifier */:
+            return true;
+        case 274 /* SyntaxKind.ImportClause */:
+            return node instanceof ImportClause && node.name !== undefined;
+        case 278 /* SyntaxKind.ExportAssignment */:
+            return true;
+    }
+    return false;
+}
+export function getDeclarationOfAliasSymbol(symbol) {
+    for (let i = symbol.declarations.length - 1; i >= 0; i--) {
+        const declaration = symbol.declarations[i];
+        if (isAliasSymbolDeclaration(declaration))
+            return declaration;
+    }
+    return undefined;
+}
+function isTypeOnlyAlias(symbol) {
+    let node = getDeclarationOfAliasSymbol(symbol);
+    while (node !== undefined) {
+        switch (node.kind) {
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                return getIsTypeOnly(node);
+            case 274 /* SyntaxKind.ImportClause */:
+                if (node instanceof ImportClause && node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */)
+                    return true;
+                node = node.parent;
+                continue;
+            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                if (getIsTypeOnly(node))
+                    return true;
+                node = node.parent;
+                continue;
+            case 275 /* SyntaxKind.NamespaceImport */:
+            case 281 /* SyntaxKind.NamespaceExport */:
+            case 276 /* SyntaxKind.NamedImports */:
+            case 280 /* SyntaxKind.NamedExports */:
+                node = node.parent;
+                continue;
+        }
+        return false;
+    }
+    return false;
+}
+function isValueDeclarationKind(kind) {
+    switch (kind) {
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 170 /* SyntaxKind.Parameter */:
+        case 209 /* SyntaxKind.BindingElement */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 306 /* SyntaxKind.EnumMember */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+            return true;
+    }
+    return false;
+}
+/** The name an import or export specifier takes from its module. */
+function importedNameOf(node) {
+    if (node instanceof ImportSpecifier)
+        return moduleExportNameText(node.propertyName !== undefined ? node.propertyName : node.name);
+    if (node instanceof ExportSpecifier)
+        return moduleExportNameText(node.propertyName !== undefined ? node.propertyName : node.name);
+    return undefined;
+}
+/** The import or export declaration of a specifier. */
+function moduleDeclarationOfSpecifier(node) {
+    const list = node.parent;
+    const clauseOrDeclaration = list === undefined ? undefined : list.parent;
+    if (node instanceof ImportSpecifier)
+        return clauseOrDeclaration === undefined ? undefined : clauseOrDeclaration.parent;
+    return clauseOrDeclaration;
+}
+function getModuleSpecifierOf(declaration) {
+    return getModuleSpecifier(declaration);
+}
+function moduleExportNameText(name) {
+    if (name instanceof Identifier)
+        return name.text;
+    if (name instanceof StringLiteral)
+        return name.text;
+    return '';
+}