/* @internal */

namespace ts {

export const enum ModuleInstanceState {

NonInstantiated = 0,

Instantiated = 1,

ConstEnumOnly = 2

}

interface ActiveLabel {

next: ActiveLabel | undefined;

name: __String;

breakTarget: FlowLabel;

continueTarget: FlowLabel | undefined;

referenced: boolean;

}

export function getModuleInstanceState(node: ModuleDeclaration, visited?: Map<ModuleInstanceState | undefined>): ModuleInstanceState {

if (node.body && !node.body.parent) {

// getModuleInstanceStateForAliasTarget needs to walk up the parent chain, so parent pointers must be set on this tree already

setParentPointers(node, node.body);

}

return node.body ? getModuleInstanceStateCached(node.body, visited) : ModuleInstanceState.Instantiated;

}

function getModuleInstanceStateCached(node: Node, visited = createMap<ModuleInstanceState | undefined>()) {

const nodeId = "" + getNodeId(node);

if (visited.has(nodeId)) {

return visited.get(nodeId) || ModuleInstanceState.NonInstantiated;

}

visited.set(nodeId, undefined);

const result = getModuleInstanceStateWorker(node, visited);

visited.set(nodeId, result);

return result;

}

function getModuleInstanceStateWorker(node: Node, visited: Map<ModuleInstanceState | undefined>): ModuleInstanceState {

// A module is uninstantiated if it contains only

switch (node.kind) {

// 1. interface declarations, type alias declarations

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.TypeAliasDeclaration:

return ModuleInstanceState.NonInstantiated;

// 2. const enum declarations

case SyntaxKind.EnumDeclaration:

if (isEnumConst(node as EnumDeclaration)) {

return ModuleInstanceState.ConstEnumOnly;

}

break;

// 3. non-exported import declarations

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ImportEqualsDeclaration:

if (!(hasModifier(node, ModifierFlags.Export))) {

return ModuleInstanceState.NonInstantiated;

}

break;

// 4. Export alias declarations pointing at only uninstantiated modules or things uninstantiated modules contain

case SyntaxKind.ExportDeclaration:

const exportDeclaration = node as ExportDeclaration;

if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === SyntaxKind.NamedExports) {

let state = ModuleInstanceState.NonInstantiated;

for (const specifier of exportDeclaration.exportClause.elements) {

const specifierState = getModuleInstanceStateForAliasTarget(specifier, visited);

if (specifierState > state) {

state = specifierState;

}

if (state === ModuleInstanceState.Instantiated) {

return state;

}

}

return state;

}

break;

// 5. other uninstantiated module declarations.

case SyntaxKind.ModuleBlock: {

let state = ModuleInstanceState.NonInstantiated;

forEachChild(node, n => {

const childState = getModuleInstanceStateCached(n, visited);

switch (childState) {

case ModuleInstanceState.NonInstantiated:

// child is non-instantiated - continue searching

return;

case ModuleInstanceState.ConstEnumOnly:

// child is const enum only - record state and continue searching

state = ModuleInstanceState.ConstEnumOnly;

return;

case ModuleInstanceState.Instantiated:

// child is instantiated - record state and stop

state = ModuleInstanceState.Instantiated;

return true;

default:

Debug.assertNever(childState);

}

});

return state;

}

case SyntaxKind.ModuleDeclaration:

return getModuleInstanceState(node as ModuleDeclaration, visited);

case SyntaxKind.Identifier:

// Only jsdoc typedef definition can exist in jsdoc namespace, and it should

// be considered the same as type alias

if ((<Identifier>node).isInJSDocNamespace) {

return ModuleInstanceState.NonInstantiated;

}

}

return ModuleInstanceState.Instantiated;

}

function getModuleInstanceStateForAliasTarget(specifier: ExportSpecifier, visited: Map<ModuleInstanceState | undefined>) {

const name = specifier.propertyName || specifier.name;

let p: Node | undefined = specifier.parent;

while (p) {

if (isBlock(p) || isModuleBlock(p) || isSourceFile(p)) {

const statements = p.statements;

let found: ModuleInstanceState | undefined;

for (const statement of statements) {

if (nodeHasName(statement, name)) {

if (!statement.parent) {

setParentPointers(p, statement);

}

const state = getModuleInstanceStateCached(statement, visited);

if (found === undefined || state > found) {

found = state;

}

if (found === ModuleInstanceState.Instantiated) {

return found;

}

}

}

if (found !== undefined) {

return found;

}

}

p = p.parent;

}

return ModuleInstanceState.Instantiated; // Couldn't locate, assume could refer to a value

}

const enum ContainerFlags {

// The current node is not a container, and no container manipulation should happen before

// recursing into it.

None = 0,

// The current node is a container. It should be set as the current container (and block-

// container) before recursing into it. The current node does not have locals. Examples:

//

// Classes, ObjectLiterals, TypeLiterals, Interfaces...

IsContainer = 1 << 0,

// The current node is a block-scoped-container. It should be set as the current block-

// container before recursing into it. Examples:

//

// Blocks (when not parented by functions), Catch clauses, For/For-in/For-of statements...

IsBlockScopedContainer = 1 << 1,

// The current node is the container of a control flow path. The current control flow should

// be saved and restored, and a new control flow initialized within the container.

IsControlFlowContainer = 1 << 2,

IsFunctionLike = 1 << 3,

IsFunctionExpression = 1 << 4,

HasLocals = 1 << 5,

IsInterface = 1 << 6,

IsObjectLiteralOrClassExpressionMethod = 1 << 7,

}

function initFlowNode<T extends FlowNode>(node: T) {

Debug.attachFlowNodeDebugInfo(node);

return node;

}

const binder = createBinder();

export function bindSourceFile(file: SourceFile, options: CompilerOptions) {

performance.mark("beforeBind");

perfLogger.logStartBindFile("" + file.fileName);

binder(file, options);

perfLogger.logStopBindFile();

performance.mark("afterBind");

performance.measure("Bind", "beforeBind", "afterBind");

}

function createBinder(): (file: SourceFile, options: CompilerOptions) => void {

let file: SourceFile;

let options: CompilerOptions;

let languageVersion: ScriptTarget;

let parent: Node;

let container: Node;

let thisParentContainer: Node; // Container one level up

let blockScopeContainer: Node;

let lastContainer: Node;

let delayedTypeAliases: (JSDocTypedefTag | JSDocCallbackTag | JSDocEnumTag)[];

let seenThisKeyword: boolean;

// state used by control flow analysis

let currentFlow: FlowNode;

let currentBreakTarget: FlowLabel | undefined;

let currentContinueTarget: FlowLabel | undefined;

let currentReturnTarget: FlowLabel | undefined;

let currentTrueTarget: FlowLabel | undefined;

let currentFalseTarget: FlowLabel | undefined;

let currentExceptionTarget: FlowLabel | undefined;

let preSwitchCaseFlow: FlowNode | undefined;

let activeLabelList: ActiveLabel | undefined;

let hasExplicitReturn: boolean;

// state used for emit helpers

let emitFlags: NodeFlags;

// If this file is an external module, then it is automatically in strict-mode according to

// ES6. If it is not an external module, then we'll determine if it is in strict mode or

// not depending on if we see "use strict" in certain places or if we hit a class/namespace

// or if compiler options contain alwaysStrict.

let inStrictMode: boolean;

let symbolCount = 0;

let Symbol: new (flags: SymbolFlags, name: __String) => Symbol;

let classifiableNames: UnderscoreEscapedMap<true>;

const unreachableFlow: FlowNode = { flags: FlowFlags.Unreachable };

const reportedUnreachableFlow: FlowNode = { flags: FlowFlags.Unreachable };

// state used to aggregate transform flags during bind.

let subtreeTransformFlags: TransformFlags = TransformFlags.None;

let skipTransformFlagAggregation: boolean;

/**

* Inside the binder, we may create a diagnostic for an as-yet unbound node (with potentially no parent pointers, implying no accessible source file)

* If so, the node _must_ be in the current file (as that's the only way anything could have traversed to it to yield it as the error node)

* This version of `createDiagnosticForNode` uses the binder's context to account for this, and always yields correct diagnostics even in these situations.

*/

function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number): DiagnosticWithLocation {

return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);

}

function bindSourceFile(f: SourceFile, opts: CompilerOptions) {

file = f;

options = opts;

languageVersion = getEmitScriptTarget(options);

inStrictMode = bindInStrictMode(file, opts);

classifiableNames = createUnderscoreEscapedMap<true>();

symbolCount = 0;

skipTransformFlagAggregation = file.isDeclarationFile;

Symbol = objectAllocator.getSymbolConstructor();

// Attach debugging information if necessary

Debug.attachFlowNodeDebugInfo(unreachableFlow);

Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);

if (!file.locals) {

bind(file);

file.symbolCount = symbolCount;

file.classifiableNames = classifiableNames;

delayedBindJSDocTypedefTag();

}

file = undefined!;

options = undefined!;

languageVersion = undefined!;

parent = undefined!;

container = undefined!;

thisParentContainer = undefined!;

blockScopeContainer = undefined!;

lastContainer = undefined!;

delayedTypeAliases = undefined!;

seenThisKeyword = false;

currentFlow = undefined!;

currentBreakTarget = undefined;

currentContinueTarget = undefined;

currentReturnTarget = undefined;

currentTrueTarget = undefined;

currentFalseTarget = undefined;

currentExceptionTarget = undefined;

activeLabelList = undefined;

hasExplicitReturn = false;

emitFlags = NodeFlags.None;

subtreeTransformFlags = TransformFlags.None;

}

return bindSourceFile;

function bindInStrictMode(file: SourceFile, opts: CompilerOptions): boolean {

if (getStrictOptionValue(opts, "alwaysStrict") && !file.isDeclarationFile) {

// bind in strict mode source files with alwaysStrict option

return true;

}

else {

return !!file.externalModuleIndicator;

}

}

function createSymbol(flags: SymbolFlags, name: __String): Symbol {

symbolCount++;

return new Symbol(flags, name);

}

function addDeclarationToSymbol(symbol: Symbol, node: Declaration, symbolFlags: SymbolFlags) {

symbol.flags |= symbolFlags;

node.symbol = symbol;

symbol.declarations = appendIfUnique(symbol.declarations, node);

if (symbolFlags & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.Module | SymbolFlags.Variable) && !symbol.exports) {

symbol.exports = createSymbolTable();

}

if (symbolFlags & (SymbolFlags.Class | SymbolFlags.Interface | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) && !symbol.members) {

symbol.members = createSymbolTable();

}

// On merge of const enum module with class or function, reset const enum only flag (namespaces will already recalculate)

if (symbol.constEnumOnlyModule && (symbol.flags & (SymbolFlags.Function | SymbolFlags.Class | SymbolFlags.RegularEnum))) {

symbol.constEnumOnlyModule = false;

}

if (symbolFlags & SymbolFlags.Value) {

setValueDeclaration(symbol, node);

}

}

function setValueDeclaration(symbol: Symbol, node: Declaration): void {

const { valueDeclaration } = symbol;

if (!valueDeclaration ||

(isAssignmentDeclaration(valueDeclaration) && !isAssignmentDeclaration(node)) ||

(valueDeclaration.kind !== node.kind && isEffectiveModuleDeclaration(valueDeclaration))) {

// other kinds of value declarations take precedence over modules and assignment declarations

symbol.valueDeclaration = node;

}

}

// Should not be called on a declaration with a computed property name,

// unless it is a well known Symbol.

function getDeclarationName(node: Declaration): __String | undefined {

if (node.kind === SyntaxKind.ExportAssignment) {

return (<ExportAssignment>node).isExportEquals ? InternalSymbolName.ExportEquals : InternalSymbolName.Default;

}

const name = getNameOfDeclaration(node);

if (name) {

if (isAmbientModule(node)) {

const moduleName = getTextOfIdentifierOrLiteral(name as Identifier | StringLiteral);

return (isGlobalScopeAugmentation(<ModuleDeclaration>node) ? "__global" : `"${moduleName}"`) as __String;

}

if (name.kind === SyntaxKind.ComputedPropertyName) {

const nameExpression = name.expression;

// treat computed property names where expression is string/numeric literal as just string/numeric literal

if (isStringOrNumericLiteralLike(nameExpression)) {

return escapeLeadingUnderscores(nameExpression.text);

}

if (isSignedNumericLiteral(nameExpression)) {

return tokenToString(nameExpression.operator) + nameExpression.operand.text as __String;

}

Debug.assert(isWellKnownSymbolSyntactically(nameExpression));

return getPropertyNameForKnownSymbolName(idText((<PropertyAccessExpression>nameExpression).name));

}

if (isWellKnownSymbolSyntactically(name)) {

return getPropertyNameForKnownSymbolName(idText(name.name));

}

if (isPrivateIdentifier(name)) {

// containingClass exists because private names only allowed inside classes

const containingClass = getContainingClass(node);

if (!containingClass) {

// we can get here in cases where there is already a parse error.

return undefined;

}

const containingClassSymbol = containingClass.symbol;

return getSymbolNameForPrivateIdentifier(containingClassSymbol, name.escapedText);

}

return isPropertyNameLiteral(name) ? getEscapedTextOfIdentifierOrLiteral(name) : undefined;

}

switch (node.kind) {

case SyntaxKind.Constructor:

return InternalSymbolName.Constructor;

case SyntaxKind.FunctionType:

case SyntaxKind.CallSignature:

case SyntaxKind.JSDocSignature:

return InternalSymbolName.Call;

case SyntaxKind.ConstructorType:

case SyntaxKind.ConstructSignature:

return InternalSymbolName.New;

case SyntaxKind.IndexSignature:

return InternalSymbolName.Index;

case SyntaxKind.ExportDeclaration:

return InternalSymbolName.ExportStar;

case SyntaxKind.SourceFile:

// json file should behave as

// module.exports = ...

return InternalSymbolName.ExportEquals;

case SyntaxKind.BinaryExpression:

if (getAssignmentDeclarationKind(node as BinaryExpression) === AssignmentDeclarationKind.ModuleExports) {

// module.exports = ...

return InternalSymbolName.ExportEquals;

}

Debug.fail("Unknown binary declaration kind");

break;

case SyntaxKind.JSDocFunctionType:

return (isJSDocConstructSignature(node) ? InternalSymbolName.New : InternalSymbolName.Call);

case SyntaxKind.Parameter:

// Parameters with names are handled at the top of this function. Parameters

// without names can only come from JSDocFunctionTypes.

Debug.assert(node.parent.kind === SyntaxKind.JSDocFunctionType, "Impossible parameter parent kind", () => `parent is: ${(ts as any).SyntaxKind ? (ts as any).SyntaxKind[node.parent.kind] : node.parent.kind}, expected JSDocFunctionType`);

const functionType = <JSDocFunctionType>node.parent;

const index = functionType.parameters.indexOf(node as ParameterDeclaration);

return "arg" + index as __String;

}

}

function getDisplayName(node: Declaration): string {

return isNamedDeclaration(node) ? declarationNameToString(node.name) : unescapeLeadingUnderscores(Debug.assertDefined(getDeclarationName(node)));

}

/**

* Declares a Symbol for the node and adds it to symbols. Reports errors for conflicting identifier names.

* @param symbolTable - The symbol table which node will be added to.

* @param parent - node's parent declaration.

* @param node - The declaration to be added to the symbol table

* @param includes - The SymbolFlags that node has in addition to its declaration type (eg: export, ambient, etc.)

* @param excludes - The flags which node cannot be declared alongside in a symbol table. Used to report forbidden declarations.

*/

function declareSymbol(symbolTable: SymbolTable, parent: Symbol | undefined, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags, isReplaceableByMethod?: boolean): Symbol {

Debug.assert(!hasDynamicName(node));

const isDefaultExport = hasModifier(node, ModifierFlags.Default);

// The exported symbol for an export default function/class node is always named "default"

const name = isDefaultExport && parent ? InternalSymbolName.Default : getDeclarationName(node);

let symbol: Symbol | undefined;

if (name === undefined) {

symbol = createSymbol(SymbolFlags.None, InternalSymbolName.Missing);

}

else {

// Check and see if the symbol table already has a symbol with this name. If not,

// create a new symbol with this name and add it to the table. Note that we don't

// give the new symbol any flags *yet*. This ensures that it will not conflict

// with the 'excludes' flags we pass in.

//

// If we do get an existing symbol, see if it conflicts with the new symbol we're

// creating. For example, a 'var' symbol and a 'class' symbol will conflict within

// the same symbol table. If we have a conflict, report the issue on each

// declaration we have for this symbol, and then create a new symbol for this

// declaration.

//

// Note that when properties declared in Javascript constructors

// (marked by isReplaceableByMethod) conflict with another symbol, the property loses.

// Always. This allows the common Javascript pattern of overwriting a prototype method

// with an bound instance method of the same type: `this.method = this.method.bind(this)`

//

// If we created a new symbol, either because we didn't have a symbol with this name

// in the symbol table, or we conflicted with an existing symbol, then just add this

// node as the sole declaration of the new symbol.

//

// Otherwise, we'll be merging into a compatible existing symbol (for example when

// you have multiple 'vars' with the same name in the same container). In this case

// just add this node into the declarations list of the symbol.

symbol = symbolTable.get(name);

if (includes & SymbolFlags.Classifiable) {

classifiableNames.set(name, true);

}

if (!symbol) {

symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name));

if (isReplaceableByMethod) symbol.isReplaceableByMethod = true;

}

else if (isReplaceableByMethod && !symbol.isReplaceableByMethod) {

// A symbol already exists, so don't add this as a declaration.

return symbol;

}

else if (symbol.flags & excludes) {

if (symbol.isReplaceableByMethod) {

// Javascript constructor-declared symbols can be discarded in favor of

// prototype symbols like methods.

symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name));

}

else if (!(includes & SymbolFlags.Variable && symbol.flags & SymbolFlags.Assignment)) {

// Assignment declarations are allowed to merge with variables, no matter what other flags they have.

if (isNamedDeclaration(node)) {

node.name.parent = node;

}

// Report errors every position with duplicate declaration

// Report errors on previous encountered declarations

let message = symbol.flags & SymbolFlags.BlockScopedVariable

? Diagnostics.Cannot_redeclare_block_scoped_variable_0

: Diagnostics.Duplicate_identifier_0;

let messageNeedsName = true;

if (symbol.flags & SymbolFlags.Enum || includes & SymbolFlags.Enum) {

message = Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations;

messageNeedsName = false;

}

let multipleDefaultExports = false;

if (length(symbol.declarations)) {

// If the current node is a default export of some sort, then check if

// there are any other default exports that we need to error on.

// We'll know whether we have other default exports depending on if `symbol` already has a declaration list set.

if (isDefaultExport) {

message = Diagnostics.A_module_cannot_have_multiple_default_exports;

messageNeedsName = false;

multipleDefaultExports = true;

}

else {

// This is to properly report an error in the case "export default { }" is after export default of class declaration or function declaration.

// Error on multiple export default in the following case:

// 1. multiple export default of class declaration or function declaration by checking NodeFlags.Default

// 2. multiple export default of export assignment. This one doesn't have NodeFlags.Default on (as export default doesn't considered as modifiers)

if (symbol.declarations && symbol.declarations.length &&

(node.kind === SyntaxKind.ExportAssignment && !(<ExportAssignment>node).isExportEquals)) {

message = Diagnostics.A_module_cannot_have_multiple_default_exports;

messageNeedsName = false;

multipleDefaultExports = true;

}

}

}

const relatedInformation: DiagnosticRelatedInformation[] = [];

if (isTypeAliasDeclaration(node) && nodeIsMissing(node.type) && hasModifier(node, ModifierFlags.Export) && symbol.flags & (SymbolFlags.Alias | SymbolFlags.Type | SymbolFlags.Namespace)) {

// export type T; - may have meant export type { T }?

relatedInformation.push(createDiagnosticForNode(node, Diagnostics.Did_you_mean_0, `export type { ${unescapeLeadingUnderscores(node.name.escapedText)} }`));

}

const declarationName = getNameOfDeclaration(node) || node;

forEach(symbol.declarations, (declaration, index) => {

const decl = getNameOfDeclaration(declaration) || declaration;

const diag = createDiagnosticForNode(decl, message, messageNeedsName ? getDisplayName(declaration) : undefined);

file.bindDiagnostics.push(

multipleDefaultExports ? addRelatedInfo(diag, createDiagnosticForNode(declarationName, index === 0 ? Diagnostics.Another_export_default_is_here : Diagnostics.and_here)) : diag

);

if (multipleDefaultExports) {

relatedInformation.push(createDiagnosticForNode(decl, Diagnostics.The_first_export_default_is_here));

}

});

const diag = createDiagnosticForNode(declarationName, message, messageNeedsName ? getDisplayName(node) : undefined);

file.bindDiagnostics.push(addRelatedInfo(diag, ...relatedInformation));

symbol = createSymbol(SymbolFlags.None, name);

}

}

}

addDeclarationToSymbol(symbol, node, includes);

if (symbol.parent) {

Debug.assert(symbol.parent === parent, "Existing symbol parent should match new one");

}

else {

symbol.parent = parent;

}

return symbol;

}

function declareModuleMember(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol {

const hasExportModifier = getCombinedModifierFlags(node) & ModifierFlags.Export;

if (symbolFlags & SymbolFlags.Alias) {

if (node.kind === SyntaxKind.ExportSpecifier || (node.kind === SyntaxKind.ImportEqualsDeclaration && hasExportModifier)) {

return declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes);

}

else {

return declareSymbol(container.locals!, /*parent*/ undefined, node, symbolFlags, symbolExcludes);

}

}

else {

// Exported module members are given 2 symbols: A local symbol that is classified with an ExportValue flag,

// and an associated export symbol with all the correct flags set on it. There are 2 main reasons:

//

// 1. We treat locals and exports of the same name as mutually exclusive within a container.

// That means the binder will issue a Duplicate Identifier error if you mix locals and exports

// with the same name in the same container.

// TODO: Make this a more specific error and decouple it from the exclusion logic.

// 2. When we checkIdentifier in the checker, we set its resolved symbol to the local symbol,

// but return the export symbol (by calling getExportSymbolOfValueSymbolIfExported). That way

// when the emitter comes back to it, it knows not to qualify the name if it was found in a containing scope.

// NOTE: Nested ambient modules always should go to to 'locals' table to prevent their automatic merge

// during global merging in the checker. Why? The only case when ambient module is permitted inside another module is module augmentation

// and this case is specially handled. Module augmentations should only be merged with original module definition

// and should never be merged directly with other augmentation, and the latter case would be possible if automatic merge is allowed.

if (isJSDocTypeAlias(node)) Debug.assert(isInJSFile(node)); // We shouldn't add symbols for JSDoc nodes if not in a JS file.

if ((!isAmbientModule(node) && (hasExportModifier || container.flags & NodeFlags.ExportContext)) || isJSDocTypeAlias(node)) {

if (!container.locals || (hasModifier(node, ModifierFlags.Default) && !getDeclarationName(node))) {

return declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes); // No local symbol for an unnamed default!

}

const exportKind = symbolFlags & SymbolFlags.Value ? SymbolFlags.ExportValue : 0;

const local = declareSymbol(container.locals, /*parent*/ undefined, node, exportKind, symbolExcludes);

local.exportSymbol = declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes);

node.localSymbol = local;

return local;

}

else {

return declareSymbol(container.locals!, /*parent*/ undefined, node, symbolFlags, symbolExcludes);

}

}

}

// All container nodes are kept on a linked list in declaration order. This list is used by

// the getLocalNameOfContainer function in the type checker to validate that the local name

// used for a container is unique.

function bindContainer(node: Node, containerFlags: ContainerFlags) {

// Before we recurse into a node's children, we first save the existing parent, container

// and block-container. Then after we pop out of processing the children, we restore

// these saved values.

const saveContainer = container;

const saveThisParentContainer = thisParentContainer;

const savedBlockScopeContainer = blockScopeContainer;

// Depending on what kind of node this is, we may have to adjust the current container

// and block-container. If the current node is a container, then it is automatically

// considered the current block-container as well. Also, for containers that we know

// may contain locals, we eagerly initialize the .locals field. We do this because

// it's highly likely that the .locals will be needed to place some child in (for example,

// a parameter, or variable declaration).

//

// However, we do not proactively create the .locals for block-containers because it's

// totally normal and common for block-containers to never actually have a block-scoped

// variable in them. We don't want to end up allocating an object for every 'block' we

// run into when most of them won't be necessary.

//

// Finally, if this is a block-container, then we clear out any existing .locals object

// it may contain within it. This happens in incremental scenarios. Because we can be

// reusing a node from a previous compilation, that node may have had 'locals' created

// for it. We must clear this so we don't accidentally move any stale data forward from

// a previous compilation.

if (containerFlags & ContainerFlags.IsContainer) {

if (node.kind !== SyntaxKind.ArrowFunction) {

thisParentContainer = container;

}

container = blockScopeContainer = node;

if (containerFlags & ContainerFlags.HasLocals) {

container.locals = createSymbolTable();

}

addToContainerChain(container);

}

else if (containerFlags & ContainerFlags.IsBlockScopedContainer) {

blockScopeContainer = node;

blockScopeContainer.locals = undefined;

}

if (containerFlags & ContainerFlags.IsControlFlowContainer) {

const saveCurrentFlow = currentFlow;

const saveBreakTarget = currentBreakTarget;

const saveContinueTarget = currentContinueTarget;

const saveReturnTarget = currentReturnTarget;

const saveExceptionTarget = currentExceptionTarget;

const saveActiveLabelList = activeLabelList;

const saveHasExplicitReturn = hasExplicitReturn;

const isIIFE = containerFlags & ContainerFlags.IsFunctionExpression && !hasModifier(node, ModifierFlags.Async) &&

!(<FunctionLikeDeclaration>node).asteriskToken && !!getImmediatelyInvokedFunctionExpression(node);

// A non-async, non-generator IIFE is considered part of the containing control flow. Return statements behave

// similarly to break statements that exit to a label just past the statement body.

if (!isIIFE) {

currentFlow = initFlowNode({ flags: FlowFlags.Start });

if (containerFlags & (ContainerFlags.IsFunctionExpression | ContainerFlags.IsObjectLiteralOrClassExpressionMethod)) {

currentFlow.node = <FunctionExpression | ArrowFunction | MethodDeclaration>node;

}

}

// We create a return control flow graph for IIFEs and constructors. For constructors

// we use the return control flow graph in strict property initialization checks.

currentReturnTarget = isIIFE || node.kind === SyntaxKind.Constructor ? createBranchLabel() : undefined;

currentExceptionTarget = undefined;

currentBreakTarget = undefined;

currentContinueTarget = undefined;

activeLabelList = undefined;

hasExplicitReturn = false;

bindChildren(node);

// Reset all reachability check related flags on node (for incremental scenarios)

node.flags &= ~NodeFlags.ReachabilityAndEmitFlags;

if (!(currentFlow.flags & FlowFlags.Unreachable) && containerFlags & ContainerFlags.IsFunctionLike && nodeIsPresent((<FunctionLikeDeclaration>node).body)) {

node.flags |= NodeFlags.HasImplicitReturn;

if (hasExplicitReturn) node.flags |= NodeFlags.HasExplicitReturn;

(<FunctionLikeDeclaration>node).endFlowNode = currentFlow;

}

if (node.kind === SyntaxKind.SourceFile) {

node.flags |= emitFlags;

}

if (currentReturnTarget) {

addAntecedent(currentReturnTarget, currentFlow);

currentFlow = finishFlowLabel(currentReturnTarget);

if (node.kind === SyntaxKind.Constructor) {

(<ConstructorDeclaration>node).returnFlowNode = currentFlow;

}

}

if (!isIIFE) {

currentFlow = saveCurrentFlow;

}

currentBreakTarget = saveBreakTarget;

currentContinueTarget = saveContinueTarget;

currentReturnTarget = saveReturnTarget;

currentExceptionTarget = saveExceptionTarget;

activeLabelList = saveActiveLabelList;

hasExplicitReturn = saveHasExplicitReturn;

}

else if (containerFlags & ContainerFlags.IsInterface) {

seenThisKeyword = false;

bindChildren(node);

node.flags = seenThisKeyword ? node.flags | NodeFlags.ContainsThis : node.flags & ~NodeFlags.ContainsThis;

}

else {

bindChildren(node);

}

container = saveContainer;

thisParentContainer = saveThisParentContainer;

blockScopeContainer = savedBlockScopeContainer;

}

function bindChildren(node: Node): void {

if (skipTransformFlagAggregation) {

bindChildrenWorker(node);

}

else if (node.transformFlags & TransformFlags.HasComputedFlags) {

skipTransformFlagAggregation = true;

bindChildrenWorker(node);

skipTransformFlagAggregation = false;

subtreeTransformFlags |= node.transformFlags & ~getTransformFlagsSubtreeExclusions(node.kind);

}

else {

const savedSubtreeTransformFlags = subtreeTransformFlags;

subtreeTransformFlags = 0;

bindChildrenWorker(node);

subtreeTransformFlags = savedSubtreeTransformFlags | computeTransformFlagsForNode(node, subtreeTransformFlags);

}

}

function bindEachFunctionsFirst(nodes: NodeArray<Node> | undefined): void {

bindEach(nodes, n => n.kind === SyntaxKind.FunctionDeclaration ? bind(n) : undefined);

bindEach(nodes, n => n.kind !== SyntaxKind.FunctionDeclaration ? bind(n) : undefined);

}

function bindEach(nodes: NodeArray<Node> | undefined, bindFunction: (node: Node) => void = bind): void {

if (nodes === undefined) {

return;

}

if (skipTransformFlagAggregation) {

forEach(nodes, bindFunction);

}

else {

const savedSubtreeTransformFlags = subtreeTransformFlags;

subtreeTransformFlags = TransformFlags.None;

let nodeArrayFlags = TransformFlags.None;

for (const node of nodes) {

bindFunction(node);

nodeArrayFlags |= node.transformFlags & ~TransformFlags.HasComputedFlags;

}

nodes.transformFlags = nodeArrayFlags | TransformFlags.HasComputedFlags;

subtreeTransformFlags |= savedSubtreeTransformFlags;

}

}

function bindEachChild(node: Node) {

forEachChild(node, bind, bindEach);

}

function bindChildrenWorker(node: Node): void {

if (checkUnreachable(node)) {

bindEachChild(node);

bindJSDoc(node);

return;

}

if (node.kind >= SyntaxKind.FirstStatement && node.kind <= SyntaxKind.LastStatement && !options.allowUnreachableCode) {

node.flowNode = currentFlow;

}

switch (node.kind) {

case SyntaxKind.WhileStatement:

bindWhileStatement(<WhileStatement>node);

break;

case SyntaxKind.DoStatement:

bindDoStatement(<DoStatement>node);

break;

case SyntaxKind.ForStatement:

bindForStatement(<ForStatement>node);

break;

case SyntaxKind.ForInStatement:

case SyntaxKind.ForOfStatement:

bindForInOrForOfStatement(<ForInOrOfStatement>node);

break;

case SyntaxKind.IfStatement:

bindIfStatement(<IfStatement>node);

break;

case SyntaxKind.ReturnStatement:

case SyntaxKind.ThrowStatement:

bindReturnOrThrow(<ReturnStatement | ThrowStatement>node);

break;

case SyntaxKind.BreakStatement:

case SyntaxKind.ContinueStatement:

bindBreakOrContinueStatement(<BreakOrContinueStatement>node);

break;

case SyntaxKind.TryStatement:

bindTryStatement(<TryStatement>node);

break;

case SyntaxKind.SwitchStatement:

bindSwitchStatement(<SwitchStatement>node);

break;

case SyntaxKind.CaseBlock:

bindCaseBlock(<CaseBlock>node);

break;

case SyntaxKind.CaseClause:

bindCaseClause(<CaseClause>node);

break;

case SyntaxKind.ExpressionStatement:

bindExpressionStatement(<ExpressionStatement>node);

break;

case SyntaxKind.LabeledStatement:

bindLabeledStatement(<LabeledStatement>node);

break;

case SyntaxKind.PrefixUnaryExpression:

bindPrefixUnaryExpressionFlow(<PrefixUnaryExpression>node);

break;

case SyntaxKind.PostfixUnaryExpression:

bindPostfixUnaryExpressionFlow(<PostfixUnaryExpression>node);

break;

case SyntaxKind.BinaryExpression:

bindBinaryExpressionFlow(<BinaryExpression>node);

break;

case SyntaxKind.DeleteExpression:

bindDeleteExpressionFlow(<DeleteExpression>node);

break;

case SyntaxKind.ConditionalExpression:

bindConditionalExpressionFlow(<ConditionalExpression>node);

break;

case SyntaxKind.VariableDeclaration:

bindVariableDeclarationFlow(<VariableDeclaration>node);

break;

case SyntaxKind.PropertyAccessExpression:

case SyntaxKind.ElementAccessExpression:

bindAccessExpressionFlow(<AccessExpression>node);

break;

case SyntaxKind.CallExpression:

bindCallExpressionFlow(<CallExpression>node);

break;

case SyntaxKind.JSDocTypedefTag:

case SyntaxKind.JSDocCallbackTag:

case SyntaxKind.JSDocEnumTag:

bindJSDocTypeAlias(node as JSDocTypedefTag | JSDocCallbackTag | JSDocEnumTag);

break;

// In source files and blocks, bind functions first to match hoisting that occurs at runtime

case SyntaxKind.SourceFile: {

bindEachFunctionsFirst((node as SourceFile).statements);

bind((node as SourceFile).endOfFileToken);

break;

}

case SyntaxKind.Block:

case SyntaxKind.ModuleBlock:

bindEachFunctionsFirst((node as Block).statements);

break;

default:

bindEachChild(node);

break;

}

bindJSDoc(node);

}

function isNarrowingExpression(expr: Expression): boolean {

switch (expr.kind) {

case SyntaxKind.Identifier:

case SyntaxKind.ThisKeyword:

case SyntaxKind.PropertyAccessExpression:

case SyntaxKind.ElementAccessExpression:

return containsNarrowableReference(expr);

case SyntaxKind.CallExpression:

return hasNarrowableArgument(<CallExpression>expr);

case SyntaxKind.ParenthesizedExpression:

return isNarrowingExpression((<ParenthesizedExpression>expr).expression);

case SyntaxKind.BinaryExpression:

return isNarrowingBinaryExpression(<BinaryExpression>expr);

case SyntaxKind.PrefixUnaryExpression:

return (<PrefixUnaryExpression>expr).operator === SyntaxKind.ExclamationToken && isNarrowingExpression((<PrefixUnaryExpression>expr).operand);

case SyntaxKind.TypeOfExpression:

return isNarrowingExpression((<TypeOfExpression>expr).expression);

}

return false;

}

function isNarrowableReference(expr: Expression): boolean {

return expr.kind === SyntaxKind.Identifier || expr.kind === SyntaxKind.ThisKeyword || expr.kind === SyntaxKind.SuperKeyword ||

(isPropertyAccessExpression(expr) || isNonNullExpression(expr) || isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) ||

isElementAccessExpression(expr) && isStringOrNumericLiteralLike(expr.argumentExpression) && isNarrowableReference(expr.expression);

}

function containsNarrowableReference(expr: Expression): boolean {

return isNarrowableReference(expr) || isOptionalChain(expr) && containsNarrowableReference(expr.expression);

}

function hasNarrowableArgument(expr: CallExpression) {

if (expr.arguments) {

for (const argument of expr.arguments) {

if (containsNarrowableReference(argument)) {

return true;

}

}

}

if (expr.expression.kind === SyntaxKind.PropertyAccessExpression &&

containsNarrowableReference((<PropertyAccessExpression>expr.expression).expression)) {

return true;

}

return false;

}

function isNarrowingTypeofOperands(expr1: Expression, expr2: Expression) {

return isTypeOfExpression(expr1) && isNarrowableOperand(expr1.expression) && isStringLiteralLike(expr2);

}

function isNarrowableInOperands(left: Expression, right: Expression) {

return isStringLiteralLike(left) && isNarrowingExpression(right);

}

function isNarrowingBinaryExpression(expr: BinaryExpression) {

switch (expr.operatorToken.kind) {

case SyntaxKind.EqualsToken:

return containsNarrowableReference(expr.left);

case SyntaxKind.EqualsEqualsToken:

case SyntaxKind.ExclamationEqualsToken:

case SyntaxKind.EqualsEqualsEqualsToken:

case SyntaxKind.ExclamationEqualsEqualsToken:

return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) ||

isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right);

case SyntaxKind.InstanceOfKeyword:

return isNarrowableOperand(expr.left);

case SyntaxKind.InKeyword:

return isNarrowableInOperands(expr.left, expr.right);

case SyntaxKind.CommaToken:

return isNarrowingExpression(expr.right);

}

return false;

}

function isNarrowableOperand(expr: Expression): boolean {

switch (expr.kind) {

case SyntaxKind.ParenthesizedExpression:

return isNarrowableOperand((<ParenthesizedExpression>expr).expression);

case SyntaxKind.BinaryExpression:

switch ((<BinaryExpression>expr).operatorToken.kind) {

case SyntaxKind.EqualsToken:

return isNarrowableOperand((<BinaryExpression>expr).left);

case SyntaxKind.CommaToken:

return isNarrowableOperand((<BinaryExpression>expr).right);

}

}

return containsNarrowableReference(expr);

}

function createBranchLabel(): FlowLabel {

return initFlowNode({ flags: FlowFlags.BranchLabel, antecedents: undefined });

}

function createLoopLabel(): FlowLabel {

return initFlowNode({ flags: FlowFlags.LoopLabel, antecedents: undefined });

}

function setFlowNodeReferenced(flow: FlowNode) {

// On first reference we set the Referenced flag, thereafter we set the Shared flag

flow.flags |= flow.flags & FlowFlags.Referenced ? FlowFlags.Shared : FlowFlags.Referenced;

}

function addAntecedent(label: FlowLabel, antecedent: FlowNode): void {

if (!(antecedent.flags & FlowFlags.Unreachable) && !contains(label.antecedents, antecedent)) {

(label.antecedents || (label.antecedents = [])).push(antecedent);

setFlowNodeReferenced(antecedent);

}

}

function createFlowCondition(flags: FlowFlags, antecedent: FlowNode, expression: Expression | undefined): FlowNode {

if (antecedent.flags & FlowFlags.Unreachable) {

return antecedent;

}

if (!expression) {

return flags & FlowFlags.TrueCondition ? antecedent : unreachableFlow;

}

if ((expression.kind === SyntaxKind.TrueKeyword && flags & FlowFlags.FalseCondition ||

expression.kind === SyntaxKind.FalseKeyword && flags & FlowFlags.TrueCondition) &&

!isExpressionOfOptionalChainRoot(expression) && !isNullishCoalesce(expression.parent)) {

return unreachableFlow;

}

if (!isNarrowingExpression(expression)) {

return antecedent;

}

setFlowNodeReferenced(antecedent);

return initFlowNode({ flags, antecedent, node: expression });

}

function createFlowSwitchClause(antecedent: FlowNode, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number): FlowNode {

setFlowNodeReferenced(antecedent);

return initFlowNode({ flags: FlowFlags.SwitchClause, antecedent, switchStatement, clauseStart, clauseEnd });

}

function createFlowMutation(flags: FlowFlags, antecedent: FlowNode, node: Node): FlowNode {

setFlowNodeReferenced(antecedent);

const result = initFlowNode({ flags, antecedent, node });

if (currentExceptionTarget) {

addAntecedent(currentExceptionTarget, result);

}

return result;

}

function createFlowCall(antecedent: FlowNode, node: CallExpression): FlowNode {