/* @internal */

namespace ts {

export const enum ModuleInstanceState {

NonInstantiated = 0,

Instantiated = 1,

ConstEnumOnly = 2

}

interface ActiveLabel {

name: __String;

breakTarget: FlowLabel;

continueTarget: FlowLabel;

referenced: boolean;

}

export function getModuleInstanceState(node: ModuleDeclaration): ModuleInstanceState {

return node.body ? getModuleInstanceStateWorker(node.body) : ModuleInstanceState.Instantiated;

}

function getModuleInstanceStateWorker(node: Node): 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. other uninstantiated module declarations.

case SyntaxKind.ModuleBlock: {

let state = ModuleInstanceState.NonInstantiated;

forEachChild(node, n => {

const childState = getModuleInstanceStateWorker(n);

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);

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;

}

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,

}

const binder = createBinder();

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

performance.mark("beforeBind");

binder(file, options);

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)[];

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 preSwitchCaseFlow: FlowNode | undefined;

let activeLabels: 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 }; // tslint:disable-line variable-name

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();

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;

activeLabels = 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 = append(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();

}

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);

}

Debug.assert(isWellKnownSymbolSyntactically(nameExpression));

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

}

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;

}

if (symbol.declarations && symbol.declarations.length) {

// 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;

}

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;

}

}

}

const addError = (decl: Declaration): void => {

file.bindDiagnostics.push(createDiagnosticForNode(getNameOfDeclaration(decl) || decl, message, messageNeedsName ? getDisplayName(decl) : undefined));

};

forEach(symbol.declarations, addError);

addError(node);

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 (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 saveActiveLabels = activeLabels;

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 = { flags: FlowFlags.Start };

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

currentFlow.container = <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 intialization checks.

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

currentBreakTarget = undefined;

currentContinueTarget = undefined;

activeLabels = 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;

}

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;

activeLabels = saveActiveLabels;

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;

}

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.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.CallExpression:

bindCallExpressionFlow(<CallExpression>node);

break;

case SyntaxKind.JSDocTypedefTag:

case SyntaxKind.JSDocCallbackTag:

bindJSDocTypeAlias(node as JSDocTypedefTag | JSDocCallbackTag);

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 isNarrowableReference(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) && isNarrowableReference(expr.expression) ||

isElementAccessExpression(expr) && expr.argumentExpression &&

(isStringLiteral(expr.argumentExpression) || isNumericLiteral(expr.argumentExpression)) &&

isNarrowableReference(expr.expression);

}

function hasNarrowableArgument(expr: CallExpression) {

if (expr.arguments) {

for (const argument of expr.arguments) {

if (isNarrowableReference(argument)) {

return true;

}

}

}

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

isNarrowableReference((<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 isNarrowableReference(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 isNarrowableReference(expr);

}

function createBranchLabel(): FlowLabel {

return {

flags: FlowFlags.BranchLabel,

antecedents: undefined

};

}

function createLoopLabel(): FlowLabel {

return {

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) {

return unreachableFlow;

}

if (!isNarrowingExpression(expression)) {

return antecedent;

}

setFlowNodeReferenced(antecedent);

return { flags, expression, antecedent };

}

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

if (!isNarrowingExpression(switchStatement.expression)) {

return antecedent;

}

setFlowNodeReferenced(antecedent);

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

}

function createFlowAssignment(antecedent: FlowNode, node: Expression | VariableDeclaration | BindingElement): FlowNode {

setFlowNodeReferenced(antecedent);

return { flags: FlowFlags.Assignment, antecedent, node };

}

function createFlowArrayMutation(antecedent: FlowNode, node: CallExpression | BinaryExpression): FlowNode {

setFlowNodeReferenced(antecedent);

const res: FlowArrayMutation = { flags: FlowFlags.ArrayMutation, antecedent, node };

return res;

}

function finishFlowLabel(flow: FlowLabel): FlowNode {

const antecedents = flow.antecedents;

if (!antecedents) {

return unreachableFlow;

}

if (antecedents.length === 1) {

return antecedents[0];

}

return flow;

}

function isStatementCondition(node: Node) {

const parent = node.parent;

switch (parent.kind) {

case SyntaxKind.IfStatement:

case SyntaxKind.WhileStatement:

case SyntaxKind.DoStatement:

return (<IfStatement | WhileStatement | DoStatement>parent).expression === node;

case SyntaxKind.ForStatement:

case SyntaxKind.ConditionalExpression:

return (<ForStatement | ConditionalExpression>parent).condition === node;

}

return false;

}

function isLogicalExpression(node: Node) {

while (true) {

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

node = (<ParenthesizedExpression>node).expression;

}

else if (node.kind === SyntaxKind.PrefixUnaryExpression && (<PrefixUnaryExpression>node).operator === SyntaxKind.ExclamationToken) {

node = (<PrefixUnaryExpression>node).operand;

}

else {

return node.kind === SyntaxKind.BinaryExpression && (

(<BinaryExpression>node).operatorToken.kind === SyntaxKind.AmpersandAmpersandToken ||

(<BinaryExpression>node).operatorToken.kind === SyntaxKind.BarBarToken);

}

}

}

function isTopLevelLogicalExpression(node: Node): boolean {

while (node.parent.kind === SyntaxKind.ParenthesizedExpression ||

node.parent.kind === SyntaxKind.PrefixUnaryExpression &&

(<PrefixUnaryExpression>node.parent).operator === SyntaxKind.ExclamationToken) {

node = node.parent;

}

return !isStatementCondition(node) && !isLogicalExpression(node.parent);

}

function bindCondition(node: Expression | undefined, trueTarget: FlowLabel, falseTarget: FlowLabel) {

const saveTrueTarget = currentTrueTarget;

const saveFalseTarget = currentFalseTarget;

currentTrueTarget = trueTarget;

currentFalseTarget = falseTarget;

bind(node);

currentTrueTarget = saveTrueTarget;

currentFalseTarget = saveFalseTarget;

if (!node || !isLogicalExpression(node)) {

addAntecedent(trueTarget, createFlowCondition(FlowFlags.TrueCondition, currentFlow, node));

addAntecedent(falseTarget, createFlowCondition(FlowFlags.FalseCondition, currentFlow, node));

}

}

function bindIterativeStatement(node: Statement, breakTarget: FlowLabel, continueTarget: FlowLabel): void {

const saveBreakTarget = currentBreakTarget;

const saveContinueTarget = currentContinueTarget;

currentBreakTarget = breakTarget;

currentContinueTarget = continueTarget;

bind(node);

currentBreakTarget = saveBreakTarget;

currentContinueTarget = saveContinueTarget;

}

function bindWhileStatement(node: WhileStatement): void {

const preWhileLabel = createLoopLabel();

const preBodyLabel = createBranchLabel();

const postWhileLabel = createBranchLabel();

addAntecedent(preWhileLabel, currentFlow);

currentFlow = preWhileLabel;

bindCondition(node.expression, preBodyLabel, postWhileLabel);

currentFlow = finishFlowLabel(preBodyLabel);

bindIterativeStatement(node.statement, postWhileLabel, preWhileLabel);

addAntecedent(preWhileLabel, currentFlow);

currentFlow = finishFlowLabel(postWhileLabel);

}

function bindDoStatement(node: DoStatement): void {

const preDoLabel = createLoopLabel();

const enclosingLabeledStatement = node.parent.kind === SyntaxKind.LabeledStatement

? lastOrUndefined(activeLabels!)

: undefined;

// if do statement is wrapped in labeled statement then target labels for break/continue with or without

// label should be the same

const preConditionLabel = enclosingLabeledStatement ? enclosingLabeledStatement.continueTarget : createBranchLabel();

const postDoLabel = enclosingLabeledStatement ? enclosingLabeledStatement.breakTarget : createBranchLabel();

addAntecedent(preDoLabel, currentFlow);

currentFlow = preDoLabel;

bindIterativeStatement(node.statement, postDoLabel, preConditionLabel);

addAntecedent(preConditionLabel, currentFlow);

currentFlow = finishFlowLabel(preConditionLabel);

bindCondition(node.expression, preDoLabel, postDoLabel);

currentFlow = finishFlowLabel(postDoLabel);

}

function bindForStatement(node: ForStatement): void {

const preLoopLabel = createLoopLabel();

const preBodyLabel = createBranchLabel();

const postLoopLabel = createBranchLabel();

bind(node.initializer);

addAntecedent(preLoopLabel, currentFlow);

currentFlow = preLoopLabel;

bindCondition(node.condition, preBodyLabel, postLoopLabel);

currentFlow = finishFlowLabel(preBodyLabel);

bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);

bind(node.incrementor);

addAntecedent(preLoopLabel, currentFlow);

currentFlow = finishFlowLabel(postLoopLabel);

}

function bindForInOrForOfStatement(node: ForInOrOfStatement): void {

const preLoopLabel = createLoopLabel();

const postLoopLabel = createBranchLabel();