tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/binder.js

@@ -0,0 +1,2358 @@
+// The binder: declares a symbol for each declaration in its container's table, merges
+// declarations, reports binding errors, and builds the control flow graph.
+//
+// Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
+// statically, but reads fields of a narrowed value dynamically.
+import { BinaryExpression, CallExpression, ConditionalTypeNode, ElementAccessExpression, ExportAssignment, FunctionExpression, KeywordExpression, ModuleDeclaration, NodeVisitor, PatternAmbientModule, PrefixUnaryExpression, PropertyAccessExpression, TypeAliasDeclaration, VariableDeclaration, getArguments, getBody, getElements, getExpression, getInitializer, getLabel, getLocals, getModifiers, getName, getParameters, getPostfixToken, getProperties, getStatements, getSymbol, getText, isDeclarationNode, isLocalsContainer, setEndFlowNode, setFlowNode, setLocalSymbol, setLocals, setNextContainer, setReturnFlowNode, setSymbol, } from './ast.js';
+import { isAmbientModule, isAssignmentOperator, isFunctionLike, isGlobalScopeAugmentation, isInJSFile, isLeftHandSideExpression, isRequireCall, isStringLiteralLike, nodeIsMissing, nodeIsPresent, } from './ast-utilities.js';
+import { declarationNameToString, expressionIsAlias, getAssignmentDeclarationKind, getCombinedModifierFlags, getContainingClass, getElementOrPropertyAccessName, getErrorRangeForNode, getImmediatelyInvokedFunctionExpression, getModuleInstanceState, StatementsByName, getNameOfDeclaration, getRangeOfTokenAtPosition, getSourceTextOfNode, hasDynamicName, hasSyntacticModifier, isAssignmentTarget, isAsyncFunction, isAutoAccessorPropertyDeclaration, isBlockOrCatchScoped, isBooleanLiteral, isDeclarationStatementKind, isDestructuringAssignment, isDottedName, isEntityNameExpression, isEnumConst, isExpandoInitializer, isExpressionOfOptionalChainRoot, isExternalModule, isExternalOrCommonJSModule, isIdentifierName, isImplicitlyExportedJSDocDeclaration, isInTopLevelContext, isJsonSourceFile, isLogicalExpression, isLogicalOrCoalescingAssignmentExpression, isLogicalOrCoalescingAssignmentOperator, isLogicalOrCoalescingBinaryOperator, isModuleAugmentationExternal, isNullishCoalesce, isObjectLiteralMethod, isObjectLiteralOrClassExpressionMethodOrAccessor, isOptionalChain, isOptionalChainRoot, isOutermostOptionalChain, isParameterPropertyDeclaration, isPartOfParameterDeclaration, isPartOfTypeQuery, isPotentiallyExecutableNode, isPrologueDirective, isPropertyNameLiteral, isPushOrUnshiftIdentifier, isSignedNumericLiteral, isStatic, isStringOrNumericLiteralLike, isVariableDeclarationInitializedToRequire, moduleExportNameIsDefault, nodeText, skipParentheses, } from './binder-utilities.js';
+import { Diagnostic } from './diagnostics.js';
+import { FlowNode, FlowReduceLabel, FlowSwitchClause } from './flow.js';
+import { removeFileExtension } from './path.js';
+import { getIdentifierToken, tokenToString } from './scanner.js';
+import { Symbol, addDeclaration, getExports, getMembers, getSymbolId, internalSymbolNamePrefix, } from './symbol.js';
+export function getContainerFlags(node) {
+    switch (node.kind) {
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 188 /* SyntaxKind.TypeLiteral */:
+        case 293 /* SyntaxKind.JsxAttributes */:
+            return 1 /* ContainerFlags.IsContainer */;
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+            return 1 /* ContainerFlags.IsContainer */ | 64 /* ContainerFlags.IsInterface */;
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 201 /* SyntaxKind.MappedType */:
+        case 182 /* SyntaxKind.IndexSignature */:
+            return 1 /* ContainerFlags.IsContainer */ | 32 /* ContainerFlags.HasLocals */;
+        case 307 /* SyntaxKind.SourceFile */:
+            return 1 /* ContainerFlags.IsContainer */ | 4 /* ContainerFlags.IsControlFlowContainer */ | 32 /* ContainerFlags.HasLocals */;
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            if (isObjectLiteralOrClassExpressionMethodOrAccessor(node))
+                return (1 /* ContainerFlags.IsContainer */ |
+                    4 /* ContainerFlags.IsControlFlowContainer */ |
+                    32 /* ContainerFlags.HasLocals */ |
+                    8 /* ContainerFlags.IsFunctionLike */ |
+                    128 /* ContainerFlags.IsObjectLiteralOrClassExpressionMethodOrAccessor */ |
+                    256 /* ContainerFlags.IsThisContainer */);
+            return functionContainerFlags;
+        case 177 /* SyntaxKind.Constructor */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            return functionContainerFlags;
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 185 /* SyntaxKind.FunctionType */:
+        case 181 /* SyntaxKind.ConstructSignature */:
+        case 186 /* SyntaxKind.ConstructorType */:
+            return (1 /* ContainerFlags.IsContainer */ |
+                4 /* ContainerFlags.IsControlFlowContainer */ |
+                32 /* ContainerFlags.HasLocals */ |
+                8 /* ContainerFlags.IsFunctionLike */ |
+                512 /* ContainerFlags.PropagatesThisKeyword */);
+        case 219 /* SyntaxKind.FunctionExpression */:
+            return (1 /* ContainerFlags.IsContainer */ |
+                4 /* ContainerFlags.IsControlFlowContainer */ |
+                32 /* ContainerFlags.HasLocals */ |
+                8 /* ContainerFlags.IsFunctionLike */ |
+                16 /* ContainerFlags.IsFunctionExpression */ |
+                256 /* ContainerFlags.IsThisContainer */);
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return (1 /* ContainerFlags.IsContainer */ |
+                4 /* ContainerFlags.IsControlFlowContainer */ |
+                32 /* ContainerFlags.HasLocals */ |
+                8 /* ContainerFlags.IsFunctionLike */ |
+                16 /* ContainerFlags.IsFunctionExpression */ |
+                512 /* ContainerFlags.PropagatesThisKeyword */);
+        case 269 /* SyntaxKind.ModuleBlock */:
+            return 4 /* ContainerFlags.IsControlFlowContainer */;
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            return getInitializer(node) !== undefined
+                ? 4 /* ContainerFlags.IsControlFlowContainer */ | 256 /* ContainerFlags.IsThisContainer */
+                : 0 /* ContainerFlags.None */;
+        case 300 /* SyntaxKind.CatchClause */:
+        case 249 /* SyntaxKind.ForStatement */:
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */:
+        case 270 /* SyntaxKind.CaseBlock */:
+            return 2 /* ContainerFlags.IsBlockScopedContainer */ | 32 /* ContainerFlags.HasLocals */;
+        case 242 /* SyntaxKind.Block */: {
+            const parent = node.parent;
+            return isFunctionLike(parent) || parent.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */
+                ? 0 /* ContainerFlags.None */
+                : 2 /* ContainerFlags.IsBlockScopedContainer */ | 32 /* ContainerFlags.HasLocals */;
+        }
+    }
+    return 0 /* ContainerFlags.None */;
+}
+const functionContainerFlags = 1 /* ContainerFlags.IsContainer */ |
+    4 /* ContainerFlags.IsControlFlowContainer */ |
+    32 /* ContainerFlags.HasLocals */ |
+    8 /* ContainerFlags.IsFunctionLike */ |
+    256 /* ContainerFlags.IsThisContainer */;
+/** A label in scope for `break` and `continue`. */
+class ActiveLabel {
+    next;
+    name;
+    breakTarget;
+    continueTarget;
+    referenced;
+    constructor(next, name, breakTarget) {
+        this.next = next;
+        this.name = name;
+        this.breakTarget = breakTarget;
+        this.continueTarget = undefined;
+        this.referenced = false;
+    }
+}
+/** A JavaScript `F.x = …` assignment, bound once the whole file has its declarations. */
+class ExpandoAssignment {
+    node;
+    container;
+    blockScopeContainer;
+    constructor(node, container, blockScopeContainer) {
+        this.node = node;
+        this.container = container;
+        this.blockScopeContainer = blockScopeContainer;
+    }
+}
+/** Binds `file` unless it is already bound. */
+export function bindSourceFile(file) {
+    if (file.isBound)
+        return;
+    const binder = new Binder(file);
+    binder.bind(file);
+    binder.bindDeferredExpandoAssignments(binder.expandoAssignments);
+    file.symbolCount = binder.symbolCount;
+    file.isBound = true;
+}
+/** The name of a private member `#description` of the class with symbol `containingClassSymbol`. */
+export function getSymbolNameForPrivateIdentifier(containingClassSymbol, description) {
+    return internalSymbolNamePrefix + '#' + getSymbolId(containingClassSymbol) + '@' + description;
+}
+/**
+ * Makes `node` the value declaration of `symbol` unless it has one already. Non-assignment
+ * declarations win over JavaScript assignments, and other declarations over namespaces.
+ */
+export function setValueDeclaration(symbol, node) {
+    const valueDeclaration = symbol.valueDeclaration;
+    if (valueDeclaration === undefined ||
+        (isAssignmentDeclaration(valueDeclaration) && !isAssignmentDeclaration(node)) ||
+        (valueDeclaration.kind !== node.kind && isEffectiveModuleDeclaration(valueDeclaration)))
+        symbol.valueDeclaration = node;
+}
+function isAssignmentDeclaration(declaration) {
+    switch (declaration.kind) {
+        case 227 /* SyntaxKind.BinaryExpression */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 79 /* SyntaxKind.Identifier */:
+        case 214 /* SyntaxKind.CallExpression */:
+            return true;
+    }
+    return false;
+}
+function isEffectiveModuleDeclaration(node) {
+    return node.kind === 268 /* SyntaxKind.ModuleDeclaration */ || node.kind === 79 /* SyntaxKind.Identifier */;
+}
+class Binder extends NodeVisitor {
+    file;
+    unreachableFlow;
+    container;
+    thisContainer;
+    blockScopeContainer;
+    lastContainer;
+    currentFlow;
+    /**
+     * `currentFlow` as an optional value, shared by the nodes that store it: natively, converting a
+     * `FlowNode` to `FlowNode | undefined` allocates.
+     */
+    storedFlow;
+    storedFlowValue;
+    currentBreakTarget;
+    currentContinueTarget;
+    currentReturnTarget;
+    currentTrueTarget;
+    currentFalseTarget;
+    currentExceptionTarget;
+    preSwitchCaseFlow;
+    activeLabelList;
+    emitFlags;
+    seenThisKeyword;
+    hasExplicitReturn;
+    hasFlowEffects;
+    inAssignmentPattern;
+    seenParseError;
+    symbolCount;
+    notConstEnumOnlyModules;
+    expandoAssignments;
+    /** For the module instance states of the file's module declarations (`getModuleInstanceState`). */
+    statementsByName;
+    constructor(file) {
+        super();
+        this.file = file;
+        this.unreachableFlow = new FlowNode(1 /* FlowFlags.Unreachable */, undefined, undefined);
+        this.container = file;
+        this.thisContainer = undefined;
+        this.blockScopeContainer = file;
+        this.lastContainer = undefined;
+        this.currentFlow = this.unreachableFlow;
+        this.storedFlow = this.unreachableFlow;
+        this.storedFlowValue = this.unreachableFlow;
+        this.currentBreakTarget = undefined;
+        this.currentContinueTarget = undefined;
+        this.currentReturnTarget = undefined;
+        this.currentTrueTarget = undefined;
+        this.currentFalseTarget = undefined;
+        this.currentExceptionTarget = undefined;
+        this.preSwitchCaseFlow = undefined;
+        this.activeLabelList = undefined;
+        this.emitFlags = 0 /* NodeFlags.None */;
+        this.seenThisKeyword = false;
+        this.hasExplicitReturn = false;
+        this.hasFlowEffects = false;
+        this.inAssignmentPattern = false;
+        this.seenParseError = false;
+        this.symbolCount = 0;
+        this.notConstEnumOnlyModules = new Set();
+        this.expandoAssignments = [];
+        this.statementsByName = new StatementsByName();
+    }
+    visitNode(node) {
+        this.bind(node);
+        return false;
+    }
+    /** `currentFlow`, for storing in a node's `flowNode`. */
+    currentFlowValue() {
+        if (this.storedFlow !== this.currentFlow) {
+            this.storedFlow = this.currentFlow;
+            this.storedFlowValue = this.currentFlow;
+        }
+        return this.storedFlowValue;
+    }
+    newSymbol(flags, name) {
+        this.symbolCount++;
+        return new Symbol(flags, name);
+    }
+    // Declarations
+    /**
+     * Declares `node` in `symbolTable` with flags `includes`, merging with an existing symbol
+     * of the same name unless its flags intersect `excludes`, which is reported as a duplicate.
+     * Callers pass `parent` as read from the container rather than narrowed, so that its members
+     * share the stored value (see `storedFlow`).
+     */
+    declareSymbol(symbolTable, parent, node, includes, excludes) {
+        return this.declareSymbolEx(symbolTable, parent, node, includes, excludes, false, false);
+    }
+    declareSymbolEx(symbolTable, parent, node, includes, excludes, isReplaceableByMethod, isComputedName) {
+        const isDefaultExport = hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */) ||
+            (node.kind === 282 /* SyntaxKind.ExportSpecifier */ && moduleExportNameIsDefault(getName(node)));
+        // The exported symbol of `export default function/class` is always named "default".
+        const name = isComputedName
+            ? "\uFFFEcomputed" /* InternalSymbolName.Computed */
+            : isDefaultExport && parent !== undefined
+                ? "default" /* InternalSymbolName.Default */
+                : this.getDeclarationName(node);
+        let symbol;
+        if (name === "\uFFFEmissing" /* InternalSymbolName.Missing */)
+            symbol = this.newSymbol(0 /* SymbolFlags.None */, "\uFFFEmissing" /* InternalSymbolName.Missing */);
+        else {
+            // A new symbol starts without flags, so it can't conflict with `excludes`. A conflicting
+            // existing symbol gets errors on each declaration, and `node` gets a symbol of its own.
+            // A JavaScript constructor property (`isReplaceableByMethod`) always loses a conflict,
+            // which allows `this.method = this.method.bind(this)`.
+            symbol = symbolTable.get(name);
+            if (symbol === undefined) {
+                symbol = this.newSymbol(0 /* SymbolFlags.None */, name);
+                symbolTable.set(name, symbol);
+                if (isReplaceableByMethod)
+                    symbol.flags |= 536870912 /* SymbolFlags.ReplaceableByMethod */;
+            }
+            else if (isReplaceableByMethod && (symbol.flags & 536870912 /* SymbolFlags.ReplaceableByMethod */) === 0) {
+                return symbol;
+            }
+            else if ((symbol.flags & excludes) !== 0) {
+                if ((symbol.flags & 536870912 /* SymbolFlags.ReplaceableByMethod */) !== 0) {
+                    symbol = this.newSymbol(0 /* SymbolFlags.None */, name);
+                    symbolTable.set(name, symbol);
+                }
+                else if (!(((includes & 3 /* SymbolFlags.Variable */) !== 0 && (symbol.flags & 67108864 /* SymbolFlags.Assignment */) !== 0) ||
+                    ((includes & 67108864 /* SymbolFlags.Assignment */) !== 0 && (symbol.flags & 3 /* SymbolFlags.Variable */) !== 0))) {
+                    // Assignment declarations merge with variables whatever their other flags.
+                    this.reportDuplicate(symbol, node, includes, isDefaultExport);
+                    symbol = this.newSymbol(0 /* SymbolFlags.None */, name);
+                }
+            }
+        }
+        this.addDeclarationToSymbol(symbol, node, includes);
+        if (symbol.parent === undefined)
+            symbol.parent = parent;
+        else if (symbol.parent !== parent)
+            throw new Error('Existing symbol parent should match new one');
+        return symbol;
+    }
+    reportDuplicate(symbol, node, includes, isDefaultExport) {
+        let message = (symbol.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0
+            ? 619 /* Diagnostics.Cannot_redeclare_block_scoped_variable_0 */
+            : 478 /* Diagnostics.Duplicate_identifier_0 */;
+        let messageNeedsName = true;
+        if ((symbol.flags & 384 /* SymbolFlags.Enum */) !== 0 || (includes & 384 /* SymbolFlags.Enum */) !== 0) {
+            message = 721 /* Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations */;
+            messageNeedsName = false;
+        }
+        let multipleDefaultExports = false;
+        if (symbol.declarations.length !== 0) {
+            // A default export (by modifier, or `export default` assignment) after another one.
+            if (isDefaultExport || (node instanceof ExportAssignment && !node.isExportEquals)) {
+                message = 686 /* Diagnostics.A_module_cannot_have_multiple_default_exports */;
+                messageNeedsName = false;
+                multipleDefaultExports = true;
+            }
+        }
+        const declarationName = getNameOfDeclaration(node) ?? node;
+        const diagnostic = this.createDiagnosticForNode(declarationName, message, messageNeedsName ? [this.getDisplayName(node)] : noArgs);
+        if (node instanceof TypeAliasDeclaration &&
+            nodeIsMissing(node.type) &&
+            hasSyntacticModifier(node, 32 /* ModifierFlags.Export */) &&
+            (symbol.flags & (2097152 /* SymbolFlags.Alias */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */)) !== 0) {
+            // `export type T;` may have meant `export type { T }`.
+            diagnostic.addRelatedInfo(this.createDiagnosticForNode(node, 303 /* Diagnostics.Did_you_mean_0 */, [
+                'export type { ' + node.name.text + ' }',
+            ]));
+        }
+        const declarations = symbol.declarations;
+        for (let index = 0; index < declarations.length; index++) {
+            const declaration = declarations[index];
+            const decl = getNameOfDeclaration(declaration) ?? declaration;
+            const d = this.createDiagnosticForNode(decl, message, messageNeedsName ? [this.getDisplayName(declaration)] : noArgs);
+            if (multipleDefaultExports)
+                d.addRelatedInfo(this.createDiagnosticForNode(declarationName, index === 0 ? 885 /* Diagnostics.Another_export_default_is_here */ : 1357 /* Diagnostics.X_and_here */, noArgs));
+            this.addDiagnostic(d);
+            if (multipleDefaultExports)
+                diagnostic.addRelatedInfo(this.createDiagnosticForNode(decl, 884 /* Diagnostics.The_first_export_default_is_here */, noArgs));
+        }
+        this.addDiagnostic(diagnostic);
+        // An accessor conflicting with a non-accessor or the other accessor kind makes the symbol a
+        // full accessor, so later declarations conflict too.
+        const accessor = symbol.flags & 98304 /* SymbolFlags.Accessor */;
+        if (accessor !== 0 && accessor !== (includes & 98304 /* SymbolFlags.Accessor */))
+            symbol.flags |= 98304 /* SymbolFlags.Accessor */;
+    }
+    /** The symbol name of a declaration. Computed names must be literals or well-known symbols. */
+    getDeclarationName(node) {
+        if (node instanceof ExportAssignment)
+            return node.isExportEquals ? "export=" /* InternalSymbolName.ExportEquals */ : "default" /* InternalSymbolName.Default */;
+        const name = getNameOfDeclaration(node);
+        if (name !== undefined) {
+            if (isAmbientModule(node)) {
+                if (isGlobalScopeAugmentation(node))
+                    return "\uFFFEglobal" /* InternalSymbolName.Global */;
+                return '"' + nodeText(name) + '"';
+            }
+            if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
+                // Private names are only allowed in classes; elsewhere there is already a parse error.
+                const containingClass = getContainingClass(node);
+                if (containingClass === undefined)
+                    return "\uFFFEmissing" /* InternalSymbolName.Missing */;
+                return getSymbolNameForPrivateIdentifier(getSymbol(containingClass), getText(name));
+            }
+            if (isPropertyNameLiteral(name) || name.kind === 296 /* SyntaxKind.JsxNamespacedName */)
+                return nodeText(name);
+            if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */) {
+                const expression = getExpression(name);
+                // A literal computed name is just the literal.
+                if (isStringOrNumericLiteralLike(expression))
+                    return getText(expression);
+                if (expression instanceof PrefixUnaryExpression && isSignedNumericLiteral(expression)) {
+                    const unary = expression;
+                    return tokenToString(unary.operator) + getText(unary.operand);
+                }
+                throw new Error('Only computed properties with literal names have declaration names');
+            }
+            return "\uFFFEmissing" /* InternalSymbolName.Missing */;
+        }
+        switch (node.kind) {
+            case 177 /* SyntaxKind.Constructor */:
+                return "\uFFFEconstructor" /* InternalSymbolName.Constructor */;
+            case 185 /* SyntaxKind.FunctionType */:
+            case 180 /* SyntaxKind.CallSignature */:
+                return "\uFFFEcall" /* InternalSymbolName.Call */;
+            case 186 /* SyntaxKind.ConstructorType */:
+            case 181 /* SyntaxKind.ConstructSignature */:
+                return "\uFFFEnew" /* InternalSymbolName.New */;
+            case 182 /* SyntaxKind.IndexSignature */:
+                return "\uFFFEindex" /* InternalSymbolName.Index */;
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                return "\uFFFEexport" /* InternalSymbolName.ExportStar */;
+            case 307 /* SyntaxKind.SourceFile */:
+            case 227 /* SyntaxKind.BinaryExpression */:
+                return "export=" /* InternalSymbolName.ExportEquals */;
+        }
+        return "\uFFFEmissing" /* InternalSymbolName.Missing */;
+    }
+    getDisplayName(node) {
+        const name = getName(node);
+        if (name !== undefined)
+            return declarationNameToString(this.file, name);
+        const declarationName = this.getDeclarationName(node);
+        return declarationName !== "\uFFFEmissing" /* InternalSymbolName.Missing */ ? declarationName : '(Missing)';
+    }
+    /**
+     * Declares a module or namespace member. Exported members get two symbols: a local one
+     * marked `ExportValue` and the export, so locals and exports of the same name conflict and
+     * the checker can tell a reference to the export from its local.
+     */
+    declareModuleMember(node, symbolFlags, symbolExcludes) {
+        const container = this.container;
+        const hasExportModifier = (getCombinedModifierFlags(node) & 32 /* ModifierFlags.Export */) !== 0 || isImplicitlyExportedJSDocDeclaration(node);
+        if ((symbolFlags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+            if (node.kind === 282 /* SyntaxKind.ExportSpecifier */ ||
+                (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ && hasExportModifier)) {
+                const containerSymbol = getSymbol(container);
+                return this.declareSymbol(getExports(containerSymbol), containerSymbol, node, symbolFlags, symbolExcludes);
+            }
+            return this.declareSymbol(this.localsOf(container), undefined, node, symbolFlags, symbolExcludes);
+        }
+        // Nested ambient modules (module augmentations) stay local so they never merge globally.
+        if (!isAmbientModule(node) && (hasExportModifier || (container.flags & 64 /* NodeFlags.ExportContext */) !== 0)) {
+            const containerSymbol = getSymbol(container);
+            // An unnamed default export has no local symbol.
+            if (!isLocalsContainer(container) ||
+                (hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */) &&
+                    this.getDeclarationName(node) === "\uFFFEmissing" /* InternalSymbolName.Missing */))
+                return this.declareSymbol(getExports(containerSymbol), containerSymbol, node, symbolFlags, symbolExcludes);
+            const exportKind = (symbolFlags & 111551 /* SymbolFlags.Value */) !== 0 ? 1048576 /* SymbolFlags.ExportValue */ : 0 /* SymbolFlags.None */;
+            const local = this.declareSymbol(this.localsOf(container), undefined, node, exportKind, symbolExcludes);
+            local.exportSymbol = this.declareSymbol(getExports(containerSymbol), containerSymbol, node, symbolFlags, symbolExcludes);
+            setLocalSymbol(node, local);
+            return local;
+        }
+        return this.declareSymbol(this.localsOf(container), undefined, node, symbolFlags, symbolExcludes);
+    }
+    declareClassMember(node, symbolFlags, symbolExcludes) {
+        const classSymbol = getSymbol(this.container);
+        const table = isStatic(node) ? getExports(classSymbol) : getMembers(classSymbol);
+        return this.declareSymbol(table, classSymbol, node, symbolFlags, symbolExcludes);
+    }
+    declareSourceFileMember(node, symbolFlags, symbolExcludes) {
+        if (isExternalModule(this.file))
+            return this.declareModuleMember(node, symbolFlags, symbolExcludes);
+        return this.declareSymbol(this.localsOf(this.file), undefined, node, symbolFlags, symbolExcludes);
+    }
+    declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
+        const container = this.container;
+        switch (container.kind) {
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+                return this.declareModuleMember(node, symbolFlags, symbolExcludes);
+            case 307 /* SyntaxKind.SourceFile */:
+                return this.declareSourceFileMember(node, symbolFlags, symbolExcludes);
+            case 232 /* SyntaxKind.ClassExpression */:
+            case 264 /* SyntaxKind.ClassDeclaration */:
+                return this.declareClassMember(node, symbolFlags, symbolExcludes);
+            case 267 /* SyntaxKind.EnumDeclaration */: {
+                const enumSymbol = getSymbol(container);
+                return this.declareSymbol(getExports(enumSymbol), enumSymbol, node, symbolFlags, symbolExcludes);
+            }
+            case 188 /* SyntaxKind.TypeLiteral */:
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 293 /* SyntaxKind.JsxAttributes */: {
+                const containerSymbol = getSymbol(container);
+                return this.declareSymbol(getMembers(containerSymbol), containerSymbol, node, symbolFlags, symbolExcludes);
+            }
+            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.ConstructorType */:
+            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.ConstructSignature */:
+            case 182 /* SyntaxKind.IndexSignature */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 174 /* SyntaxKind.MethodSignature */:
+            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.ArrowFunction */:
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 201 /* SyntaxKind.MappedType */:
+                return this.declareSymbol(this.localsOf(container), undefined, node, symbolFlags, symbolExcludes);
+        }
+        throw new Error('Unhandled case in declareSymbolAndAddToSymbolTable');
+    }
+    /** The locals table of `container`, created if missing. */
+    localsOf(container) {
+        let locals = getLocals(container);
+        if (locals === undefined) {
+            locals = new Map();
+            setLocals(container, locals);
+        }
+        return locals;
+    }
+    addDeclarationToSymbol(symbol, node, symbolFlags) {
+        symbol.flags |= symbolFlags;
+        setSymbol(node, symbol);
+        if (symbol.declarations.indexOf(node) < 0)
+            addDeclaration(symbol, node);
+        // A const-enum-only namespace merged with a class, function or regular enum isn't one anymore.
+        if ((symbol.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) !== 0 &&
+            (symbol.flags & (16 /* SymbolFlags.Function */ | 32 /* SymbolFlags.Class */ | 256 /* SymbolFlags.RegularEnum */)) !== 0) {
+            symbol.flags &= ~268435456 /* SymbolFlags.ConstEnumOnlyModule */;
+            this.notConstEnumOnlyModules.add(symbol);
+        }
+        if ((symbolFlags & 111551 /* SymbolFlags.Value */) !== 0)
+            setValueDeclaration(symbol, node);
+    }
+    bindAnonymousDeclaration(node, symbolFlags, name) {
+        const symbol = this.newSymbol(symbolFlags, name);
+        if ((symbolFlags & (8 /* SymbolFlags.EnumMember */ | 106500 /* SymbolFlags.ClassMember */)) !== 0)
+            symbol.parent = getSymbol(this.container);
+        this.addDeclarationToSymbol(symbol, node, symbolFlags);
+        return symbol;
+    }
+    bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) {
+        const blockScopeContainer = this.blockScopeContainer;
+        switch (blockScopeContainer.kind) {
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+                return this.declareModuleMember(node, symbolFlags, symbolExcludes);
+            case 307 /* SyntaxKind.SourceFile */:
+                if (isExternalOrCommonJSModule(this.file))
+                    return this.declareModuleMember(node, symbolFlags, symbolExcludes);
+                break;
+        }
+        return this.declareSymbol(this.localsOf(blockScopeContainer), undefined, node, symbolFlags, symbolExcludes);
+    }
+    // Diagnostics
+    createDiagnosticForNode(node, message, args) {
+        const range = getErrorRangeForNode(this.file, node);
+        return new Diagnostic(this.file.diagnosticFile(), range.pos, range.end, message, args);
+    }
+    errorOnNode(node, message, args) {
+        this.addDiagnostic(this.createDiagnosticForNode(node, message, args));
+    }
+    errorOnFirstToken(node, message, args) {
+        const range = getRangeOfTokenAtPosition(this.file, node.pos);
+        this.addDiagnostic(new Diagnostic(this.file.diagnosticFile(), range.pos, range.end, message, args));
+    }
+    addDiagnostic(diagnostic) {
+        this.file.bindDiagnostics.push(diagnostic);
+    }
+    // Traversal
+    bindOptional(node) {
+        if (node !== undefined)
+            this.bind(node);
+    }
+    bind(node) {
+        // Declare the node's symbol in the exports or members of the container's symbol, or in
+        // the container's locals; anonymous declarations like type literals go in no table.
+        switch (node.kind) {
+            case 79 /* SyntaxKind.Identifier */:
+                node.flowNode = this.currentFlowValue();
+                this.checkContextualIdentifier(node);
+                break;
+            case 109 /* SyntaxKind.ThisKeyword */:
+            case 107 /* SyntaxKind.SuperKeyword */:
+                if (node.kind === 109 /* SyntaxKind.ThisKeyword */)
+                    this.seenThisKeyword = true;
+                if (node instanceof KeywordExpression)
+                    node.flowNode = this.currentFlowValue();
+                break;
+            case 167 /* SyntaxKind.QualifiedName */:
+                if (isPartOfTypeQuery(node))
+                    node.flowNode = this.currentFlowValue();
+                break;
+            case 237 /* SyntaxKind.MetaProperty */:
+                node.flowNode = this.currentFlowValue();
+                break;
+            case 80 /* SyntaxKind.PrivateIdentifier */:
+                this.checkPrivateIdentifier(node);
+                break;
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+                if (isNarrowableReference(node))
+                    setFlowNode(node, this.currentFlowValue());
+                break;
+            case 227 /* SyntaxKind.BinaryExpression */:
+                switch (getAssignmentDeclarationKind(node)) {
+                    case 1 /* JSDeclarationKind.ModuleExports */:
+                        this.bindModuleExportsAssignment(node);
+                        break;
+                    case 2 /* JSDeclarationKind.ExportsProperty */:
+                        this.bindExportsOrObjectDefineProperty(node);
+                        break;
+                    case 4 /* JSDeclarationKind.Property */:
+                        this.bindExpandoPropertyAssignment(node);
+                        break;
+                    case 3 /* JSDeclarationKind.ThisProperty */:
+                        this.bindThisPropertyAssignment(node);
+                        break;
+                }
+                this.checkStrictModeBinaryExpression(node);
+                break;
+            case 300 /* SyntaxKind.CatchClause */:
+                this.checkStrictModeCatchClause(node);
+                break;
+            case 221 /* SyntaxKind.DeleteExpression */:
+                this.checkStrictModeDeleteExpression(node);
+                break;
+            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+                this.checkStrictModeEvalOrArguments(node, node.operand);
+                break;
+            case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+                const operator = node.operator;
+                if (operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */)
+                    this.checkStrictModeEvalOrArguments(node, node.operand);
+                break;
+            }
+            case 255 /* SyntaxKind.WithStatement */:
+                this.errorOnFirstToken(node, 70 /* Diagnostics.X_with_statements_are_not_allowed_in_strict_mode */, noArgs);
+                break;
+            case 257 /* SyntaxKind.LabeledStatement */: {
+                const statement = node.statement;
+                if (isDeclarationStatementKind(statement.kind) || statement.kind === 244 /* SyntaxKind.VariableStatement */)
+                    this.errorOnFirstToken(node.label, 278 /* Diagnostics.A_label_is_not_allowed_here */, noArgs);
+                break;
+            }
+            case 198 /* SyntaxKind.ThisType */:
+                this.seenThisKeyword = true;
+                break;
+            case 169 /* SyntaxKind.TypeParameter */:
+                this.bindTypeParameter(node);
+                break;
+            case 170 /* SyntaxKind.Parameter */:
+                this.bindParameter(node);
+                break;
+            case 261 /* SyntaxKind.VariableDeclaration */:
+                this.bindVariableDeclarationOrBindingElement(node);
+                break;
+            case 209 /* SyntaxKind.BindingElement */:
+                node.flowNode = this.currentFlowValue();
+                this.bindVariableDeclarationOrBindingElement(node);
+                break;
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 172 /* SyntaxKind.PropertySignature */: {
+                const isAutoAccessor = isAutoAccessorPropertyDeclaration(node);
+                this.bindPropertyOrMethodOrAccessor(node, (isAutoAccessor ? 98304 /* SymbolFlags.Accessor */ : 4 /* SymbolFlags.Property */) | optionalSymbolFlag(node), isAutoAccessor ? 111547 /* SymbolFlags.AccessorExcludes */ : 13243 /* SymbolFlags.PropertyExcludes */);
+                break;
+            }
+            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+                this.bindPropertyOrMethodOrAccessor(node, 4 /* SymbolFlags.Property */, 13243 /* SymbolFlags.PropertyExcludes */);
+                break;
+            case 306 /* SyntaxKind.EnumMember */:
+                this.bindPropertyOrMethodOrAccessor(node, 8 /* SymbolFlags.EnumMember */, 900095 /* SymbolFlags.EnumMemberExcludes */);
+                break;
+            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.ConstructSignature */:
+            case 182 /* SyntaxKind.IndexSignature */:
+                this.declareSymbolAndAddToSymbolTable(node, 131072 /* SymbolFlags.Signature */, 0 /* SymbolFlags.None */);
+                break;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 174 /* SyntaxKind.MethodSignature */:
+                this.bindPropertyOrMethodOrAccessor(node, 8192 /* SymbolFlags.Method */ | optionalSymbolFlag(node), isObjectLiteralMethod(node) ? 111551 /* SymbolFlags.Value */ : 103359 /* SymbolFlags.MethodExcludes */);
+                break;
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+                this.bindFunctionDeclaration(node);
+                break;
+            case 177 /* SyntaxKind.Constructor */:
+                this.declareSymbolAndAddToSymbolTable(node, 16384 /* SymbolFlags.Constructor */, 0 /* SymbolFlags.None */);
+                break;
+            case 178 /* SyntaxKind.GetAccessor */:
+                this.bindPropertyOrMethodOrAccessor(node, 32768 /* SymbolFlags.GetAccessor */, 46011 /* SymbolFlags.GetAccessorExcludes */);
+                break;
+            case 179 /* SyntaxKind.SetAccessor */:
+                this.bindPropertyOrMethodOrAccessor(node, 65536 /* SymbolFlags.SetAccessor */, 78779 /* SymbolFlags.SetAccessorExcludes */);
+                break;
+            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.ConstructorType */:
+                this.bindFunctionOrConstructorType(node);
+                break;
+            case 188 /* SyntaxKind.TypeLiteral */:
+            case 201 /* SyntaxKind.MappedType */:
+                this.bindAnonymousDeclaration(node, 2048 /* SymbolFlags.TypeLiteral */, "\uFFFEtype" /* InternalSymbolName.Type */);
+                break;
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+                this.bindAnonymousDeclaration(node, 4096 /* SymbolFlags.ObjectLiteral */, "\uFFFEobject" /* InternalSymbolName.Object */);
+                break;
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.ArrowFunction */:
+                this.bindFunctionExpression(node);
+                break;
+            case 232 /* SyntaxKind.ClassExpression */:
+            case 264 /* SyntaxKind.ClassDeclaration */:
+                this.bindClassLikeDeclaration(node);
+                break;
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+                this.bindBlockScopedDeclaration(node, 64 /* SymbolFlags.Interface */, 788872 /* SymbolFlags.InterfaceExcludes */);
+                break;
+            case 214 /* SyntaxKind.CallExpression */:
+                switch (getAssignmentDeclarationKind(node)) {
+                    case 5 /* JSDeclarationKind.ObjectDefinePropertyValue */:
+                        this.bindExpandoPropertyAssignment(node);
+                        break;
+                    case 6 /* JSDeclarationKind.ObjectDefinePropertyExports */:
+                        this.bindExportsOrObjectDefineProperty(node);
+                        break;
+                }
+                // Only to detect CommonJS modules.
+                if (isInJSFile(node) && this.file.commonJSModuleIndicator === undefined && isRequireCall(node, false))
+                    this.setCommonJSModuleIndicator(node);
+                break;
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+                this.bindBlockScopedDeclaration(node, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */);
+                break;
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+                // Top-level ones are bound by bindContainer, after CommonJS module indicators.
+                if (this.blockScopeContainer.kind !== 307 /* SyntaxKind.SourceFile */)
+                    this.bindBlockScopedDeclaration(node, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */);
+                break;
+            case 267 /* SyntaxKind.EnumDeclaration */:
+                if (isEnumConst(node))
+                    this.bindBlockScopedDeclaration(node, 128 /* SymbolFlags.ConstEnum */, 899967 /* SymbolFlags.ConstEnumExcludes */);
+                else
+                    this.bindBlockScopedDeclaration(node, 256 /* SymbolFlags.RegularEnum */, 899327 /* SymbolFlags.RegularEnumExcludes */);
+                break;
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+                this.bindModuleDeclaration(node);
+                break;
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 275 /* SyntaxKind.NamespaceImport */:
+            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                this.declareSymbolAndAddToSymbolTable(node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */);
+                break;
+            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+                this.bindNamespaceExportDeclaration(node);
+                break;
+            case 274 /* SyntaxKind.ImportClause */:
+                if (node.name !== undefined)
+                    this.declareSymbolAndAddToSymbolTable(node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */);
+                break;
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                this.bindExportDeclaration(node);
+                break;
+            case 278 /* SyntaxKind.ExportAssignment */:
+                this.bindExportAssignment(node);
+                break;
+            case 307 /* SyntaxKind.SourceFile */:
+                this.bindSourceFileIfExternalModule(node);
+                break;
+            case 293 /* SyntaxKind.JsxAttributes */:
+                this.bindAnonymousDeclaration(node, 4096 /* SymbolFlags.ObjectLiteral */, "\uFFFEjsxAttributes" /* InternalSymbolName.JSXAttributes */);
+                break;
+            case 292 /* SyntaxKind.JsxAttribute */:
+                this.declareSymbolAndAddToSymbolTable(node, 4 /* SymbolFlags.Property */, 13243 /* SymbolFlags.PropertyExcludes */);
+                break;
+        }
+        // Then bind the children, tracking the current container. Tokens have no children.
+        let thisNodeOrAnySubnodesHasError = (node.flags & 32768 /* NodeFlags.ThisNodeHasError */) !== 0;
+        if (node.kind > 166 /* SyntaxKind.LastToken */) {
+            const saveSeenParseError = this.seenParseError;
+            this.seenParseError = false;
+            const containerFlags = getContainerFlags(node);
+            if (containerFlags === 0 /* ContainerFlags.None */)
+                this.bindChildren(node);
+            else
+                this.bindContainer(node, containerFlags);
+            if (this.seenParseError)
+                thisNodeOrAnySubnodesHasError = true;
+            this.seenParseError = saveSeenParseError;
+        }
+        if (thisNodeOrAnySubnodesHasError) {
+            node.flags |= 131072 /* NodeFlags.ThisNodeOrAnySubNodesHasError */;
+            this.seenParseError = true;
+        }
+    }
+    /**
+     * Binds the children of a container. Containers are chained in declaration order for the
+     * checker's local name lookups.
+     */
+    bindContainer(node, containerFlags) {
+        const saveContainer = this.container;
+        const saveThisContainer = this.thisContainer;
+        const saveBlockScopeContainer = this.blockScopeContainer;
+        // Locals are created on first use, so block-scoped containers without declarations stay cheap.
+        if ((containerFlags & 1 /* ContainerFlags.IsContainer */) !== 0) {
+            this.container = node;
+            this.blockScopeContainer = node;
+            if ((containerFlags & 32 /* ContainerFlags.HasLocals */) !== 0)
+                this.addToContainerChain(node);
+        }
+        else if ((containerFlags & 2 /* ContainerFlags.IsBlockScopedContainer */) !== 0) {
+            this.blockScopeContainer = node;
+            this.addToContainerChain(node);
+        }
+        if ((containerFlags & 256 /* ContainerFlags.IsThisContainer */) !== 0)
+            this.thisContainer = node;
+        if ((containerFlags & 4 /* ContainerFlags.IsControlFlowContainer */) !== 0)
+            this.bindControlFlowContainer(node, containerFlags);
+        else if ((containerFlags & 64 /* ContainerFlags.IsInterface */) !== 0) {
+            const saveSeenThisKeyword = this.seenThisKeyword;
+            this.seenThisKeyword = false;
+            this.bindChildren(node);
+            // ContainsThis can't overlap with HasExtendedUnicodeEscape, which is for identifiers.
+            if (this.seenThisKeyword)
+                node.flags |= 128 /* NodeFlags.ContainsThis */;
+            else
+                node.flags &= ~128 /* NodeFlags.ContainsThis */;
+            this.seenThisKeyword = saveSeenThisKeyword;
+        }
+        else
+            this.bindChildren(node);
+        if (node.kind === 307 /* SyntaxKind.SourceFile */)
+            this.finishSourceFile(node);
+        else if (isAmbientModule(node))
+            this.bindCommonJSTypeExports(getSymbol(node));
+        this.container = saveContainer;
+        this.thisContainer = saveThisContainer;
+        this.blockScopeContainer = saveBlockScopeContainer;
+    }
+    bindControlFlowContainer(node, containerFlags) {
+        const saveCurrentFlow = this.currentFlow;
+        const saveBreakTarget = this.currentBreakTarget;
+        const saveContinueTarget = this.currentContinueTarget;
+        const saveReturnTarget = this.currentReturnTarget;
+        const saveExceptionTarget = this.currentExceptionTarget;
+        const saveActiveLabelList = this.activeLabelList;
+        const saveHasExplicitReturn = this.hasExplicitReturn;
+        const saveSeenThisKeyword = this.seenThisKeyword;
+        // A non-async, non-generator IIFE is part of the containing control flow; its returns act
+        // like breaks to a label past the body.
+        const isImmediatelyInvoked = ((containerFlags & 16 /* ContainerFlags.IsFunctionExpression */) !== 0 &&
+            !hasSyntacticModifier(node, 1024 /* ModifierFlags.Async */) &&
+            !isGeneratorFunctionExpression(node) &&
+            getImmediatelyInvokedFunctionExpression(node) !== undefined) ||
+            node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */;
+        if (!isImmediatelyInvoked) {
+            const flowStart = new FlowNode(2 /* FlowFlags.Start */, undefined, undefined);
+            this.currentFlow = flowStart;
+            if ((containerFlags &
+                (16 /* ContainerFlags.IsFunctionExpression */ | 128 /* ContainerFlags.IsObjectLiteralOrClassExpressionMethodOrAccessor */)) !==
+                0)
+                flowStart.node = node;
+        }
+        // IIFEs and constructors get a return graph; constructors use it to check property initialization.
+        this.currentReturnTarget =
+            isImmediatelyInvoked || node.kind === 177 /* SyntaxKind.Constructor */ ? this.createBranchLabel() : undefined;
+        this.currentExceptionTarget = undefined;
+        this.currentBreakTarget = undefined;
+        this.currentContinueTarget = undefined;
+        this.activeLabelList = undefined;
+        this.hasExplicitReturn = false;
+        this.seenThisKeyword = false;
+        this.bindChildren(node);
+        node.flags &= ~(262912 /* NodeFlags.ReachabilityAndEmitFlags */ | 128 /* NodeFlags.ContainsThis */);
+        if ((this.currentFlow.flags & 1 /* FlowFlags.Unreachable */) === 0 &&
+            (containerFlags & 8 /* ContainerFlags.IsFunctionLike */) !== 0 &&
+            node.kind !== 176 /* SyntaxKind.ClassStaticBlockDeclaration */ &&
+            nodeIsPresent(getBody(node))) {
+            node.flags |= 256 /* NodeFlags.HasImplicitReturn */;
+            if (this.hasExplicitReturn)
+                node.flags |= 512 /* NodeFlags.HasExplicitReturn */;
+            setEndFlowNode(node, this.currentFlow);
+        }
+        if (this.seenThisKeyword)
+            node.flags |= 128 /* NodeFlags.ContainsThis */;
+        if (node.kind === 307 /* SyntaxKind.SourceFile */) {
+            node.flags |= this.emitFlags;
+            node.endFlowNode = this.currentFlow;
+        }
+        const returnTarget = this.currentReturnTarget;
+        if (returnTarget !== undefined) {
+            this.addAntecedent(returnTarget, this.currentFlow);
+            this.currentFlow = this.finishFlowLabel(returnTarget);
+            if (node.kind === 177 /* SyntaxKind.Constructor */ || node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                setReturnFlowNode(node, this.currentFlow);
+        }
+        if (!isImmediatelyInvoked)
+            this.currentFlow = saveCurrentFlow;
+        this.currentBreakTarget = saveBreakTarget;
+        this.currentContinueTarget = saveContinueTarget;
+        this.currentReturnTarget = saveReturnTarget;
+        this.currentExceptionTarget = saveExceptionTarget;
+        this.activeLabelList = saveActiveLabelList;
+        this.hasExplicitReturn = saveHasExplicitReturn;
+        this.seenThisKeyword =
+            (containerFlags & 512 /* ContainerFlags.PropagatesThisKeyword */) !== 0
+                ? saveSeenThisKeyword || this.seenThisKeyword
+                : saveSeenThisKeyword;
+    }
+    finishSourceFile(file) {
+        if (isInJSFile(file)) {
+            // Top-level @typedef aliases wait until CommonJS module indicators are known.
+            for (const statement of file.statements.nodes)
+                if (statement.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+                    this.bindBlockScopedDeclaration(statement, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */);
+            if (file.commonJSModuleIndicator !== undefined) {
+                this.declareCommonJSVariable('module');
+                this.declareCommonJSVariable('exports');
+            }
+        }
+        if (isExternalOrCommonJSModule(file))
+            this.bindCommonJSTypeExports(file.symbol);
+    }
+    declareCommonJSVariable(name) {
+        const locals = this.localsOf(this.file);
+        if (locals.has(name))
+            return;
+        const symbol = this.newSymbol(1 /* SymbolFlags.FunctionScopedVariable */ | 134217728 /* SymbolFlags.ModuleExports */, name);
+        addDeclaration(symbol, this.file);
+        symbol.valueDeclaration = this.file;
+        if (name === 'module') {
+            const exportsProperty = this.newSymbol(134217728 /* SymbolFlags.ModuleExports */ | 4 /* SymbolFlags.Property */, 'exports');
+            exportsProperty.declarations = symbol.declarations;
+            exportsProperty.valueDeclaration = this.file;
+            exportsProperty.parent = symbol;
+            getMembers(symbol).set('exports', exportsProperty);
+        }
+        locals.set(name, symbol);
+    }
+    addToContainerChain(next) {
+        const last = this.lastContainer;
+        if (last !== undefined)
+            setNextContainer(last, next);
+        this.lastContainer = next;
+    }
+    bindChildren(node) {
+        const saveInAssignmentPattern = this.inAssignmentPattern;
+        // Most nodes can't be in an assignment pattern; those that can restore it below.
+        this.inAssignmentPattern = false;
+        if (this.currentFlow === this.unreachableFlow) {
+            setFlowNode(node, undefined);
+            if (isPotentiallyExecutableNode(node))
+                node.flags |= 134217728 /* NodeFlags.Unreachable */;
+            node.forEachChild(this);
+            this.inAssignmentPattern = saveInAssignmentPattern;
+            return;
+        }
+        if (node.kind >= 244 /* SyntaxKind.FirstStatement */ && node.kind <= 260 /* SyntaxKind.LastStatement */)
+            setFlowNode(node, this.currentFlowValue());
+        switch (node.kind) {
+            case 248 /* SyntaxKind.WhileStatement */:
+                this.bindWhileStatement(node);
+                break;
+            case 247 /* SyntaxKind.DoStatement */:
+                this.bindDoStatement(node);
+                break;
+            case 249 /* SyntaxKind.ForStatement */:
+                this.bindForStatement(node);
+                break;
+            case 250 /* SyntaxKind.ForInStatement */:
+            case 251 /* SyntaxKind.ForOfStatement */:
+                this.bindForInOrForOfStatement(node);
+                break;
+            case 246 /* SyntaxKind.IfStatement */:
+                this.bindIfStatement(node);
+                break;
+            case 254 /* SyntaxKind.ReturnStatement */:
+                this.bindOptional(getExpression(node));
+                if (this.currentReturnTarget !== undefined)
+                    this.addAntecedent(this.currentReturnTarget, this.currentFlow);
+                this.currentFlow = this.unreachableFlow;
+                this.hasExplicitReturn = true;
+                this.hasFlowEffects = true;
+                break;
+            case 258 /* SyntaxKind.ThrowStatement */:
+                this.bindOptional(getExpression(node));
+                this.currentFlow = this.unreachableFlow;
+                this.hasFlowEffects = true;
+                break;
+            case 253 /* SyntaxKind.BreakStatement */:
+                this.bindBreakOrContinueStatement(getLabel(node), true);
+                break;
+            case 252 /* SyntaxKind.ContinueStatement */:
+                this.bindBreakOrContinueStatement(getLabel(node), false);
+                break;
+            case 259 /* SyntaxKind.TryStatement */:
+                this.bindTryStatement(node);
+                break;
+            case 256 /* SyntaxKind.SwitchStatement */:
+                this.bindSwitchStatement(node);
+                break;
+            case 270 /* SyntaxKind.CaseBlock */:
+                this.bindCaseBlock(node);
+                break;
+            case 297 /* SyntaxKind.CaseClause */:
+            case 298 /* SyntaxKind.DefaultClause */:
+                this.bindCaseOrDefaultClause(node);
+                break;
+            case 245 /* SyntaxKind.ExpressionStatement */: {
+                const expression = node.expression;
+                this.bind(expression);
+                this.maybeBindExpressionFlowIfCall(expression);
+                break;
+            }
+            case 257 /* SyntaxKind.LabeledStatement */:
+                this.bindLabeledStatement(node);
+                break;
+            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+                this.bindPrefixUnaryExpressionFlow(node);
+                break;
+            case 226 /* SyntaxKind.PostfixUnaryExpression */: {
+                node.forEachChild(this);
+                const operator = node.operator;
+                if (operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */)
+                    this.bindAssignmentTargetFlow(node.operand);
+                break;
+            }
+            case 227 /* SyntaxKind.BinaryExpression */:
+                if (isDestructuringAssignment(node)) {
+                    // Carry the assignment pattern state into initializers of the pattern.
+                    this.inAssignmentPattern = saveInAssignmentPattern;
+                    this.bindDestructuringAssignmentFlow(node);
+                    return;
+                }
+                this.bindBinaryExpressionFlow(node);
+                break;
+            case 221 /* SyntaxKind.DeleteExpression */:
+                node.forEachChild(this);
+                if (node.expression.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+                    this.bindAssignmentTargetFlow(node.expression);
+                break;
+            case 228 /* SyntaxKind.ConditionalExpression */:
+                this.bindConditionalExpressionFlow(node);
+                break;
+            case 261 /* SyntaxKind.VariableDeclaration */:
+                node.forEachChild(this);
+                if (node.initializer !== undefined ||
+                    isForInOrOfStatementKind(node.parent.parent.kind))
+                    this.bindInitializedVariableFlow(node);
+                break;
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 236 /* SyntaxKind.NonNullExpression */:
+                if (isOptionalChain(node))
+                    this.bindOptionalChainFlow(node);
+                else
+                    node.forEachChild(this);
+                break;
+            case 214 /* SyntaxKind.CallExpression */:
+                this.bindCallExpressionFlow(node);
+                break;
+            case 307 /* SyntaxKind.SourceFile */:
+                this.bindEachStatementFunctionsFirst(node.statements);
+                this.bind(node.endOfFileToken);
+                break;
+            case 242 /* SyntaxKind.Block */:
+            case 269 /* SyntaxKind.ModuleBlock */:
+                this.bindEachStatementFunctionsFirst(getStatements(node));
+                break;
+            case 209 /* SyntaxKind.BindingElement */: {
+                // The initializer runs before the binding pattern.
+                const element = node;
+                this.bindOptional(element.dotDotDotToken);
+                this.bindOptional(element.propertyName);
+                this.bindInitializer(element.initializer);
+                this.bindOptional(element.name);
+                break;
+            }
+            case 170 /* SyntaxKind.Parameter */: {
+                const parameter = node;
+                this.bindNodes(parameter.modifiers);
+                this.bindOptional(parameter.dotDotDotToken);
+                this.bindOptional(parameter.questionToken);
+                this.bindOptional(parameter.type);
+                this.bindInitializer(parameter.initializer);
+                this.bind(parameter.name);
+                break;
+            }
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 231 /* SyntaxKind.SpreadElement */:
+                this.inAssignmentPattern = saveInAssignmentPattern;
+                node.forEachChild(this);
+                break;
+            default:
+                node.forEachChild(this);
+        }
+        this.inAssignmentPattern = saveInAssignmentPattern;
+    }
+    bindNodes(list) {
+        if (list === undefined)
+            return;
+        const nodes = list.nodes;
+        for (let i = 0; i < nodes.length; i++)
+            this.bind(nodes[i]);
+    }
+    bindEachStatementFunctionsFirst(statements) {
+        const nodes = statements.nodes;
+        for (let i = 0; i < nodes.length; i++)
+            if (nodes[i].kind === 263 /* SyntaxKind.FunctionDeclaration */)
+                this.bind(nodes[i]);
+        for (let i = 0; i < nodes.length; i++)
+            if (nodes[i].kind !== 263 /* SyntaxKind.FunctionDeclaration */)
+                this.bind(nodes[i]);
+    }
+    // Flow graph
+    createBranchLabel() {
+        return new FlowNode(4 /* FlowFlags.BranchLabel */, undefined, undefined);
+    }
+    createLoopLabel() {
+        return new FlowNode(8 /* FlowFlags.LoopLabel */, undefined, undefined);
+    }
+    createFlowCondition(flags, antecedent, expression) {
+        if ((antecedent.flags & 1 /* FlowFlags.Unreachable */) !== 0)
+            return antecedent;
+        if (expression === undefined)
+            return (flags & 32 /* FlowFlags.TrueCondition */) !== 0 ? antecedent : this.unreachableFlow;
+        if (((expression.kind === 111 /* SyntaxKind.TrueKeyword */ && (flags & 64 /* FlowFlags.FalseCondition */) !== 0) ||
+            (expression.kind === 96 /* SyntaxKind.FalseKeyword */ && (flags & 32 /* FlowFlags.TrueCondition */) !== 0)) &&
+            !isExpressionOfOptionalChainRoot(expression) &&
+            !isNullishCoalesce(expression.parent))
+            return this.unreachableFlow;
+        if (!isNarrowingExpression(expression))
+            return antecedent;
+        setFlowNodeReferenced(antecedent);
+        return new FlowNode(flags, expression, antecedent);
+    }
+    createFlowMutation(flags, antecedent, node) {
+        setFlowNodeReferenced(antecedent);
+        this.hasFlowEffects = true;
+        const result = new FlowNode(flags, node, antecedent);
+        if (this.currentExceptionTarget !== undefined)
+            this.addAntecedent(this.currentExceptionTarget, result);
+        return result;
+    }
+    createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) {
+        setFlowNodeReferenced(antecedent);
+        return new FlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd);
+    }
+    createFlowCall(antecedent, node) {
+        setFlowNodeReferenced(antecedent);
+        this.hasFlowEffects = true;
+        return new FlowNode(512 /* FlowFlags.Call */, node, antecedent);
+    }
+    /** Adds `antecedent` to the end of the label's antecedents, unless unreachable or already there. */
+    addAntecedent(label, antecedent) {
+        if ((antecedent.flags & 1 /* FlowFlags.Unreachable */) !== 0)
+            return;
+        const antecedents = label.antecedents;
+        if (antecedents === undefined)
+            label.antecedents = [antecedent];
+        else {
+            if (antecedents.indexOf(antecedent) >= 0)
+                return;
+            antecedents.push(antecedent);
+        }
+        setFlowNodeReferenced(antecedent);
+    }
+    /** The label, its only antecedent, or unreachable if it has none. */
+    finishFlowLabel(label) {
+        const antecedents = label.antecedents;
+        if (antecedents === undefined)
+            return this.unreachableFlow;
+        if (antecedents.length === 1)
+            return antecedents[0];
+        return label;
+    }
+    setContinueTarget(node, target) {
+        let label = this.activeLabelList;
+        let current = node;
+        while (label !== undefined && current.parent.kind === 257 /* SyntaxKind.LabeledStatement */) {
+            label.continueTarget = target;
+            label = label.next;
+            current = current.parent;
+        }
+        return target;
+    }
+    /** Binds `node` with `trueTarget` and `falseTarget` as the condition's targets. */
+    bindWithTargets(node, trueTarget, falseTarget) {
+        const savedTrueTarget = this.currentTrueTarget;
+        const savedFalseTarget = this.currentFalseTarget;
+        this.currentTrueTarget = trueTarget;
+        this.currentFalseTarget = falseTarget;
+        this.bindOptional(node);
+        this.currentTrueTarget = savedTrueTarget;
+        this.currentFalseTarget = savedFalseTarget;
+    }
+    bindCondition(node, trueTarget, falseTarget) {
+        this.bindWithTargets(node, trueTarget, falseTarget);
+        if (node === undefined ||
+            (!isLogicalOrCoalescingAssignmentExpression(skipParentheses(node)) &&
+                !isLogicalExpression(node) &&
+                !(isOptionalChain(node) && isOutermostOptionalChain(node)))) {
+            this.addAntecedent(trueTarget, this.createFlowCondition(32 /* FlowFlags.TrueCondition */, this.currentFlow, node));
+            this.addAntecedent(falseTarget, this.createFlowCondition(64 /* FlowFlags.FalseCondition */, this.currentFlow, node));
+        }
+    }
+    bindIterativeStatement(node, breakTarget, continueTarget) {
+        const saveBreakTarget = this.currentBreakTarget;
+        const saveContinueTarget = this.currentContinueTarget;
+        this.currentBreakTarget = breakTarget;
+        this.currentContinueTarget = continueTarget;
+        this.bind(node);
+        this.currentBreakTarget = saveBreakTarget;
+        this.currentContinueTarget = saveContinueTarget;
+    }
+    bindAssignmentTargetFlow(node) {
+        switch (node.kind) {
+            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+                for (const element of getElements(node).nodes) {
+                    if (element.kind === 231 /* SyntaxKind.SpreadElement */)
+                        this.bindAssignmentTargetFlow(getExpression(element));
+                    else
+                        this.bindDestructuringTargetFlow(element);
+                }
+                break;
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+                for (const property of getProperties(node).nodes) {
+                    switch (property.kind) {
+                        case 303 /* SyntaxKind.PropertyAssignment */:
+                            this.bindDestructuringTargetFlow(getInitializer(property));
+                            break;
+                        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+                            this.bindAssignmentTargetFlow(getName(property));
+                            break;
+                        case 305 /* SyntaxKind.SpreadAssignment */:
+                            this.bindAssignmentTargetFlow(getExpression(property));
+                            break;
+                    }
+                }
+                break;
+            default:
+                if (isNarrowableReference(node))
+                    this.currentFlow = this.createFlowMutation(16 /* FlowFlags.Assignment */, this.currentFlow, node);
+        }
+    }
+    bindDestructuringTargetFlow(node) {
+        if (node instanceof BinaryExpression && node.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */)
+            this.bindAssignmentTargetFlow(node.left);
+        else
+            this.bindAssignmentTargetFlow(node);
+    }
+    bindWhileStatement(node) {
+        const preWhileLabel = this.setContinueTarget(node, this.createLoopLabel());
+        const preBodyLabel = this.createBranchLabel();
+        const postWhileLabel = this.createBranchLabel();
+        this.addAntecedent(preWhileLabel, this.currentFlow);
+        this.currentFlow = preWhileLabel;
+        this.bindCondition(node.expression, preBodyLabel, postWhileLabel);
+        this.currentFlow = this.finishFlowLabel(preBodyLabel);
+        this.bindIterativeStatement(node.statement, postWhileLabel, preWhileLabel);
+        this.addAntecedent(preWhileLabel, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(postWhileLabel);
+    }
+    bindDoStatement(node) {
+        const preDoLabel = this.createLoopLabel();
+        const preConditionLabel = this.setContinueTarget(node, this.createBranchLabel());
+        const postDoLabel = this.createBranchLabel();
+        this.addAntecedent(preDoLabel, this.currentFlow);
+        this.currentFlow = preDoLabel;
+        this.bindIterativeStatement(node.statement, postDoLabel, preConditionLabel);
+        this.addAntecedent(preConditionLabel, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(preConditionLabel);
+        this.bindCondition(node.expression, preDoLabel, postDoLabel);
+        this.currentFlow = this.finishFlowLabel(postDoLabel);
+    }
+    bindForStatement(node) {
+        const preLoopLabel = this.setContinueTarget(node, this.createLoopLabel());
+        const preBodyLabel = this.createBranchLabel();
+        const preIncrementorLabel = this.createBranchLabel();
+        const postLoopLabel = this.createBranchLabel();
+        this.bindOptional(node.initializer);
+        this.addAntecedent(preLoopLabel, this.currentFlow);
+        this.currentFlow = preLoopLabel;
+        this.bindCondition(node.condition, preBodyLabel, postLoopLabel);
+        this.currentFlow = this.finishFlowLabel(preBodyLabel);
+        this.bindIterativeStatement(node.statement, postLoopLabel, preIncrementorLabel);
+        this.addAntecedent(preIncrementorLabel, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(preIncrementorLabel);
+        this.bindOptional(node.incrementor);
+        this.addAntecedent(preLoopLabel, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(postLoopLabel);
+    }
+    bindForInOrForOfStatement(node) {
+        const preLoopLabel = this.setContinueTarget(node, this.createLoopLabel());
+        const postLoopLabel = this.createBranchLabel();
+        this.bind(node.expression);
+        this.addAntecedent(preLoopLabel, this.currentFlow);
+        this.currentFlow = preLoopLabel;
+        if (node.kind === 251 /* SyntaxKind.ForOfStatement */)
+            this.bindOptional(node.awaitModifier);
+        this.addAntecedent(postLoopLabel, this.currentFlow);
+        this.bind(node.initializer);
+        if (node.initializer.kind !== 262 /* SyntaxKind.VariableDeclarationList */)
+            this.bindAssignmentTargetFlow(node.initializer);
+        this.bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
+        this.addAntecedent(preLoopLabel, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(postLoopLabel);
+    }
+    bindIfStatement(node) {
+        const thenLabel = this.createBranchLabel();
+        const elseLabel = this.createBranchLabel();
+        const postIfLabel = this.createBranchLabel();
+        this.bindCondition(node.expression, thenLabel, elseLabel);
+        this.currentFlow = this.finishFlowLabel(thenLabel);
+        this.bind(node.thenStatement);
+        this.addAntecedent(postIfLabel, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(elseLabel);
+        this.bindOptional(node.elseStatement);
+        this.addAntecedent(postIfLabel, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(postIfLabel);
+    }
+    bindBreakOrContinueStatement(label, isBreak) {
+        this.bindOptional(label);
+        if (label !== undefined) {
+            const name = getText(label);
+            let activeLabel = this.activeLabelList;
+            while (activeLabel !== undefined && activeLabel.name !== name)
+                activeLabel = activeLabel.next;
+            if (activeLabel !== undefined) {
+                activeLabel.referenced = true;
+                this.bindBreakOrContinueFlow(isBreak ? activeLabel.breakTarget : activeLabel.continueTarget);
+            }
+        }
+        else
+            this.bindBreakOrContinueFlow(isBreak ? this.currentBreakTarget : this.currentContinueTarget);
+    }
+    bindBreakOrContinueFlow(flowLabel) {
+        if (flowLabel === undefined)
+            return;
+        this.addAntecedent(flowLabel, this.currentFlow);
+        this.currentFlow = this.unreachableFlow;
+        this.hasFlowEffects = true;
+    }
+    /**
+     * Any code in a `try` block may throw, but only mutations change narrowed types, so the
+     * exception label collects the mutations (and the flow before them) as antecedents of the
+     * `catch` or `finally` block.
+     */
+    bindTryStatement(node) {
+        const saveReturnTarget = this.currentReturnTarget;
+        const saveExceptionTarget = this.currentExceptionTarget;
+        const normalExitLabel = this.createBranchLabel();
+        const returnLabel = this.createBranchLabel();
+        let exceptionLabel = this.createBranchLabel();
+        if (node.finallyBlock !== undefined)
+            this.currentReturnTarget = returnLabel;
+        this.addAntecedent(exceptionLabel, this.currentFlow);
+        this.currentExceptionTarget = exceptionLabel;
+        this.bind(node.tryBlock);
+        this.addAntecedent(normalExitLabel, this.currentFlow);
+        if (node.catchClause !== undefined) {
+            // The catch clause starts with the exceptions of the try block and acts like a second try block.
+            this.currentFlow = this.finishFlowLabel(exceptionLabel);
+            exceptionLabel = this.createBranchLabel();
+            this.addAntecedent(exceptionLabel, this.currentFlow);
+            this.currentExceptionTarget = exceptionLabel;
+            this.bind(node.catchClause);
+            this.addAntecedent(normalExitLabel, this.currentFlow);
+        }
+        this.currentReturnTarget = saveReturnTarget;
+        this.currentExceptionTarget = saveExceptionTarget;
+        if (node.finallyBlock === undefined) {
+            this.currentFlow = this.finishFlowLabel(normalExitLabel);
+            return;
+        }
+        // The finally block is reached by normal completion of the try or catch block, by returns in
+        // them, and by exceptions in them. Analysis that starts past the finally block only considers
+        // normal completion, and returns from an IIFE only the returns, so ReduceLabel nodes give the
+        // finally label a reduced set of antecedents for those paths.
+        const finallyLabel = this.createBranchLabel();
+        finallyLabel.antecedents = combineFlowLists(normalExitLabel.antecedents, combineFlowLists(exceptionLabel.antecedents, returnLabel.antecedents));
+        this.currentFlow = finallyLabel;
+        this.bind(node.finallyBlock);
+        if ((this.currentFlow.flags & 1 /* FlowFlags.Unreachable */) !== 0) {
+            // An unreachable end of the finally block makes the end of the try statement unreachable.
+            this.currentFlow = this.unreachableFlow;
+            return;
+        }
+        // Returns in the try or catch block of an IIFE continue through the finally block.
+        if (this.currentReturnTarget !== undefined && returnLabel.antecedents !== undefined)
+            this.addAntecedent(this.currentReturnTarget, new FlowReduceLabel(finallyLabel, returnLabel.antecedents, this.currentFlow));
+        // So do exceptions, to an enclosing try statement.
+        if (this.currentExceptionTarget !== undefined && exceptionLabel.antecedents !== undefined)
+            this.addAntecedent(this.currentExceptionTarget, new FlowReduceLabel(finallyLabel, exceptionLabel.antecedents, this.currentFlow));
+        // `try { return 1; } finally { … }` ends unreachable.
+        this.currentFlow =
+            normalExitLabel.antecedents !== undefined
+                ? new FlowReduceLabel(finallyLabel, normalExitLabel.antecedents, this.currentFlow)
+                : this.unreachableFlow;
+    }
+    bindSwitchStatement(node) {
+        const postSwitchLabel = this.createBranchLabel();
+        this.bind(node.expression);
+        const saveBreakTarget = this.currentBreakTarget;
+        const savePreSwitchCaseFlow = this.preSwitchCaseFlow;
+        this.currentBreakTarget = postSwitchLabel;
+        this.preSwitchCaseFlow = this.currentFlow;
+        this.bind(node.caseBlock);
+        this.addAntecedent(postSwitchLabel, this.currentFlow);
+        let hasDefault = false;
+        for (const clause of node.caseBlock.clauses.nodes)
+            if (clause.kind === 298 /* SyntaxKind.DefaultClause */)
+                hasDefault = true;
+        if (!hasDefault)
+            this.addAntecedent(postSwitchLabel, this.createFlowSwitchClause(this.preSwitchCaseFlow, node, 0, 0));
+        this.currentBreakTarget = saveBreakTarget;
+        this.preSwitchCaseFlow = savePreSwitchCaseFlow;
+        this.currentFlow = this.finishFlowLabel(postSwitchLabel);
+    }
+    bindCaseBlock(node) {
+        const switchStatement = node.parent;
+        const clauses = node.clauses.nodes;
+        const switchExpression = switchStatement.expression;
+        const isNarrowingSwitch = switchExpression.kind === 111 /* SyntaxKind.TrueKeyword */ || isNarrowingExpression(switchExpression);
+        let fallthroughFlow = this.unreachableFlow;
+        for (let i = 0; i < clauses.length; i++) {
+            const clauseStart = i;
+            while (clauses[i].statements.nodes.length === 0 && i + 1 < clauses.length) {
+                if (fallthroughFlow === this.unreachableFlow)
+                    this.currentFlow = this.preSwitchCaseFlow;
+                this.bind(clauses[i]);
+                i++;
+            }
+            const preCaseLabel = this.createBranchLabel();
+            const preCaseFlow = isNarrowingSwitch
+                ? this.createFlowSwitchClause(this.preSwitchCaseFlow, switchStatement, clauseStart, i + 1)
+                : this.preSwitchCaseFlow;
+            this.addAntecedent(preCaseLabel, preCaseFlow);
+            this.addAntecedent(preCaseLabel, fallthroughFlow);
+            this.currentFlow = this.finishFlowLabel(preCaseLabel);
+            const clause = clauses[i];
+            this.bind(clause);
+            fallthroughFlow = this.currentFlow;
+            if ((this.currentFlow.flags & 1 /* FlowFlags.Unreachable */) === 0 && i !== clauses.length - 1)
+                clause.fallthroughFlowNode = this.currentFlow;
+        }
+    }
+    bindCaseOrDefaultClause(node) {
+        if (node.expression !== undefined) {
+            const saveCurrentFlow = this.currentFlow;
+            this.currentFlow = this.preSwitchCaseFlow;
+            this.bind(node.expression);
+            this.currentFlow = saveCurrentFlow;
+        }
+        this.bindNodes(node.statements);
+    }
+    /** A top-level or comma call with a dotted callee may be an assertion, so it joins the flow graph. */
+    maybeBindExpressionFlowIfCall(node) {
+        if (node instanceof CallExpression) {
+            const call = node;
+            const callee = call.expression;
+            if (callee.kind !== 107 /* SyntaxKind.SuperKeyword */ && isDottedName(callee))
+                this.currentFlow = this.createFlowCall(this.currentFlow, node);
+        }
+    }
+    bindLabeledStatement(node) {
+        const postStatementLabel = this.createBranchLabel();
+        const activeLabel = new ActiveLabel(this.activeLabelList, node.label.text, postStatementLabel);
+        this.activeLabelList = activeLabel;
+        this.bind(node.label);
+        this.bind(node.statement);
+        // An unused label; the checker decides whether to report it.
+        if (!activeLabel.referenced)
+            node.label.flags |= 134217728 /* NodeFlags.Unreachable */;
+        this.activeLabelList = activeLabel.next;
+        this.addAntecedent(postStatementLabel, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(postStatementLabel);
+    }
+    bindPrefixUnaryExpressionFlow(node) {
+        if (node.operator === 53 /* SyntaxKind.ExclamationToken */) {
+            const saveTrueTarget = this.currentTrueTarget;
+            this.currentTrueTarget = this.currentFalseTarget;
+            this.currentFalseTarget = saveTrueTarget;
+            node.forEachChild(this);
+            this.currentFalseTarget = this.currentTrueTarget;
+            this.currentTrueTarget = saveTrueTarget;
+        }
+        else {
+            node.forEachChild(this);
+            if (node.operator === 45 /* SyntaxKind.PlusPlusToken */ || node.operator === 46 /* SyntaxKind.MinusMinusToken */)
+                this.bindAssignmentTargetFlow(node.operand);
+        }
+    }
+    bindDestructuringAssignmentFlow(node) {
+        if (this.inAssignmentPattern) {
+            this.inAssignmentPattern = false;
+            this.bind(node.operatorToken);
+            this.bind(node.right);
+            this.inAssignmentPattern = true;
+            this.bind(node.left);
+            this.bindOptional(node.type);
+        }
+        else {
+            this.inAssignmentPattern = true;
+            this.bind(node.left);
+            this.bindOptional(node.type);
+            this.inAssignmentPattern = false;
+            this.bind(node.operatorToken);
+            this.bind(node.right);
+        }
+        this.bindAssignmentTargetFlow(node.left);
+    }
+    bindBinaryExpressionFlow(node) {
+        const operator = node.operatorToken.kind;
+        if (isLogicalOrCoalescingBinaryOperator(operator) || isLogicalOrCoalescingAssignmentOperator(operator)) {
+            if (isTopLevelLogicalExpression(node)) {
+                const postExpressionLabel = this.createBranchLabel();
+                const saveCurrentFlow = this.currentFlow;
+                const saveHasFlowEffects = this.hasFlowEffects;
+                this.hasFlowEffects = false;
+                this.bindLogicalLikeExpression(node, postExpressionLabel, postExpressionLabel);
+                this.currentFlow = this.hasFlowEffects ? this.finishFlowLabel(postExpressionLabel) : saveCurrentFlow;
+                this.hasFlowEffects = this.hasFlowEffects || saveHasFlowEffects;
+            }
+            else
+                this.bindLogicalLikeExpression(node, this.currentTrueTarget, this.currentFalseTarget);
+            return;
+        }
+        this.bind(node.left);
+        this.bindOptional(node.type);
+        if (operator === 27 /* SyntaxKind.CommaToken */)
+            this.maybeBindExpressionFlowIfCall(node.left);
+        this.bind(node.operatorToken);
+        this.bind(node.right);
+        if (operator === 27 /* SyntaxKind.CommaToken */)
+            this.maybeBindExpressionFlowIfCall(node.right);
+        if (isAssignmentOperator(operator) && !isAssignmentTarget(node)) {
+            this.bindAssignmentTargetFlow(node.left);
+            const left = node.left;
+            if (operator === 63 /* SyntaxKind.EqualsToken */ &&
+                left instanceof ElementAccessExpression &&
+                isNarrowableOperand(left.expression))
+                this.currentFlow = this.createFlowMutation(256 /* FlowFlags.ArrayMutation */, this.currentFlow, node);
+        }
+    }
+    bindLogicalLikeExpression(node, trueTarget, falseTarget) {
+        const preRightLabel = this.createBranchLabel();
+        const operator = node.operatorToken.kind;
+        if (operator === 55 /* SyntaxKind.AmpersandAmpersandToken */ || operator === 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */)
+            this.bindCondition(node.left, preRightLabel, falseTarget);
+        else
+            this.bindCondition(node.left, trueTarget, preRightLabel);
+        this.currentFlow = this.finishFlowLabel(preRightLabel);
+        this.bind(node.operatorToken);
+        if (isLogicalOrCoalescingAssignmentOperator(operator)) {
+            this.bindWithTargets(node.right, trueTarget, falseTarget);
+            this.bindAssignmentTargetFlow(node.left);
+            this.addAntecedent(trueTarget, this.createFlowCondition(32 /* FlowFlags.TrueCondition */, this.currentFlow, node));
+            this.addAntecedent(falseTarget, this.createFlowCondition(64 /* FlowFlags.FalseCondition */, this.currentFlow, node));
+        }
+        else
+            this.bindCondition(node.right, trueTarget, falseTarget);
+    }
+    bindConditionalExpressionFlow(node) {
+        const trueLabel = this.createBranchLabel();
+        const falseLabel = this.createBranchLabel();
+        const postExpressionLabel = this.createBranchLabel();
+        const saveCurrentFlow = this.currentFlow;
+        const saveHasFlowEffects = this.hasFlowEffects;
+        this.hasFlowEffects = false;
+        this.bindCondition(node.condition, trueLabel, falseLabel);
+        this.currentFlow = this.finishFlowLabel(trueLabel);
+        this.bind(node.questionToken);
+        this.bind(node.whenTrue);
+        this.addAntecedent(postExpressionLabel, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(falseLabel);
+        this.bind(node.colonToken);
+        this.bind(node.whenFalse);
+        this.addAntecedent(postExpressionLabel, this.currentFlow);
+        this.currentFlow = this.hasFlowEffects ? this.finishFlowLabel(postExpressionLabel) : saveCurrentFlow;
+        this.hasFlowEffects = this.hasFlowEffects || saveHasFlowEffects;
+    }
+    bindInitializedVariableFlow(node) {
+        const name = getName(node);
+        if (name !== undefined &&
+            (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)) {
+            for (const element of getElements(name).nodes)
+                this.bindInitializedVariableFlow(element);
+        }
+        else
+            this.currentFlow = this.createFlowMutation(16 /* FlowFlags.Assignment */, this.currentFlow, node);
+    }
+    bindOptionalChainFlow(node) {
+        if (isTopLevelLogicalExpression(node)) {
+            const postExpressionLabel = this.createBranchLabel();
+            const saveCurrentFlow = this.currentFlow;
+            const saveHasFlowEffects = this.hasFlowEffects;
+            this.bindOptionalChain(node, postExpressionLabel, postExpressionLabel);
+            this.currentFlow = this.hasFlowEffects ? this.finishFlowLabel(postExpressionLabel) : saveCurrentFlow;
+            this.hasFlowEffects = this.hasFlowEffects || saveHasFlowEffects;
+        }
+        else
+            this.bindOptionalChain(node, this.currentTrueTarget, this.currentFalseTarget);
+    }
+    /**
+     * Binds an optional chain like a logical expression: `a?.b.c` as `a && a.b.c`. The chain's
+     * root is the first condition and the rest of the chain is its true branch.
+     */
+    bindOptionalChain(node, trueTarget, falseTarget) {
+        const preChainLabel = isOptionalChainRoot(node) ? this.createBranchLabel() : undefined;
+        this.bindOptionalExpression(getExpression(node), preChainLabel ?? trueTarget, falseTarget);
+        if (preChainLabel !== undefined)
+            this.currentFlow = this.finishFlowLabel(preChainLabel);
+        const savedTrueTarget = this.currentTrueTarget;
+        const savedFalseTarget = this.currentFalseTarget;
+        this.currentTrueTarget = trueTarget;
+        this.currentFalseTarget = falseTarget;
+        this.bindOptionalChainRest(node);
+        this.currentTrueTarget = savedTrueTarget;
+        this.currentFalseTarget = savedFalseTarget;
+        if (isOutermostOptionalChain(node)) {
+            this.addAntecedent(trueTarget, this.createFlowCondition(32 /* FlowFlags.TrueCondition */, this.currentFlow, node));
+            this.addAntecedent(falseTarget, this.createFlowCondition(64 /* FlowFlags.FalseCondition */, this.currentFlow, node));
+        }
+    }
+    bindOptionalExpression(node, trueTarget, falseTarget) {
+        this.bindWithTargets(node, trueTarget, falseTarget);
+        if (!isOptionalChain(node) || isOutermostOptionalChain(node)) {
+            this.addAntecedent(trueTarget, this.createFlowCondition(32 /* FlowFlags.TrueCondition */, this.currentFlow, node));
+            this.addAntecedent(falseTarget, this.createFlowCondition(64 /* FlowFlags.FalseCondition */, this.currentFlow, node));
+        }
+    }
+    bindOptionalChainRest(node) {
+        if (node instanceof PropertyAccessExpression) {
+            this.bindOptional(node.questionDotToken);
+            this.bind(node.name);
+        }
+        else if (node instanceof ElementAccessExpression) {
+            this.bindOptional(node.questionDotToken);
+            this.bind(node.argumentExpression);
+        }
+        else if (node instanceof CallExpression) {
+            this.bindOptional(node.questionDotToken);
+            this.bindNodes(node.typeArguments);
+            this.bindNodes(node.arguments);
+        }
+    }
+    bindCallExpressionFlow(node) {
+        if (isOptionalChain(node))
+            this.bindOptionalChainFlow(node);
+        else {
+            // An IIFE's flow node includes the evaluation of its arguments.
+            const callee = skipParentheses(node.expression);
+            if (callee.kind === 219 /* SyntaxKind.FunctionExpression */ || callee.kind === 220 /* SyntaxKind.ArrowFunction */) {
+                this.bindNodes(node.typeArguments);
+                this.bindNodes(node.arguments);
+                this.bind(node.expression);
+            }
+            else {
+                node.forEachChild(this);
+                if (node.expression.kind === 107 /* SyntaxKind.SuperKeyword */)
+                    this.currentFlow = this.createFlowCall(this.currentFlow, node);
+            }
+        }
+        const callee = node.expression;
+        if (!(callee instanceof PropertyAccessExpression))
+            return;
+        // Typed locals keep scriptc's field reads static after `instanceof`.
+        const access = callee;
+        if (access.name.kind === 79 /* SyntaxKind.Identifier */ &&
+            isNarrowableOperand(access.expression) &&
+            isPushOrUnshiftIdentifier(access.name))
+            this.currentFlow = this.createFlowMutation(256 /* FlowFlags.ArrayMutation */, this.currentFlow, node);
+    }
+    /** Binds a parameter or binding element initializer, which only runs when the value is `undefined`. */
+    bindInitializer(node) {
+        if (node === undefined)
+            return;
+        const entryFlow = this.currentFlow;
+        this.bind(node);
+        if (entryFlow === this.unreachableFlow || entryFlow === this.currentFlow)
+            return;
+        const exitFlow = this.createBranchLabel();
+        this.addAntecedent(exitFlow, entryFlow);
+        this.addAntecedent(exitFlow, this.currentFlow);
+        this.currentFlow = this.finishFlowLabel(exitFlow);
+    }
+    // Declarations by kind
+    bindSourceFileIfExternalModule(file) {
+        this.setExportContextFlag(file);
+        if (isExternalOrCommonJSModule(file))
+            this.bindSourceFileAsExternalModule(file);
+        else if (isJsonSourceFile(file)) {
+            this.bindSourceFileAsExternalModule(file);
+            // The equivalent of `module.exports = {…}`.
+            const originalSymbol = file.symbol;
+            this.declareSymbol(getExports(originalSymbol), originalSymbol, file, 4 /* SymbolFlags.Property */, 1073741823 /* SymbolFlags.All */);
+            file.symbol = originalSymbol;
+        }
+    }
+    bindSourceFileAsExternalModule(file) {
+        this.bindAnonymousDeclaration(file, 512 /* SymbolFlags.ValueModule */, '"' + removeFileExtension(file.fileName) + '"');
+    }
+    bindModuleDeclaration(node) {
+        this.setExportContextFlag(node);
+        if (isAmbientModule(node)) {
+            if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+                this.errorOnFirstToken(node, 802 /* Diagnostics.X_export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible */, noArgs);
+            if (isModuleAugmentationExternal(node)) {
+                this.declareModuleSymbol(node);
+                return;
+            }
+            const symbol = this.declareSymbolAndAddToSymbolTable(node, 512 /* SymbolFlags.ValueModule */, 110735 /* SymbolFlags.ValueModuleExcludes */);
+            const name = node.name;
+            if (name.kind === 10 /* SyntaxKind.StringLiteral */) {
+                const text = getText(name);
+                const starIndex = text.indexOf('*');
+                if (starIndex >= 0 && text.indexOf('*', starIndex + 1) >= 0)
+                    this.errorOnFirstToken(name, 1136 /* Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character */, [text]);
+                else if (starIndex >= 0)
+                    this.file.patternAmbientModules.push(new PatternAmbientModule(text, starIndex, symbol));
+            }
+            return;
+        }
+        const state = this.declareModuleSymbol(node);
+        if (state === 1 /* ModuleInstanceState.NonInstantiated */)
+            return;
+        const symbol = getSymbol(node);
+        // A namespace merged with a function, class or regular enum isn't const-enum-only.
+        const constEnumOnlyModule = (symbol.flags & (16 /* SymbolFlags.Function */ | 32 /* SymbolFlags.Class */ | 256 /* SymbolFlags.RegularEnum */)) === 0 &&
+            state === 3 /* ModuleInstanceState.ConstEnumOnly */ &&
+            !this.notConstEnumOnlyModules.has(symbol);
+        if (constEnumOnlyModule)
+            symbol.flags |= 268435456 /* SymbolFlags.ConstEnumOnlyModule */;
+        else {
+            symbol.flags &= ~268435456 /* SymbolFlags.ConstEnumOnlyModule */;
+            this.notConstEnumOnlyModules.add(symbol);
+        }
+    }
+    declareModuleSymbol(node) {
+        const state = getModuleInstanceState(node, this.statementsByName);
+        const instantiated = state !== 1 /* ModuleInstanceState.NonInstantiated */;
+        this.declareSymbolAndAddToSymbolTable(node, instantiated ? 512 /* SymbolFlags.ValueModule */ : 1024 /* SymbolFlags.NamespaceModule */, instantiated ? 110735 /* SymbolFlags.ValueModuleExcludes */ : 0 /* SymbolFlags.NamespaceModuleExcludes */);
+        return state;
+    }
+    bindNamespaceExportDeclaration(node) {
+        const parent = node.parent;
+        if (getModifiers(node) !== undefined)
+            this.errorOnNode(node, 140 /* Diagnostics.Modifiers_cannot_appear_here */, noArgs);
+        if (parent.kind !== 307 /* SyntaxKind.SourceFile */)
+            this.errorOnNode(node, 252 /* Diagnostics.Global_module_exports_may_only_appear_at_top_level */, noArgs);
+        else if (!isExternalModule(parent))
+            this.errorOnNode(node, 250 /* Diagnostics.Global_module_exports_may_only_appear_in_module_files */, noArgs);
+        else if (!parent.isDeclarationFile)
+            this.errorOnNode(node, 251 /* Diagnostics.Global_module_exports_may_only_appear_in_declaration_files */, noArgs);
+        else {
+            const file = this.file;
+            let globalExports = file.globalExports;
+            if (globalExports === undefined) {
+                globalExports = new Map();
+                file.globalExports = globalExports;
+            }
+            this.declareSymbol(globalExports, file.symbol, node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */);
+        }
+    }
+    bindExportDeclaration(node) {
+        const containerSymbol = getSymbol(this.container);
+        if (containerSymbol === undefined)
+            // `export *` in a block.
+            this.bindAnonymousDeclaration(node, 8388608 /* SymbolFlags.ExportStar */, this.getDeclarationName(node));
+        else if (node.exportClause === undefined)
+            // All `export *` declarations go in one symbol.
+            this.declareSymbol(getExports(containerSymbol), containerSymbol, node, 8388608 /* SymbolFlags.ExportStar */, 0 /* SymbolFlags.None */);
+        else if (node.exportClause.kind === 281 /* SyntaxKind.NamespaceExport */)
+            this.declareSymbol(getExports(containerSymbol), containerSymbol, node.exportClause, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */);
+    }
+    bindExportAssignment(node) {
+        const containerSymbol = getSymbol(this.container);
+        if (containerSymbol === undefined) {
+            // An export assignment in a block.
+            this.bindAnonymousDeclaration(node, 111551 /* SymbolFlags.Value */, this.getDeclarationName(node));
+            return;
+        }
+        // `export default x` aliases x; anything else exported as default is a property.
+        const flags = expressionIsAlias(node.expression) ? 2097152 /* SymbolFlags.Alias */ : 4 /* SymbolFlags.Property */;
+        const symbol = this.declareSymbol(getExports(containerSymbol), containerSymbol, node, flags, 1073741823 /* SymbolFlags.All */);
+        if (node.isExportEquals)
+            setValueDeclaration(symbol, node);
+    }
+    /** Ambient files and modules without export declarations export every declaration implicitly. */
+    setExportContextFlag(node) {
+        if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && !hasExportDeclarations(node))
+            node.flags |= 64 /* NodeFlags.ExportContext */;
+        else
+            node.flags &= ~64 /* NodeFlags.ExportContext */;
+    }
+    bindFunctionDeclaration(node) {
+        if (!this.file.isDeclarationFile && (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 && isAsyncFunction(node))
+            this.emitFlags |= 262144 /* NodeFlags.HasAsyncFunctions */;
+        this.checkStrictModeFunctionName(node);
+        this.bindBlockScopedDeclaration(node, 16 /* SymbolFlags.Function */, 110991 /* SymbolFlags.FunctionExcludes */);
+    }
+    bindFunctionExpression(node) {
+        if (!this.file.isDeclarationFile && (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 && isAsyncFunction(node))
+            this.emitFlags |= 262144 /* NodeFlags.HasAsyncFunctions */;
+        setFlowNode(node, this.currentFlowValue());
+        let bindingName = "\uFFFEfunction" /* InternalSymbolName.Function */;
+        if (node instanceof FunctionExpression) {
+            const name = node.name;
+            if (name !== undefined) {
+                this.checkStrictModeFunctionName(node);
+                bindingName = name.text;
+            }
+        }
+        this.bindAnonymousDeclaration(node, 16 /* SymbolFlags.Function */, bindingName);
+    }
+    bindClassLikeDeclaration(node) {
+        if (node.kind === 264 /* SyntaxKind.ClassDeclaration */)
+            this.bindBlockScopedDeclaration(node, 32 /* SymbolFlags.Class */, 899503 /* SymbolFlags.ClassExcludes */);
+        else {
+            const name = getName(node);
+            this.bindAnonymousDeclaration(node, 32 /* SymbolFlags.Class */, name !== undefined ? getText(name) : "\uFFFEclass" /* InternalSymbolName.Class */);
+        }
+        // Every class has a static `prototype` property; declaring another one is an error, checked
+        // here because the class may merge with a namespace that exports `prototype`.
+        const symbol = getSymbol(node);
+        const prototypeSymbol = this.newSymbol(4 /* SymbolFlags.Property */ | 4194304 /* SymbolFlags.Prototype */, 'prototype');
+        const exports = getExports(symbol);
+        const existing = exports.get('prototype');
+        if (existing !== undefined)
+            this.errorOnNode(existing.declarations[0], 478 /* Diagnostics.Duplicate_identifier_0 */, ['prototype']);
+        exports.set('prototype', prototypeSymbol);
+        prototypeSymbol.parent = symbol;
+    }
+    bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) {
+        if (!this.file.isDeclarationFile && (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 && isAsyncFunction(node))
+            this.emitFlags |= 262144 /* NodeFlags.HasAsyncFunctions */;
+        if (isObjectLiteralOrClassExpressionMethodOrAccessor(node))
+            setFlowNode(node, this.currentFlowValue());
+        if (hasDynamicName(node))
+            this.bindAnonymousDeclaration(node, symbolFlags, "\uFFFEcomputed" /* InternalSymbolName.Computed */);
+        else
+            this.declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
+    }
+    /** Binds `(…) => T` like `{ (…): T }`: a type literal symbol whose only member is the signature. */
+    bindFunctionOrConstructorType(node) {
+        const symbol = this.newSymbol(131072 /* SymbolFlags.Signature */, this.getDeclarationName(node));
+        this.addDeclarationToSymbol(symbol, node, 131072 /* SymbolFlags.Signature */);
+        const typeLiteralSymbol = this.newSymbol(2048 /* SymbolFlags.TypeLiteral */, "\uFFFEtype" /* InternalSymbolName.Type */);
+        this.addDeclarationToSymbol(typeLiteralSymbol, node, 2048 /* SymbolFlags.TypeLiteral */);
+        getMembers(typeLiteralSymbol).set(symbol.name, symbol);
+    }
+    bindVariableDeclarationOrBindingElement(node) {
+        const name = getName(node);
+        this.checkStrictModeEvalOrArguments(node, name);
+        if (name === undefined ||
+            name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ ||
+            name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+            return;
+        if (isVariableDeclarationInitializedToRequire(node))
+            this.declareSymbolAndAddToSymbolTable(node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */);
+        else if (isBlockOrCatchScoped(node))
+            this.bindBlockScopedDeclaration(node, 2 /* SymbolFlags.BlockScopedVariable */, 111551 /* SymbolFlags.BlockScopedVariableExcludes */);
+        else if (isPartOfParameterDeclaration(node))
+            // Parameter excludes report duplicates like `function f([a, a]) {}`.
+            this.declareSymbolAndAddToSymbolTable(node, 1 /* SymbolFlags.FunctionScopedVariable */, 111551 /* SymbolFlags.ParameterExcludes */);
+        else
+            this.declareSymbolAndAddToSymbolTable(node, 1 /* SymbolFlags.FunctionScopedVariable */, 111550 /* SymbolFlags.FunctionScopedVariableExcludes */);
+    }
+    bindParameter(node) {
+        // `eval` and `arguments` can't be parameter names in strict mode.
+        if ((node.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+            this.checkStrictModeEvalOrArguments(node, node.name);
+        const name = node.name;
+        if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */) {
+            const index = getParameters(node.parent).nodes.indexOf(node);
+            this.bindAnonymousDeclaration(node, 1 /* SymbolFlags.FunctionScopedVariable */, '__' + index);
+        }
+        else
+            this.declareSymbolAndAddToSymbolTable(node, 1 /* SymbolFlags.FunctionScopedVariable */, 111551 /* SymbolFlags.ParameterExcludes */);
+        // A parameter property also declares a property of the class.
+        if (isParameterPropertyDeclaration(node, node.parent)) {
+            const classSymbol = getSymbol(node.parent.parent);
+            const flags = 4 /* SymbolFlags.Property */ | (node.questionToken !== undefined ? 16777216 /* SymbolFlags.Optional */ : 0 /* SymbolFlags.None */);
+            this.declareSymbol(getMembers(classSymbol), classSymbol, node, flags, 13243 /* SymbolFlags.PropertyExcludes */);
+        }
+    }
+    bindTypeParameter(node) {
+        const parent = node.parent;
+        if (parent.kind !== 196 /* SyntaxKind.InferType */) {
+            this.declareSymbolAndAddToSymbolTable(node, 262144 /* SymbolFlags.TypeParameter */, 526824 /* SymbolFlags.TypeParameterExcludes */);
+            return;
+        }
+        // `infer T` declares T in the conditional type whose extends clause contains it.
+        let container;
+        for (let current = parent; current !== undefined; current = current.parent) {
+            const p = current.parent;
+            if (p !== undefined && p.kind === 195 /* SyntaxKind.ConditionalType */ && getExtendsType(p) === current) {
+                container = p;
+                break;
+            }
+        }
+        if (container !== undefined)
+            this.declareSymbol(this.localsOf(container), undefined, node, 262144 /* SymbolFlags.TypeParameter */, 526824 /* SymbolFlags.TypeParameterExcludes */);
+        else
+            this.bindAnonymousDeclaration(node, 262144 /* SymbolFlags.TypeParameter */, this.getDeclarationName(node));
+    }
+    // JavaScript
+    setCommonJSModuleIndicator(node) {
+        const file = this.file;
+        if (file.externalModuleIndicator !== undefined && file.externalModuleIndicator !== file)
+            return false;
+        if (file.commonJSModuleIndicator === undefined) {
+            file.commonJSModuleIndicator = node;
+            if (file.externalModuleIndicator === undefined)
+                this.bindSourceFileAsExternalModule(file);
+        }
+        return true;
+    }
+    bindModuleExportsAssignment(node) {
+        if (!this.setCommonJSModuleIndicator(node))
+            return;
+        const fileSymbol = this.file.symbol;
+        const flags = expressionIsAlias(node.right) ? 2097152 /* SymbolFlags.Alias */ : 4 /* SymbolFlags.Property */;
+        const symbol = this.declareSymbol(getExports(fileSymbol), fileSymbol, node, flags, 0 /* SymbolFlags.None */);
+        setValueDeclaration(symbol, node);
+    }
+    bindExportsOrObjectDefineProperty(node) {
+        if (!this.setCommonJSModuleIndicator(node))
+            return;
+        const fileSymbol = this.file.symbol;
+        const flags = node instanceof BinaryExpression && expressionIsAlias(node.right)
+            ? 2097152 /* SymbolFlags.Alias */
+            : 1 /* SymbolFlags.FunctionScopedVariable */;
+        this.declareSymbol(getExports(fileSymbol), fileSymbol, node, flags, 111550 /* SymbolFlags.FunctionScopedVariableExcludes */);
+    }
+    bindExpandoPropertyAssignment(node) {
+        this.expandoAssignments.push(new ExpandoAssignment(node, this.container, this.blockScopeContainer));
+    }
+    bindDeferredExpandoAssignments(assignments) {
+        for (const assignment of assignments) {
+            this.container = assignment.container;
+            this.blockScopeContainer = assignment.blockScopeContainer;
+            this.bindDeferredExpandoAssignment(assignment.node);
+        }
+    }
+    bindDeferredExpandoAssignment(node) {
+        const target = node instanceof BinaryExpression
+            ? getExpression(node.left)
+            : getArguments(node).nodes[0];
+        const symbol = getInitializerSymbol(this.lookupEntity(target, this.blockScopeContainer) ?? this.lookupEntity(target, this.container));
+        if (symbol === undefined)
+            return;
+        if (hasDynamicName(node)) {
+            this.bindAnonymousDeclaration(node, 4 /* SymbolFlags.Property */ | 67108864 /* SymbolFlags.Assignment */, "\uFFFEcomputed" /* InternalSymbolName.Computed */);
+            this.addLateBoundAssignmentDeclarationToSymbol(node, symbol);
+            return;
+        }
+        // Expandos are declared only where no other declaration has the name.
+        const exports = getExports(symbol);
+        const existing = exports.get(this.getDeclarationName(node));
+        if (existing === undefined || (existing.flags & 67108864 /* SymbolFlags.Assignment */) !== 0)
+            this.declareSymbol(exports, symbol, node, 4 /* SymbolFlags.Property */ | 67108864 /* SymbolFlags.Assignment */, 13243 /* SymbolFlags.PropertyExcludes */);
+    }
+    addLateBoundAssignmentDeclarationToSymbol(node, symbol) {
+        const exports = getExports(symbol);
+        let assignmentSymbol = exports.get("\uFFFEassignment" /* InternalSymbolName.AssignmentDeclaration */);
+        if (assignmentSymbol === undefined) {
+            assignmentSymbol = this.newSymbol(0 /* SymbolFlags.None */, "\uFFFEassignment" /* InternalSymbolName.AssignmentDeclaration */);
+            exports.set("\uFFFEassignment" /* InternalSymbolName.AssignmentDeclaration */, assignmentSymbol);
+        }
+        addDeclaration(assignmentSymbol, node);
+    }
+    /**
+     * With an `export=` symbol, its module's exports with a type or namespace meaning are also
+     * exports of the `export=` symbol, which makes it a namespace.
+     */
+    bindCommonJSTypeExports(moduleSymbol) {
+        if (moduleSymbol === undefined)
+            return;
+        const moduleExports = moduleSymbol.exports;
+        if (moduleExports === undefined)
+            return;
+        const exportEquals = moduleExports.get("export=" /* InternalSymbolName.ExportEquals */);
+        if (exportEquals === undefined)
+            return;
+        for (const symbol of moduleExports.values()) {
+            if (symbol.name !== "export=" /* InternalSymbolName.ExportEquals */ &&
+                (symbol.flags & (788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */)) !== 0) {
+                getExports(exportEquals).set(symbol.name, symbol);
+                exportEquals.flags |= 1024 /* SymbolFlags.NamespaceModule */;
+            }
+        }
+    }
+    bindThisPropertyAssignment(node) {
+        if (!isInJSFile(node))
+            return;
+        const left = node.left;
+        const thisContainer = this.thisContainer;
+        if ((left instanceof PropertyAccessExpression &&
+            left.name.kind === 80 /* SyntaxKind.PrivateIdentifier */) ||
+            thisContainer === undefined)
+            return;
+        const symbolTable = this.thisSymbolTable();
+        if (symbolTable !== undefined) {
+            const classSymbol = getSymbol(thisContainer.parent);
+            if (hasDynamicName(node)) {
+                this.declareSymbolEx(symbolTable, classSymbol, node, 4 /* SymbolFlags.Property */, 0 /* SymbolFlags.None */, true, true);
+                this.addLateBoundAssignmentDeclarationToSymbol(node, classSymbol);
+            }
+            else
+                this.declareSymbolEx(symbolTable, classSymbol, node, 4 /* SymbolFlags.Property */ | 67108864 /* SymbolFlags.Assignment */, 0 /* SymbolFlags.None */, true, false);
+        }
+        else if (thisContainer.kind !== 263 /* SyntaxKind.FunctionDeclaration */ &&
+            thisContainer.kind !== 219 /* SyntaxKind.FunctionExpression */)
+            throw new Error('Unhandled case in bindThisPropertyAssignment');
+    }
+    /** For `this.x` in a class member, the class's members, or exports if the member is static. */
+    thisSymbolTable() {
+        const thisContainer = this.thisContainer;
+        if (thisContainer === undefined)
+            return undefined;
+        switch (thisContainer.kind) {
+            case 177 /* SyntaxKind.Constructor */:
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */: {
+                const classSymbol = getSymbol(thisContainer.parent);
+                return isStatic(thisContainer) ? getExports(classSymbol) : getMembers(classSymbol);
+            }
+        }
+        return undefined;
+    }
+    lookupEntity(node, container) {
+        if (node.kind === 79 /* SyntaxKind.Identifier */)
+            return lookupName(getText(node), container);
+        const expression = getExpression(node);
+        if (expression.kind === 109 /* SyntaxKind.ThisKeyword */) {
+            const symbolTable = this.thisSymbolTable();
+            if (symbolTable === undefined)
+                return undefined;
+            const name = getElementOrPropertyAccessName(node);
+            return name !== undefined ? symbolTable.get(getText(name)) : undefined;
+        }
+        const symbol = getInitializerSymbol(this.lookupEntity(expression, container));
+        if (symbol !== undefined && symbol.exports !== undefined) {
+            const name = getElementOrPropertyAccessName(node);
+            if (name !== undefined)
+                return symbol.exports.get(getText(name));
+        }
+        return undefined;
+    }
+    // Strict mode
+    /** Reports reserved words used as identifiers, and `await`/`yield` where they are keywords. */
+    checkContextualIdentifier(node) {
+        // Only words starting with a, i, l, p, s or y can be future reserved words, await or yield.
+        const text = node.text;
+        const first = text.charCodeAt(0);
+        if (first !== 0x61 && first !== 0x69 && first !== 0x6c && first !== 0x70 && first !== 0x73 && first !== 0x79)
+            return;
+        if (this.file.diagnostics.length !== 0 ||
+            (node.flags & (8388608 /* NodeFlags.Ambient */ | 4194304 /* NodeFlags.JSDoc */)) !== 0 ||
+            isIdentifierName(node))
+            return;
+        const originalKeywordKind = getIdentifierToken(text);
+        if (originalKeywordKind === 79 /* SyntaxKind.Identifier */)
+            return;
+        if (originalKeywordKind >= 118 /* SyntaxKind.FirstFutureReservedWord */ &&
+            originalKeywordKind <= 126 /* SyntaxKind.LastFutureReservedWord */)
+            this.errorOnNode(node, this.getStrictModeIdentifierMessage(node), [declarationNameToString(this.file, node)]);
+        else if (originalKeywordKind === 134 /* SyntaxKind.AwaitKeyword */) {
+            if (isExternalModule(this.file) && isInTopLevelContext(node))
+                this.errorOnNode(node, 211 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module */, [
+                    declarationNameToString(this.file, node),
+                ]);
+            else if ((node.flags & 8192 /* NodeFlags.AwaitContext */) !== 0)
+                this.errorOnNode(node, 293 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here */, [
+                    declarationNameToString(this.file, node),
+                ]);
+        }
+        else if (originalKeywordKind === 126 /* SyntaxKind.YieldKeyword */ && (node.flags & 2048 /* NodeFlags.YieldContext */) !== 0)
+            this.errorOnNode(node, 293 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here */, [
+                declarationNameToString(this.file, node),
+            ]);
+    }
+    checkPrivateIdentifier(node) {
+        if (getText(node) === '#constructor' && this.file.diagnostics.length === 0)
+            this.errorOnNode(node, 1834 /* Diagnostics.X_constructor_is_a_reserved_word */, [declarationNameToString(this.file, node)]);
+    }
+    getStrictModeIdentifierMessage(node) {
+        if (getContainingClass(node) !== undefined)
+            return 166 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode */;
+        if (this.file.externalModuleIndicator !== undefined)
+            return 167 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode */;
+        return 165 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode */;
+    }
+    checkStrictModeFunctionName(node) {
+        if ((node.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+            this.checkStrictModeEvalOrArguments(node, getName(node));
+    }
+    checkStrictModeBinaryExpression(node) {
+        // `eval` and `arguments` can't be assigned to.
+        if (isLeftHandSideExpression(node.left) && isAssignmentOperator(node.operatorToken.kind))
+            this.checkStrictModeEvalOrArguments(node, node.left);
+    }
+    checkStrictModeCatchClause(node) {
+        const declaration = node.variableDeclaration;
+        if (declaration !== undefined)
+            this.checkStrictModeEvalOrArguments(node, declaration.name);
+    }
+    checkStrictModeDeleteExpression(node) {
+        // Deleting a variable, parameter or function name is an error in strict mode.
+        if (node.expression.kind === 79 /* SyntaxKind.Identifier */)
+            this.errorOnNode(node.expression, 71 /* Diagnostics.X_delete_cannot_be_called_on_an_identifier_in_strict_mode */, noArgs);
+    }
+    checkStrictModeEvalOrArguments(contextNode, name) {
+        if (name === undefined || name.kind !== 79 /* SyntaxKind.Identifier */)
+            return;
+        const text = getText(name);
+        if (text !== 'eval' && text !== 'arguments')
+            return;
+        let message;
+        if (getContainingClass(contextNode) !== undefined)
+            message =
+                163 /* Diagnostics.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode */;
+        else if (this.file.externalModuleIndicator !== undefined)
+            message = 168 /* Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode */;
+        else
+            message = 69 /* Diagnostics.Invalid_use_of_0_in_strict_mode */;
+        this.errorOnNode(name, message, [text]);
+    }
+}
+const noArgs = [];
+function optionalSymbolFlag(node) {
+    const postfixToken = getPostfixToken(node);
+    return postfixToken !== undefined && postfixToken.kind === 57 /* SyntaxKind.QuestionToken */
+        ? 16777216 /* SymbolFlags.Optional */
+        : 0 /* SymbolFlags.None */;
+}
+function getExtendsType(node) {
+    return node instanceof ConditionalTypeNode ? node.extendsType : undefined;
+}
+function isGeneratorFunctionExpression(node) {
+    return node instanceof FunctionExpression && node.asteriskToken !== undefined;
+}
+function isForInOrOfStatementKind(kind) {
+    return kind === 250 /* SyntaxKind.ForInStatement */ || kind === 251 /* SyntaxKind.ForOfStatement */;
+}
+function hasExportDeclarations(node) {
+    let statements;
+    if (node.kind === 307 /* SyntaxKind.SourceFile */)
+        statements = node.statements;
+    else if (node instanceof ModuleDeclaration) {
+        const body = node.body;
+        if (body !== undefined && body.kind === 269 /* SyntaxKind.ModuleBlock */)
+            statements = getStatements(body);
+    }
+    if (statements === undefined)
+        return false;
+    for (const statement of statements.nodes)
+        if (statement.kind === 279 /* SyntaxKind.ExportDeclaration */ || statement.kind === 278 /* SyntaxKind.ExportAssignment */)
+            return true;
+    return false;
+}
+/** The symbol in `container`'s locals or its symbol's exports, preferring a local's export symbol. */
+function lookupName(name, container) {
+    if (isLocalsContainer(container)) {
+        const locals = getLocals(container);
+        const local = locals !== undefined ? locals.get(name) : undefined;
+        if (local !== undefined)
+            return local.exportSymbol ?? local;
+    }
+    if (isDeclarationNode(container)) {
+        const symbol = getSymbol(container);
+        if (symbol !== undefined && symbol.exports !== undefined)
+            return symbol.exports.get(name);
+    }
+    return undefined;
+}
+/**
+ * For `fn.x = …`: the symbol that gets expando properties when `fn` is a function, a const
+ * (or JavaScript) variable initialized with a function or class, or a JavaScript class.
+ */
+function getInitializerSymbol(symbol) {
+    if (symbol === undefined)
+        return undefined;
+    const declaration = symbol.valueDeclaration;
+    if (declaration === undefined)
+        return undefined;
+    if (declaration.kind === 263 /* SyntaxKind.FunctionDeclaration */ ||
+        (isInJSFile(declaration) && declaration.kind === 264 /* SyntaxKind.ClassDeclaration */))
+        return symbol;
+    if (declaration instanceof VariableDeclaration) {
+        if ((declaration.parent.flags & 2 /* NodeFlags.Const */) !== 0 || isInJSFile(declaration)) {
+            const initializer = declaration.initializer;
+            if (isExpandoInitializer(declaration, initializer))
+                return getSymbol(initializer);
+        }
+        return undefined;
+    }
+    if (declaration instanceof BinaryExpression && isInJSFile(declaration)) {
+        const initializer = declaration.right;
+        if (isExpandoInitializer(declaration, initializer))
+            return getSymbol(initializer);
+    }
+    return undefined;
+}
+function setFlowNodeReferenced(flow) {
+    // Referenced on first use, Shared after that.
+    flow.flags |= (flow.flags & 2048 /* FlowFlags.Referenced */) === 0 ? 2048 /* FlowFlags.Referenced */ : 4096 /* FlowFlags.Shared */;
+}
+function combineFlowLists(head, tail) {
+    if (head === undefined)
+        return tail;
+    return tail === undefined ? head.slice() : head.concat(tail);
+}
+function isStatementCondition(node) {
+    const parent = node.parent;
+    switch (parent.kind) {
+        case 246 /* SyntaxKind.IfStatement */:
+        case 248 /* SyntaxKind.WhileStatement */:
+        case 247 /* SyntaxKind.DoStatement */:
+            return getExpression(parent) === node;
+        case 249 /* SyntaxKind.ForStatement */:
+            return parent.condition === node;
+        case 228 /* SyntaxKind.ConditionalExpression */:
+            return parent.condition === node;
+    }
+    return false;
+}
+function isTopLevelLogicalExpression(node) {
+    let current = node;
+    for (;;) {
+        const parent = current.parent;
+        if (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */ ||
+            (parent instanceof PrefixUnaryExpression &&
+                parent.operator === 53 /* SyntaxKind.ExclamationToken */))
+            current = parent;
+        else
+            break;
+    }
+    const parent = current.parent;
+    return (!isStatementCondition(current) &&
+        !isLogicalExpression(parent) &&
+        !(isOptionalChain(parent) && getExpression(parent) === current));
+}
+// Narrowing
+function isNarrowingExpression(expression) {
+    switch (expression.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return true;
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+            return containsNarrowableReference(expression);
+        case 214 /* SyntaxKind.CallExpression */:
+            return hasNarrowableArgument(expression);
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 222 /* SyntaxKind.TypeOfExpression */:
+            return isNarrowingExpression(getExpression(expression));
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return isNarrowingBinaryExpression(expression);
+        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            const unary = expression;
+            return unary.operator === 53 /* SyntaxKind.ExclamationToken */ && isNarrowingExpression(unary.operand);
+        }
+    }
+    return false;
+}
+function containsNarrowableReference(expression) {
+    if (isNarrowableReference(expression))
+        return true;
+    if ((expression.flags & 32 /* NodeFlags.OptionalChain */) !== 0) {
+        switch (expression.kind) {
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 214 /* SyntaxKind.CallExpression */:
+            case 236 /* SyntaxKind.NonNullExpression */:
+                return containsNarrowableReference(getExpression(expression));
+        }
+    }
+    return false;
+}
+/** A reference whose type control flow analysis can narrow. */
+export function isNarrowableReference(node) {
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 109 /* SyntaxKind.ThisKeyword */:
+        case 107 /* SyntaxKind.SuperKeyword */:
+        case 237 /* SyntaxKind.MetaProperty */:
+            return true;
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+            return isNarrowableReference(node.expression);
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return isNarrowableReference(node.expression);
+        case 236 /* SyntaxKind.NonNullExpression */:
+            return isNarrowableReference(node.expression);
+        case 213 /* SyntaxKind.ElementAccessExpression */: {
+            const access = node;
+            return (isStringOrNumericLiteralLike(access.argumentExpression) ||
+                (isEntityNameExpression(access.argumentExpression, false) && isNarrowableReference(access.expression)));
+        }
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            const binary = node;
+            const operator = binary.operatorToken.kind;
+            return ((operator === 27 /* SyntaxKind.CommaToken */ && isNarrowableReference(binary.right)) ||
+                (isAssignmentOperator(operator) && isLeftHandSideExpression(binary.left)));
+        }
+    }
+    return false;
+}
+function hasNarrowableArgument(call) {
+    for (const argument of call.arguments.nodes)
+        if (containsNarrowableReference(argument))
+            return true;
+    const callee = call.expression;
+    return (callee instanceof PropertyAccessExpression &&
+        containsNarrowableReference(callee.expression));
+}
+function isNarrowingBinaryExpression(expression) {
+    switch (expression.operatorToken.kind) {
+        case 63 /* SyntaxKind.EqualsToken */:
+        case 75 /* SyntaxKind.BarBarEqualsToken */:
+        case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+        case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+            return containsNarrowableReference(expression.left);
+        case 34 /* SyntaxKind.EqualsEqualsToken */:
+        case 35 /* SyntaxKind.ExclamationEqualsToken */:
+        case 36 /* SyntaxKind.EqualsEqualsEqualsToken */:
+        case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: {
+            const left = skipParentheses(expression.left);
+            const right = skipParentheses(expression.right);
+            return (isNarrowableOperand(left) ||
+                isNarrowableOperand(right) ||
+                isNarrowingTypeOfOperands(right, left) ||
+                isNarrowingTypeOfOperands(left, right) ||
+                (isBooleanLiteral(right) && isNarrowingExpression(left)) ||
+                (isBooleanLiteral(left) && isNarrowingExpression(right)));
+        }
+        case 103 /* SyntaxKind.InstanceOfKeyword */:
+            return isNarrowableOperand(expression.left);
+        case 102 /* SyntaxKind.InKeyword */:
+        case 27 /* SyntaxKind.CommaToken */:
+            return isNarrowingExpression(expression.right);
+    }
+    return false;
+}
+function isNarrowableOperand(expression) {
+    if (expression.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        return isNarrowableOperand(getExpression(expression));
+    if (expression instanceof BinaryExpression) {
+        const binary = expression;
+        const operator = binary.operatorToken.kind;
+        if (operator === 63 /* SyntaxKind.EqualsToken */)
+            return isNarrowableOperand(binary.left);
+        if (operator === 27 /* SyntaxKind.CommaToken */)
+            return isNarrowableOperand(binary.right);
+    }
+    return containsNarrowableReference(expression);
+}
+function isNarrowingTypeOfOperands(expression1, expression2) {
+    return (expression1.kind === 222 /* SyntaxKind.TypeOfExpression */ &&
+        isNarrowableOperand(getExpression(expression1)) &&
+        isStringLiteralLike(expression2));
+}
+/** The `"use strict"` prologue directive of `statements`, if any. */
+export function findUseStrictPrologue(file, statements) {
+    for (const statement of statements) {
+        if (!isPrologueDirective(statement))
+            return undefined;
+        // Exactly `"use strict"` or `'use strict'`, without escapes.
+        const text = getSourceTextOfNode(file, statement.expression);
+        if (text === '"use strict"' || text === "'use strict'")
+            return statement;
+    }
+    return undefined;
+}