Downlevel emit for let\const

src/compiler/binder.ts

@@ -67,7 +67,8 @@ module ts {
 
  if (!file.locals) {
  file.locals = {};
- container = blockScopeContainer = file;
+ container = file;
+ setBlockScopeContainer(file, /*cleanLocals*/ false);
  bind(file);
  file.symbolCount = symbolCount;
  }
@@ -77,6 +78,13 @@ module ts {
  return new Symbol(flags, name);
  }
 
+ function setBlockScopeContainer(node: Node, cleanLocals: boolean) {
+ blockScopeContainer = node;
+ if (cleanLocals) {
+ blockScopeContainer.locals = undefined;
+ }
+ }
+
  function addDeclarationToSymbol(symbol: Symbol, node: Declaration, symbolKind: SymbolFlags) {
  symbol.flags |= symbolKind;
  if (!symbol.declarations) symbol.declarations = [];
@@ -236,7 +244,13 @@ module ts {
  }
 
  if (isBlockScopeContainer) {
- blockScopeContainer = node;
+ // 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);
  }
 
  forEachChild(node, bind);

src/compiler/checker.ts

@@ -5075,10 +5075,63 @@ module ts {
 
  checkCollisionWithCapturedSuperVariable(node, node);
  checkCollisionWithCapturedThisVariable(node, node);
+ checkBlockScopedBindingCapturedInLoop(node, symbol);
 
  return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node);
  }
 
+ 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;
+ }
+ }
+
  function captureLexicalThis(node: Node, container: Node): void {
  var classNode = container.parent && container.parent.kind === SyntaxKind.ClassDeclaration ? container.parent : undefined;
  getNodeLinks(node).flags |= NodeCheckFlags.LexicalThis;
@@ -10467,25 +10520,8 @@ module ts {
  }
 
  function makeUniqueName(baseName: string): string {
- // First try '_name'
- if (baseName.charCodeAt(0) !== CharacterCodes._) {
- var baseName = "_" + baseName;
- if (!isExistingName(baseName)) {
- return generatedNames[baseName] = baseName;
- }
- }
- // Find the first unique '_name_n', where n is a positive number
- if (baseName.charCodeAt(baseName.length - 1) !== CharacterCodes._) {
- baseName += "_";
- }
- var i = 1;
- while (true) {
- name = baseName + i;
- if (!isExistingName(name)) {
- return generatedNames[name] = name;
- }
- i++;
- }
+ var name = generateUniqueName(baseName, isExistingName);
+ return generatedNames[name] = name;
  }
 
  function assignGeneratedName(node: Node, name: string) {
@@ -10686,6 +10722,46 @@ module ts {
  !hasProperty(getGeneratedNamesForSourceFile(getSourceFile(location)), 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;
+ }
+
  function createResolver(): EmitResolver {
  return {
  getGeneratedNameForNode,
@@ -10702,6 +10778,7 @@ module ts {
  isEntityNameVisible,
  getConstantValue,
  isUnknownIdentifier,
+ getBlockScopedVariableId,
  };
  }
 
@@ -11443,7 +11520,8 @@ module ts {
  if (isBindingPattern(node.name) && !isBindingPattern(node.parent)) {
  return grammarErrorOnNode(node, Diagnostics.A_destructuring_declaration_must_have_an_initializer);
  }
- if (isConst(node)) {
+ // 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) {
  return grammarErrorOnNode(node, Diagnostics.const_declarations_must_be_initialized);
  }
  }
@@ -11485,15 +11563,6 @@ module ts {
  if (!declarationList.declarations.length) {
  return grammarErrorAtPos(getSourceFileOfNode(declarationList), declarations.pos, declarations.end - declarations.pos, Diagnostics.Variable_declaration_list_cannot_be_empty);
  }
-
- if (languageVersion < ScriptTarget.ES6) {
- if (isLet(declarationList)) {
- return grammarErrorOnFirstToken(declarationList, Diagnostics.let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher);
- }
- else if (isConst(declarationList)) {
- return grammarErrorOnFirstToken(declarationList, Diagnostics.const_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher);
- }
- }
  }
 
  function allowLetAndConstDeclarations(parent: Node): boolean {

src/compiler/diagnosticInformationMap.generated.ts

@@ -397,6 +397,7 @@ module ts {
  Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: { code: 4077, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'." },
  Parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4078, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using private name '{1}'." },
  Exported_type_alias_0_has_or_is_using_private_name_1: { code: 4081, category: DiagnosticCategory.Error, key: "Exported type alias '{0}' has or is using private name '{1}'." },
+ 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." },
  The_current_host_does_not_support_the_0_option: { code: 5001, category: DiagnosticCategory.Error, key: "The current host does not support the '{0}' option." },
  Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: DiagnosticCategory.Error, key: "Cannot find the common subdirectory path for the input files." },
  Cannot_read_file_0_Colon_1: { code: 5012, category: DiagnosticCategory.Error, key: "Cannot read file '{0}': {1}" },

src/compiler/diagnosticMessages.json

@@ -1581,6 +1581,10 @@
  "category": "Error",
  "code": 4081
  },
+ "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
+ },
  "The current host does not support the '{0}' option.": {
  "category": "Error",
  "code": 5001