Emit for...of when LHS is expression

src/compiler/emitter.ts

@@ -3491,10 +3491,10 @@ module ts {
                 var endPos = emitToken(SyntaxKind.ForKeyword, node.pos);
                 write(" ");
                 endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
+                write("var ");
                 if (node.initializer.kind === SyntaxKind.VariableDeclarationList) {
                     var variableDeclarationList = <VariableDeclarationList>node.initializer;
                     if (variableDeclarationList.declarations.length >= 1) {
-                        write("var ");
                         var decl = variableDeclarationList.declarations[0];
                         // TODO handle binding patterns
                         emit(decl.name);
@@ -3537,13 +3537,25 @@ module ts {
                 // v = _a[_i];
                 if (decl) {
                     emit(decl.name);
-                    write(" = ");
-                    emit(rhsReference)
-                    write("[");
-                    emit(counter);
-                    write("];");
-                    writeLine();
                 }
+                else if (variableDeclarationList) {
+                    // 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);
+                    write("var ");
+                    emit(emptyDeclarationListTemp);
+                }
+                else {
+                    // Initializer is an expression. Emit the expression in the body, so that it's
+                    // evaluated on every iteration.
+                    emit(node.initializer);
+                }
+                write(" = ");
+                emit(rhsReference)
+                write("[");
+                emit(counter);
+                write("];");
+                writeLine();
                 
                 if (node.statement.kind === SyntaxKind.Block) {
                     emitLines((<Block>node.statement).statements);

tests/baselines/reference/ES5For-of10.js

@@ -0,0 +1,20 @@
+//// [ES5For-of10.ts]
+function foo() {
+    return { x: 0 };
+}
+for (foo().x of []) {
+    for (foo().x of [])
+        var p = foo().x;
+}
+
+//// [ES5For-of10.js]
+function foo() {
+    return { x: 0 };
+}
+for (var _i = 0, _a = []; _i < _a.length; _i++) {
+    foo().x = _a[_i];
+    for (var _i_1 = 0, _a_1 = []; _i_1 < _a_1.length; _i_1++) {
+        foo().x = _a_1[_i_1];
+        var p = foo().x;
+    }
+}

tests/baselines/reference/ES5For-of11.js

@@ -0,0 +1,9 @@
+//// [ES5For-of11.ts]
+var v;
+for (v of []) { }
+
+//// [ES5For-of11.js]
+var v;
+for (var _i = 0, _a = []; _i < _a.length; _i++) {
+    v = _a[_i];
+}

tests/baselines/reference/ES5For-of12.js

@@ -0,0 +1,7 @@
+//// [ES5For-of12.ts]
+for ([""] of []) { }
+
+//// [ES5For-of12.js]
+for (var _i = 0, _a = []; _i < _a.length; _i++) {
+    [""] = _a[_i];
+}

tests/baselines/reference/ES5For-of8.js

@@ -0,0 +1,16 @@
+//// [ES5For-of8.ts]
+function foo() {
+    return { x: 0 };
+}
+for (foo().x of []) {
+    var p = foo().x;
+}
+
+//// [ES5For-of8.js]
+function foo() {
+    return { x: 0 };
+}
+for (var _i = 0, _a = []; _i < _a.length; _i++) {
+    foo().x = _a[_i];
+    var p = foo().x;
+}

tests/baselines/reference/ES5For-of9.js

@@ -0,0 +1,21 @@
+//// [ES5For-of9.ts]
+function foo() {
+    return { x: 0 };
+}
+for (foo().x of []) {
+    for (foo().x of []) {
+        var p = foo().x;
+    }
+}
+
+//// [ES5For-of9.js]
+function foo() {
+    return { x: 0 };
+}
+for (var _i = 0, _a = []; _i < _a.length; _i++) {
+    foo().x = _a[_i];
+    for (var _i_1 = 0, _a_1 = []; _i_1 < _a_1.length; _i_1++) {
+        foo().x = _a_1[_i_1];
+        var p = foo().x;
+    }
+}

tests/baselines/reference/parserES5ForOfStatement2.js

@@ -3,5 +3,6 @@ for (var of X) {
 }
 
 //// [parserES5ForOfStatement2.js]
-for (_i = 0, _a = X; _i < _a.length; _i++) {
+for (var _i = 0, _a = X; _i < _a.length; _i++) {
+    var _a_1 = _a[_i];
 }

tests/baselines/reference/parserES5ForOfStatement21.js

@@ -2,5 +2,6 @@
 for (var of of) { }
 
 //// [parserES5ForOfStatement21.js]
-for (_i = 0, _a = of; _i < _a.length; _i++) {
+for (var _i = 0, _a = of; _i < _a.length; _i++) {
+    var _a_1 = _a[_i];
 }

tests/cases/conformance/statements/for-ofStatements/ES5For-of10.ts

@@ -0,0 +1,7 @@
+function foo() {
+    return { x: 0 };
+}
+for (foo().x of []) {
+    for (foo().x of [])
+        var p = foo().x;
+}

tests/cases/conformance/statements/for-ofStatements/ES5For-of11.ts

@@ -0,0 +1,2 @@
+var v;
+for (v of []) { }

tests/cases/conformance/statements/for-ofStatements/ES5For-of12.ts

@@ -0,0 +1 @@
+for ([""] of []) { }

tests/cases/conformance/statements/for-ofStatements/ES5For-of8.ts

@@ -0,0 +1,6 @@
+function foo() {
+    return { x: 0 };
+}
+for (foo().x of []) {
+    var p = foo().x;
+}

tests/cases/conformance/statements/for-ofStatements/ES5For-of9.ts

@@ -0,0 +1,8 @@
+function foo() {
+    return { x: 0 };
+}
+for (foo().x of []) {
+    for (foo().x of []) {
+        var p = foo().x;
+    }
+}