/// <reference path="utilities.ts"/>

/// <reference path="parser.ts"/>

/* @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: Node): ModuleInstanceState {

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

}

else {

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,

}

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

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 = !!file.externalModuleIndicator;

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

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

let functionType = <JSDocFunctionType>node.parent;

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

}

/**

* 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, 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;

forEach(symbol.declarations, declaration => {

if (hasModifier(declaration, ModifierFlags.Default)) {

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.

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

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

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

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

}

currentReturnTarget = undefined;

}

currentBreakTarget = undefined;

currentContinueTarget = undefined;

activeLabels = undefined;

hasExplicitReturn = false;

bindChildren(node);

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

// Reset all emit helper 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;

}

else {

const savedSubtreeTransformFlags = subtreeTransformFlags;

subtreeTransformFlags = 0;

bindChildrenWorker(node);

subtreeTransformFlags = savedSubtreeTransformFlags | computeTransformFlagsForNode(node, subtreeTransformFlags);

}

}

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

forEach(node.jsDocComments, bind);

}

if (checkUnreachable(node)) {

forEachChild(node, bind);

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:

forEachChild(node, bind);

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 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, 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 preConditionLabel = createBranchLabel();

const postDoLabel = 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: ForInStatement | ForOfStatement): void {

const preLoopLabel = createLoopLabel();

const postLoopLabel = createBranchLabel();

addAntecedent(preLoopLabel, currentFlow);

currentFlow = preLoopLabel;

bind(node.expression);

addAntecedent(postLoopLabel, currentFlow);

bind(node.initializer);

if (node.initializer.kind !== SyntaxKind.VariableDeclarationList) {

bindAssignmentTargetFlow(<Expression>node.initializer);

}

bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);

addAntecedent(preLoopLabel, currentFlow);

currentFlow = finishFlowLabel(postLoopLabel);

}

function bindIfStatement(node: IfStatement): void {

const thenLabel = createBranchLabel();

const elseLabel = createBranchLabel();

const postIfLabel = createBranchLabel();

bindCondition(node.expression, thenLabel, elseLabel);

currentFlow = finishFlowLabel(thenLabel);

bind(node.thenStatement);

addAntecedent(postIfLabel, currentFlow);

currentFlow = finishFlowLabel(elseLabel);

bind(node.elseStatement);

addAntecedent(postIfLabel, currentFlow);

currentFlow = finishFlowLabel(postIfLabel);

}

function bindReturnOrThrow(node: ReturnStatement | ThrowStatement): void {

bind(node.expression);

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

hasExplicitReturn = true;

if (currentReturnTarget) {

addAntecedent(currentReturnTarget, currentFlow);

}

}

currentFlow = unreachableFlow;

}

function findActiveLabel(name: string) {

if (activeLabels) {

for (const label of activeLabels) {

if (label.name === name) {

return label;

}

}

}

return undefined;

}

function bindbreakOrContinueFlow(node: BreakOrContinueStatement, breakTarget: FlowLabel, continueTarget: FlowLabel) {

const flowLabel = node.kind === SyntaxKind.BreakStatement ? breakTarget : continueTarget;

if (flowLabel) {

addAntecedent(flowLabel, currentFlow);

currentFlow = unreachableFlow;

}

}

function bindBreakOrContinueStatement(node: BreakOrContinueStatement): void {

bind(node.label);

if (node.label) {

const activeLabel = findActiveLabel(node.label.text);

if (activeLabel) {

activeLabel.referenced = true;

bindbreakOrContinueFlow(node, activeLabel.breakTarget, activeLabel.continueTarget);

}

}

else {

bindbreakOrContinueFlow(node, currentBreakTarget, currentContinueTarget);

}

}

function bindTryStatement(node: TryStatement): void {

const postFinallyLabel = createBranchLabel();

const preTryFlow = currentFlow;

// TODO: Every statement in try block is potentially an exit point!

bind(node.tryBlock);

addAntecedent(postFinallyLabel, currentFlow);

if (node.catchClause) {

currentFlow = preTryFlow;

bind(node.catchClause);

addAntecedent(postFinallyLabel, currentFlow);

}

if (node.finallyBlock) {

currentFlow = preTryFlow;

bind(node.finallyBlock);

}

currentFlow = finishFlowLabel(postFinallyLabel);

}

function bindSwitchStatement(node: SwitchStatement): void {

const postSwitchLabel = createBranchLabel();

bind(node.expression);

const saveBreakTarget = currentBreakTarget;

const savePreSwitchCaseFlow = preSwitchCaseFlow;

currentBreakTarget = postSwitchLabel;

preSwitchCaseFlow = currentFlow;

bind(node.caseBlock);

addAntecedent(postSwitchLabel, currentFlow);

const hasDefault = forEach(node.caseBlock.clauses, c => c.kind === SyntaxKind.DefaultClause);

// We mark a switch statement as possibly exhaustive if it has no default clause and if all

// case clauses have unreachable end points (e.g. they all return).

node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents;

if (!hasDefault) {

addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0));

}

currentBreakTarget = saveBreakTarget;

preSwitchCaseFlow = savePreSwitchCaseFlow;

currentFlow = finishFlowLabel(postSwitchLabel);

}

function bindCaseBlock(node: CaseBlock): void {

const clauses = node.clauses;

let fallthroughFlow = unreachableFlow;

for (let i = 0; i < clauses.length; i++) {

const clauseStart = i;

while (!clauses[i].statements.length && i + 1 < clauses.length) {

bind(clauses[i]);

i++;

}

const preCaseLabel = createBranchLabel();