NonInstantiated = 0,

Instantiated = 1,

ConstEnumOnly = 2

name: string;

breakTarget: FlowLabel;

continueTarget: FlowLabel;

referenced: boolean;

// A module is uninstantiated if it contains only

// 1. interface declarations, type alias declarations

if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.TypeAliasDeclaration) {

return ModuleInstanceState.NonInstantiated;

}

// 2. const enum declarations

else if (isConstEnumDeclaration(node)) {

return ModuleInstanceState.ConstEnumOnly;

}

// 3. non-exported import declarations

else if ((node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration) && !(hasModifier(node, ModifierFlags.Export))) {

return ModuleInstanceState.NonInstantiated;

}

// 4. other uninstantiated module declarations.

else if (node.kind === SyntaxKind.ModuleBlock) {

let state = ModuleInstanceState.NonInstantiated;

forEachChild(node, n => {

switch (getModuleInstanceState(n)) {

case ModuleInstanceState.NonInstantiated:

// child is non-instantiated - continue searching

return false;

case ModuleInstanceState.ConstEnumOnly:

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

state = ModuleInstanceState.ConstEnumOnly;

return false;

case ModuleInstanceState.Instantiated:

// child is instantiated - record state and stop

state = ModuleInstanceState.Instantiated;

return true;

}

});

return state;

}

else if (node.kind === SyntaxKind.ModuleDeclaration) {

const body = (<ModuleDeclaration>node).body;

return body ? getModuleInstanceState(body) : ModuleInstanceState.Instantiated;

}

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

// be considered the same as type alias

else if (node.kind === SyntaxKind.Identifier && (<Identifier>node).isInJSDocNamespace) {

return ModuleInstanceState.NonInstantiated;

}

else {

return ModuleInstanceState.Instantiated;

}

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

performance.mark("beforeBind");

binder(file, options);

performance.mark("afterBind");

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

let file: SourceFile;

let options: CompilerOptions;

let languageVersion: ScriptTarget;

let parent: Node;

let container: Node;

let blockScopeContainer: Node;

let lastContainer: Node;

let seenThisKeyword: boolean;

// state used by control flow analysis

let currentFlow: FlowNode;

let currentBreakTarget: FlowLabel;

let currentContinueTarget: FlowLabel;

let currentReturnTarget: FlowLabel;

let currentTrueTarget: FlowLabel;

let currentFalseTarget: FlowLabel;

let preSwitchCaseFlow: FlowNode;

let activeLabels: ActiveLabel[];

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: Map<string>;

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;

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

file = f;

options = opts;

languageVersion = getEmitScriptTarget(options);

inStrictMode = bindInStrictMode(file, opts);

classifiableNames = createMap<string>();

symbolCount = 0;

skipTransformFlagAggregation = isDeclarationFile(file);

Symbol = objectAllocator.getSymbolConstructor();

if (!file.locals) {

bind(file);

file.symbolCount = symbolCount;

file.classifiableNames = classifiableNames;

}

file = undefined;

options = undefined;

languageVersion = undefined;

parent = undefined;

container = undefined;

blockScopeContainer = undefined;

lastContainer = 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 (opts.alwaysStrict && !isDeclarationFile(file)) {

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

if (!symbol.declarations) {

symbol.declarations = [];

}

symbol.declarations.push(node);

if (symbolFlags & SymbolFlags.HasExports && !symbol.exports) {

symbol.exports = createMap<Symbol>();

}

if (symbolFlags & SymbolFlags.HasMembers && !symbol.members) {

symbol.members = createMap<Symbol>();

}

if (symbolFlags & SymbolFlags.Value) {

const valueDeclaration = symbol.valueDeclaration;

if (!valueDeclaration ||

(valueDeclaration.kind !== node.kind && valueDeclaration.kind === SyntaxKind.ModuleDeclaration)) {

// other kinds of value declarations take precedence over modules

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 {

if (node.name) {

if (isAmbientModule(node)) {

return isGlobalScopeAugmentation(<ModuleDeclaration>node) ? "__global" : `"${(<LiteralExpression>node.name).text}"`;

}

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

const nameExpression = (<ComputedPropertyName>node.name).expression;

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

if (isStringOrNumericLiteral(nameExpression)) {

return nameExpression.text;

}

Debug.assert(isWellKnownSymbolSyntactically(nameExpression));

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

}

return (<Identifier | LiteralExpression>node.name).text;

}

switch (node.kind) {

case SyntaxKind.Constructor:

return "__constructor";

case SyntaxKind.FunctionType:

case SyntaxKind.CallSignature:

return "__call";

case SyntaxKind.ConstructorType:

case SyntaxKind.ConstructSignature:

return "__new";

case SyntaxKind.IndexSignature:

return "__index";

case SyntaxKind.ExportDeclaration:

return "__export";

case SyntaxKind.ExportAssignment:

return (<ExportAssignment>node).isExportEquals ? "export=" : "default";

case SyntaxKind.BinaryExpression:

switch (getSpecialPropertyAssignmentKind(node)) {

case SpecialPropertyAssignmentKind.ModuleExports:

// module.exports = ...

return "export=";

case SpecialPropertyAssignmentKind.ExportsProperty:

case SpecialPropertyAssignmentKind.ThisProperty:

// exports.x = ... or this.y = ...

return ((node as BinaryExpression).left as PropertyAccessExpression).name.text;

case SpecialPropertyAssignmentKind.PrototypeProperty:

// className.prototype.methodName = ...

return (((node as BinaryExpression).left as PropertyAccessExpression).expression as PropertyAccessExpression).name.text;

}

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

break;

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ClassDeclaration:

return hasModifier(node, ModifierFlags.Default) ? "default" : undefined;

case SyntaxKind.JSDocFunctionType:

return isJSDocConstructSignature(node) ? "__new" : "__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);

const functionType = <JSDocFunctionType>node.parent;

const index = indexOf(functionType.parameters, node);

return "arg" + index;

case SyntaxKind.JSDocTypedefTag:

const parentNode = node.parent && node.parent.parent;

let nameFromParentNode: string;

if (parentNode && parentNode.kind === SyntaxKind.VariableStatement) {

if ((<VariableStatement>parentNode).declarationList.declarations.length > 0) {

const nameIdentifier = (<VariableStatement>parentNode).declarationList.declarations[0].name;

if (nameIdentifier.kind === SyntaxKind.Identifier) {

nameFromParentNode = (<Identifier>nameIdentifier).text;

}

}

}

return nameFromParentNode;

}

}

function getDisplayName(node: Declaration): string {

return node.name ? declarationNameToString(node.name) : getDeclarationName(node);

}

/**

function declareSymbol(symbolTable: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): 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 ? "default" : getDeclarationName(node);

let symbol: Symbol;

if (name === undefined) {

symbol = createSymbol(SymbolFlags.None, "__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[name] || (symbolTable[name] = createSymbol(SymbolFlags.None, name));

if (name && (includes & SymbolFlags.Classifiable)) {

classifiableNames[name] = name;

}

if (symbol.flags & excludes) {

if (symbol.isReplaceableByMethod) {

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

// prototype symbols like methods.

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

}

else {

if (node.name) {

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;

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;

}

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 &&

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

message = Diagnostics.A_module_cannot_have_multiple_default_exports;

}

}

}

forEach(symbol.declarations, declaration => {

file.bindDiagnostics.push(createDiagnosticForNode(declaration.name || declaration, message, getDisplayName(declaration)));

});

file.bindDiagnostics.push(createDiagnosticForNode(node.name || node, message, getDisplayName(node)));

symbol = createSymbol(SymbolFlags.None, name);

}

}

}

addDeclarationToSymbol(symbol, node, includes);

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, undefined, node, symbolFlags, symbolExcludes);

}

}

else {

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

// ExportType, or ExportContainer 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.

const isJSDocTypedefInJSDocNamespace = node.kind === SyntaxKind.JSDocTypedefTag &&

node.name &&

node.name.kind === SyntaxKind.Identifier &&

(<Identifier>node.name).isInJSDocNamespace;

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

const exportKind =

(symbolFlags & SymbolFlags.Value ? SymbolFlags.ExportValue : 0) |

(symbolFlags & SymbolFlags.Type ? SymbolFlags.ExportType : 0) |

(symbolFlags & SymbolFlags.Namespace ? SymbolFlags.ExportNamespace : 0);

const local = declareSymbol(container.locals, 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, 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 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 proactively 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) {

container = blockScopeContainer = node;

if (containerFlags & ContainerFlags.HasLocals) {

container.locals = createMap<Symbol>();

}

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) && !!getImmediatelyInvokedFunctionExpression(node);

// A non-async 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) {

currentReturnTarget = createBranchLabel();

}

else {

currentFlow = { flags: FlowFlags.Start };

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

(<FlowStart>currentFlow).container = <FunctionExpression | ArrowFunction | MethodDeclaration>node;

}

currentReturnTarget = 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 (isIIFE) {

addAntecedent(currentReturnTarget, currentFlow);

currentFlow = finishFlowLabel(currentReturnTarget);

}

else {

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;

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 bindEach(nodes: NodeArray<Node>) {

if (nodes === undefined) {

return;

}

if (skipTransformFlagAggregation) {

forEach(nodes, bind);

}

else {

const savedSubtreeTransformFlags = subtreeTransformFlags;

subtreeTransformFlags = TransformFlags.None;

let nodeArrayFlags = TransformFlags.None;

for (const node of nodes) {

bind(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 {

// Binding of JsDocComment should be done before the current block scope container changes.

// because the scope of JsDocComment should not be affected by whether the current node is a

// container or not.

if (isInJavaScriptFile(node) && node.jsDoc) {

forEach(node.jsDoc, bind);

}

if (checkUnreachable(node)) {

bindEachChild(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(<ForInStatement | ForOfStatement>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;

default:

bindEachChild(node);

break;

}

}

function isNarrowingExpression(expr: Expression): boolean {

switch (expr.kind) {

case SyntaxKind.Identifier:

case SyntaxKind.ThisKeyword:

case SyntaxKind.PropertyAccessExpression:

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

}

return false;

}

function isNarrowableReference(expr: Expression): boolean {

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

expr.kind === SyntaxKind.ThisKeyword ||

expr.kind === SyntaxKind.PropertyAccessExpression && isNarrowableReference((<PropertyAccessExpression>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 expr1.kind === SyntaxKind.TypeOfExpression && isNarrowableOperand((<TypeOfExpression>expr1).expression) && expr2.kind === SyntaxKind.StringLiteral;

}

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.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): 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 <FlowCondition>{

flags,

expression,

antecedent

};

}

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

if (!isNarrowingExpression(switchStatement.expression)) {

return antecedent;

}

setFlowNodeReferenced(antecedent);

return <FlowSwitchClause>{

flags: FlowFlags.SwitchClause,

switchStatement,

clauseStart,

clauseEnd,

antecedent

};

}

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

setFlowNodeReferenced(antecedent);

return <FlowAssignment>{

flags: FlowFlags.Assignment,

antecedent,

node

};

}

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

setFlowNodeReferenced(antecedent);

return <FlowArrayMutation>{

flags: FlowFlags.ArrayMutation,

antecedent,

node

};

}

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;