Emit 'for...of' statements in ES3/ES5

src/compiler/checker.ts

@@ -10891,9 +10891,9 @@ module ts {
             getSymbolDisplayBuilder().buildTypeDisplay(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags);
         }
 
-        function isUnknownIdentifier(location: Node, name: string): boolean {
+        function isUnknownIdentifier(location: Node, name: string, sourceFile: SourceFile): boolean {
             return !resolveName(location, name, SymbolFlags.Value, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined) &&
-                !hasProperty(getGeneratedNamesForSourceFile(getSourceFile(location)), name);
+                !hasProperty(getGeneratedNamesForSourceFile(sourceFile), name);
         }
 
         function getBlockScopedVariableId(n: Identifier): number {

src/compiler/emitter.ts

@@ -1639,10 +1639,12 @@ module ts {
             }
 
             if (root) {
+                currentSourceFile = root;
                 emit(root);
             }
             else {
                 forEach(host.getSourceFiles(), sourceFile => {
+                    currentSourceFile = sourceFile;
                     if (!isExternalModuleOrDeclarationFile(sourceFile)) {
                         emit(sourceFile);
                     }
@@ -1684,7 +1686,11 @@ module ts {
                 else {
                     name = generateUniqueName(baseName, n => isExistingName(location, n));
                 }
-
+
+                return putNameInCurrentScopeNames(name);
+            }
+
+            function putNameInCurrentScopeNames(name: string): string {
                 if (!currentScopeNames) {
                     currentScopeNames = {};
                 }
@@ -1694,7 +1700,7 @@ module ts {
 
             function isExistingName(location: Node, name: string) {
                 // check if resolver is aware of this name (if name was seen during the typecheck)
-                if (!resolver.isUnknownIdentifier(location, name)) {
+                if (!resolver.isUnknownIdentifier(location, name, currentSourceFile)) {
                     return true;
                 }
 
@@ -2061,6 +2067,9 @@ module ts {
 
                 function emitNodeWithMap(node: Node) {
                     if (node) {
+                        if (nodeIsSynthesized(node)) {
+                            return emitNode(node);
+                        }
                         if (node.kind != SyntaxKind.SourceFile) {
                             recordEmitNodeStartSpan(node);
                             emitNode(node);
@@ -2099,6 +2108,11 @@ module ts {
                     name = "_" + (tempCount < 25 ? String.fromCharCode(tempCount + (tempCount < 8 ? 0 : 1) + CharacterCodes.a) : tempCount - 25);
                     tempCount++;
                 }
+
+                // This is necessary so that a name generated via renameNonTopLevelLetAndConst will see the name
+                // we just generated.
+                putNameInCurrentScopeNames(name);
+
                 var result = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
                 result.text = name;
                 return result;
@@ -2882,6 +2896,12 @@ module ts {
 
                 return result;
             }
+
+            function createExpressionStatement(expression: Expression): ExpressionStatement {
+                var result = <ExpressionStatement>createSynthesizedNode(SyntaxKind.ExpressionStatement);
+                result.expression = expression;
+                return result;
+            }
 
             function createMemberAccessForPropertyName(expression: LeftHandSideExpression, memberName: DeclarationName): PropertyAccessExpression | ElementAccessExpression {
                 if (memberName.kind === SyntaxKind.Identifier) {
@@ -3444,6 +3464,10 @@ module ts {
             }
 
             function emitForInOrForOfStatement(node: ForInStatement | ForOfStatement) {
+                if (languageVersion < ScriptTarget.ES6 && node.kind === SyntaxKind.ForOfStatement) {
+                    return emitDownLevelForOfStatement(node);
+                }
+
                 var endPos = emitToken(SyntaxKind.ForKeyword, node.pos);
                 write(" ");
                 endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
@@ -3470,6 +3494,148 @@ module ts {
                 emitToken(SyntaxKind.CloseParenToken, node.expression.end);
                 emitEmbeddedStatement(node.statement);
             }
+
+            function emitDownLevelForOfStatement(node: ForOfStatement) {
+                // The following ES6 code:
+                //
+                //    for (var v of expr) { }
+                //
+                // should be emitted as
+                //
+                //    for (var _i = 0, _a = expr; _i < _a.length; _i++) {
+                //        var v = _a[_i];
+                //    }
+                //
+                // where _a and _i are temps emitted to capture the RHS and the counter,
+                // respectively.
+                // When the left hand side is an expression instead of a var declaration,
+                // the "var v" is not emitted.
+                // When the left hand side is a let/const, the v is renamed if there is
+                // another v in scope.
+                // Note that all assignments to the LHS are emitted in the body, including
+                // all destructuring.
+                // Note also that because an extra statement is needed to assign to the LHS,
+                // for-of bodies are always emitted as blocks.
+
+                var endPos = emitToken(SyntaxKind.ForKeyword, node.pos);
+                write(" ");
+                endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
+
+                // Do not emit the LHS var declaration yet, because it might contain destructuring.
+
+                // Do not call create recordTempDeclaration because we are declaring the temps
+                // right here. Recording means they will be declared later.
+                // In the case where the user wrote an identifier as the RHS, like this:
+                //
+                //     for (var v of arr) { }
+                //
+                // we don't want to emit a temporary variable for the RHS, just use it directly.
+                var rhsIsIdentifier = node.expression.kind === SyntaxKind.Identifier;
+                var counter = createTempVariable(node, /*forLoopVariable*/ true);
+                var rhsReference = rhsIsIdentifier ? <Identifier>node.expression : createTempVariable(node, /*forLoopVariable*/ false);
+
+                // This is the var keyword for the counter and rhsReference. The var keyword for
+                // the LHS will be emitted inside the body.
+                emitStart(node.expression);
+                write("var ");
+
+                // _i = 0
+                emitNode(counter);
+                write(" = 0");
+                emitEnd(node.expression);
+
+                if (!rhsIsIdentifier) {
+                    // , _a = expr
+                    write(", ");
+                    emitStart(node.expression);
+                    emitNode(rhsReference);
+                    write(" = ");
+                    emitNode(node.expression);
+                    emitEnd(node.expression);
+                }
+                write("; ");
+
+                // _i < _a.length;
+                emitStart(node.initializer);
+                emitNode(counter);
+                write(" < ");
+                emitNode(rhsReference);
+                write(".length");
+                emitEnd(node.initializer);
+                write("; ");
+
+                // _i++)
+                emitStart(node.initializer);
+                emitNode(counter);
+                write("++");
+                emitEnd(node.initializer);
+                emitToken(SyntaxKind.CloseParenToken, node.expression.end);
+
+                // Body
+                write(" {");
+                writeLine();
+                increaseIndent();
+
+                // Initialize LHS
+                // var v = _a[_i];
+                var rhsIterationValue = createElementAccessExpression(rhsReference, counter);
+                emitStart(node.initializer);
+                if (node.initializer.kind === SyntaxKind.VariableDeclarationList) {
+                    write("var ");
+                    var variableDeclarationList = <VariableDeclarationList>node.initializer;
+                    if (variableDeclarationList.declarations.length >= 1) {
+                        var declaration = variableDeclarationList.declarations[0];
+                        if (isBindingPattern(declaration.name)) {
+                            // This works whether the declaration is a var, let, or const.
+                            // It will use rhsIterationValue _a[_i] as the initializer.
+                            emitDestructuring(declaration, rhsIterationValue);
+                        }
+                        else {
+                            // The following call does not include the initializer, so we have
+                            // to emit it separately.
+                            emitNode(declaration);
+                            write(" = ");
+                            emitNode(rhsIterationValue);
+                        }
+                    }
+                    else {
+                        // It's an empty declaration list. This can only happen in an error case, if the user wrote
+                        //     for (var of []) {}
+                        var emptyDeclarationListTemp = createTempVariable(node, /*forLoopVariable*/ false);
+                        emitNode(emptyDeclarationListTemp);
+                        write(" = ");
+                        emitNode(rhsIterationValue);
+                    }
+                }
+                else {
+                    // Initializer is an expression. Emit the expression in the body, so that it's
+                    // evaluated on every iteration.
+                    var assignmentExpression = createBinaryExpression(<Expression>node.initializer, SyntaxKind.EqualsToken, rhsIterationValue, /*startsOnNewLine*/ false);
+                    var assignmentExpressionStatement = createExpressionStatement(assignmentExpression);
+                    if (node.initializer.kind === SyntaxKind.ArrayLiteralExpression || node.initializer.kind === SyntaxKind.ObjectLiteralExpression) {
+                        // This is a destructuring pattern, so call emitDestructuring instead of emit. Calling emit will not work, because it will cause
+                        // the BinaryExpression to be passed in instead of the expression statement, which will cause emitDestructuring to crash.
+                        emitDestructuring(assignmentExpressionStatement);
+                    }
+                    else {
+                        emitNode(assignmentExpression);
+                    }
+                }
+                emitEnd(node.initializer);
+                write(";");
+
+                if (node.statement.kind === SyntaxKind.Block) {
+                    emitLines((<Block>node.statement).statements);
+                }
+                else {
+                    writeLine();
+                    emit(node.statement);
+                }
+
+                writeLine();
+                decreaseIndent();
+                write("}");
+            }
 
             function emitBreakOrContinueStatement(node: BreakOrContinueStatement) {
                 emitToken(node.kind === SyntaxKind.BreakStatement ? SyntaxKind.BreakKeyword : SyntaxKind.ContinueKeyword, node.pos);
@@ -3625,13 +3791,14 @@ module ts {
                 }
             }
 
-            function emitDestructuring(root: BinaryExpression | VariableDeclaration | ParameterDeclaration, value?: Expression) {
+            // Note that a destructuring assignment can be either an ExpressionStatement or a BinaryExpression.
+            function emitDestructuring(root: ExpressionStatement | BinaryExpression | VariableDeclaration | ParameterDeclaration, value?: Expression) {
                 var emitCount = 0;
                 // An exported declaration is actually emitted as an assignment (to a property on the module object), so
                 // temporary variables in an exported declaration need to have real declarations elsewhere
                 var isDeclaration = (root.kind === SyntaxKind.VariableDeclaration && !(getCombinedNodeFlags(root) & NodeFlags.Export)) || root.kind === SyntaxKind.Parameter;
-                if (root.kind === SyntaxKind.BinaryExpression) {
-                    emitAssignmentExpression(<BinaryExpression>root);
+                if (root.kind === SyntaxKind.ExpressionStatement || root.kind === SyntaxKind.BinaryExpression) {
+                    emitAssignmentExpression(<ExpressionStatement | BinaryExpression>root);
                 }
                 else {
                     emitBindingElement(<BindingElement>root, value);
@@ -3770,13 +3937,14 @@ module ts {
                     }
                 }
 
-                function emitAssignmentExpression(root: BinaryExpression) {
-                    var target = root.left;
-                    var value = root.right;
-                    if (root.parent.kind === SyntaxKind.ExpressionStatement) {
-                        emitDestructuringAssignment(target, value);
-                    }
-                    else {
+                function emitAssignmentExpression(root: ExpressionStatement | BinaryExpression) {
+                    // Synthesized nodes will not have parents, so the ExpressionStatements will have to be passed
+                    // in directly. Otherwise, it will crash when we access the parent of a synthesized binary expression.
+                    var emitParenthesized = root.kind !== SyntaxKind.ExpressionStatement && root.parent.kind !== SyntaxKind.ExpressionStatement;
+                    var expression = <BinaryExpression>(root.kind === SyntaxKind.ExpressionStatement ? (<ExpressionStatement>root).expression : <BinaryExpression>root);
+                    var target = expression.left;
+                    var value = expression.right;
+                    if (emitParenthesized) {
                         if (root.parent.kind !== SyntaxKind.ParenthesizedExpression) {
                             write("(");
                         }
@@ -3788,6 +3956,9 @@ module ts {
                             write(")");
                         }
                     }
+                    else {
+                        emitDestructuringAssignment(target, value);
+                    }
                 }
 
                 function emitBindingElement(target: BindingElement, value: Expression) {
@@ -3846,7 +4017,7 @@ module ts {
                     }
                 }
                 else {
-                    var isLet = renameNonTopLevelLetAndConst(<Identifier>node.name);
+                    renameNonTopLevelLetAndConst(<Identifier>node.name);
                     emitModuleMemberName(node);
 
                     var initializer = node.initializer;
@@ -5037,7 +5208,6 @@ module ts {
             }
 
             function emitSourceFile(node: SourceFile) {
-                currentSourceFile = node;
                 // Start new file on new line
                 writeLine();
                 emitDetachedComments(node);

src/compiler/types.ts

@@ -1204,7 +1204,7 @@ module ts {
         isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
-        isUnknownIdentifier(location: Node, name: string): boolean;
+        isUnknownIdentifier(location: Node, name: string, sourceFile: SourceFile): boolean;
         getBlockScopedVariableId(node: Identifier): number;
     }
 

tests/baselines/reference/APISample_compile.js

@@ -940,7 +940,7 @@ declare module "typescript" {
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
         isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
-        isUnknownIdentifier(location: Node, name: string): boolean;
+        isUnknownIdentifier(location: Node, name: string, sourceFile: SourceFile): boolean;
         getBlockScopedVariableId(node: Identifier): number;
     }
     const enum SymbolFlags {

tests/baselines/reference/APISample_compile.types

@@ -3057,11 +3057,13 @@ declare module "typescript" {
 >PropertyAccessExpression : PropertyAccessExpression
 >ElementAccessExpression : ElementAccessExpression
 
-        isUnknownIdentifier(location: Node, name: string): boolean;
->isUnknownIdentifier : (location: Node, name: string) => boolean
+        isUnknownIdentifier(location: Node, name: string, sourceFile: SourceFile): boolean;
+>isUnknownIdentifier : (location: Node, name: string, sourceFile: SourceFile) => boolean
 >location : Node
 >Node : Node
 >name : string
+>sourceFile : SourceFile
+>SourceFile : SourceFile
 
         getBlockScopedVariableId(node: Identifier): number;
 >getBlockScopedVariableId : (node: Identifier) => number

tests/baselines/reference/APISample_linter.js

@@ -971,7 +971,7 @@ declare module "typescript" {
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
         isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
-        isUnknownIdentifier(location: Node, name: string): boolean;
+        isUnknownIdentifier(location: Node, name: string, sourceFile: SourceFile): boolean;
         getBlockScopedVariableId(node: Identifier): number;
     }
     const enum SymbolFlags {

tests/baselines/reference/APISample_linter.types

@@ -3203,11 +3203,13 @@ declare module "typescript" {
 >PropertyAccessExpression : PropertyAccessExpression
 >ElementAccessExpression : ElementAccessExpression
 
-        isUnknownIdentifier(location: Node, name: string): boolean;
->isUnknownIdentifier : (location: Node, name: string) => boolean
+        isUnknownIdentifier(location: Node, name: string, sourceFile: SourceFile): boolean;
+>isUnknownIdentifier : (location: Node, name: string, sourceFile: SourceFile) => boolean
 >location : Node
 >Node : Node
 >name : string
+>sourceFile : SourceFile
+>SourceFile : SourceFile
 
         getBlockScopedVariableId(node: Identifier): number;
 >getBlockScopedVariableId : (node: Identifier) => number

tests/baselines/reference/APISample_transform.js

@@ -972,7 +972,7 @@ declare module "typescript" {
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
         isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
-        isUnknownIdentifier(location: Node, name: string): boolean;
+        isUnknownIdentifier(location: Node, name: string, sourceFile: SourceFile): boolean;
         getBlockScopedVariableId(node: Identifier): number;
     }
     const enum SymbolFlags {