container = file;

setBlockScopeContainer(file, /*cleanLocals*/ false);

function setBlockScopeContainer(node: Node, cleanLocals: boolean) {

blockScopeContainer = node;

if (cleanLocals) {

blockScopeContainer.locals = undefined;

}

}

// in incremental scenarios we might reuse nodes that already have locals being allocated

// during the bind step these locals should be dropped to prevent using stale data.

// locals should always be dropped unless they were previously initialized by the binder

// these cases are:

// - node has locals (symbolKind & HasLocals) !== 0

// - node is a source file

setBlockScopeContainer(node, /*cleanLocals*/ (symbolKind & SymbolFlags.HasLocals) === 0 && node.kind !== SyntaxKind.SourceFile);

checkBlockScopedBindingCapturedInLoop(node, symbol);

function isInsideFunction(node: Node, threshold: Node): boolean {

var current = node;

while (current && current !== threshold) {

if (isAnyFunction(current)) {

return true;

}

current = current.parent;

}

return false;

}

function checkBlockScopedBindingCapturedInLoop(node: Identifier, symbol: Symbol): void {

if (languageVersion >= ScriptTarget.ES6 ||

(symbol.flags & SymbolFlags.BlockScopedVariable) === 0 ||

symbol.valueDeclaration.parent.kind === SyntaxKind.CatchClause) {

return;

}

// - check if binding is used in some function

// (stop the walk when reaching container of binding declaration)

// - if first check succeeded - check if variable is declared inside the loop

// nesting structure:

// (variable declaration or binding element) -> variable declaration list -> container

var container: Node = symbol.valueDeclaration;

while (container.kind !== SyntaxKind.VariableDeclarationList) {

container = container.parent;

}

// get the parent of variable declaration list

container = container.parent;

if (container.kind === SyntaxKind.VariableStatement) {

// if parent is variable statement - get its parent

container = container.parent;

}

var inFunction = isInsideFunction(node.parent, container);

var current = container;

while (current && !nodeStartsNewLexicalEnvironment(current)) {

if (isIterationStatement(current, /*lookInLabeledStatements*/ false)) {

if (inFunction) {

grammarErrorOnFirstToken(current, Diagnostics.Loop_contains_block_scoped_variable_0_referenced_by_a_function_in_the_loop_This_is_only_supported_in_ECMAScript_6_or_higher, declarationNameToString(node));

}

// mark value declaration so during emit they can have a special handling

getNodeLinks(<VariableDeclaration>symbol.valueDeclaration).flags |= NodeCheckFlags.BlockScopedBindingInLoop;

break;

}

current = current.parent;

}

}

var name = generateUniqueName(baseName, isExistingName);

return generatedNames[name] = name;

function getBlockScopedVariableId(n: Identifier): number {

Debug.assert(!nodeIsSynthesized(n));

// ignore name parts of property access expressions

if (n.parent.kind === SyntaxKind.PropertyAccessExpression &&

(<PropertyAccessExpression>n.parent).name === n) {

return undefined;

}

// ignore property names in object binding patterns

if (n.parent.kind === SyntaxKind.BindingElement &&

(<BindingElement>n.parent).propertyName === n) {

return undefined;

}

// for names in variable declarations and binding elements try to short circuit and fetch symbol from the node

var declarationSymbol: Symbol =

(n.parent.kind === SyntaxKind.VariableDeclaration && (<VariableDeclaration>n.parent).name === n) ||

n.parent.kind === SyntaxKind.BindingElement

? getSymbolOfNode(n.parent)

: undefined;

var symbol = declarationSymbol ||

getNodeLinks(n).resolvedSymbol ||

resolveName(n, n.text, SymbolFlags.BlockScopedVariable | SymbolFlags.Import, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined);

var isLetOrConst =

symbol &&

(symbol.flags & SymbolFlags.BlockScopedVariable) &&

symbol.valueDeclaration.parent.kind !== SyntaxKind.CatchClause;

if (isLetOrConst) {

// side-effect of calling this method:

// assign id to symbol if it was not yet set

getSymbolLinks(symbol);

return symbol.id;

}

return undefined;

}

getBlockScopedVariableId,

// const declarations should not be initialized in for-in for-of statements

if (isConst(node) && node.parent.parent.kind !== SyntaxKind.ForInStatement && node.parent.parent.kind !== SyntaxKind.ForOfStatement) {

Loop_contains_block_scoped_variable_0_referenced_by_a_function_in_the_loop_This_is_only_supported_in_ECMAScript_6_or_higher: { code: 4091, category: DiagnosticCategory.Error, key: "Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher." },

"Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.": {

"category": "Error",

"code": 4091

},