Fix "continue to a label" in dart2js async code.

pkg/compiler/lib/src/js/rewrite_async.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library rewrite_async;
 
 import "dart:math" show max;
 import 'dart:collection';
 
 import 'package:_internal/compiler/js_lib/shared/async_await_error_codes.dart'
@@ skipping 902 matching lines @@
 
   @override
   void visitDefault(js.Default node) => unreachable(node);
 
   @override
   void visitDo(js.Do node) {
     if (!shouldTransform(node)) {
       bool oldInsideUntranslatedBreakable = insideUntranslatedBreakable;
       insideUntranslatedBreakable = true;
       withExpression(node.condition, (js.Expression condition) {
-        addStatement(js.js.statement('do {#} while (#)', [node.body, condition]));
+        addStatement(js.js.statement('do {#} while (#)',
+                                     [node.body, condition]));
       }, store: false);
       insideUntranslatedBreakable = oldInsideUntranslatedBreakable;
       return;
     }
     int startLabel = newLabel("do body");
 
     int continueLabel = newLabel("do condition");
     continueLabels[node] = continueLabel;
 
     int afterLabel = newLabel("after do");
@@ skipping 11 matching lines @@
           [condition, gotoAndBreak(startLabel)]));
     }, store: false);
     beginLabel(afterLabel);
   }
 
   @override
   void visitEmptyStatement(js.EmptyStatement node) {
     addStatement(node);
   }
 
-  void visitExpressionInStatementContext(js.Expression node) {
-    if (node is js.VariableDeclarationList) {
-      // Treat js.VariableDeclarationList as a statement.
-      visitVariableDeclarationList(node);
-    } else {
-      visitExpressionIgnoreResult(node);
-    }
+
+  @override
+  void visitExpressionStatement(js.ExpressionStatement node) {
+    visitExpressionIgnoreResult(node.expression);
   }
 
   @override
-  void visitExpressionStatement(js.ExpressionStatement node) {
-    visitExpressionInStatementContext(node.expression);
-  }
-
-  @override
   void visitFor(js.For node) {
     if (!shouldTransform(node)) {
       bool oldInsideUntranslated = insideUntranslatedBreakable;
       insideUntranslatedBreakable = true;
       // Note that node.init, node.condition, node.update all can be null, but
       // withExpressions handles that.
       withExpressions([
         node.init,
         node.condition,
         node.update
       ], (List<js.Expression> transformed) {
         addStatement(new js.For(transformed[0], transformed[1], transformed[2],
              translateInBlock(node.body)));
       });
       insideUntranslatedBreakable = oldInsideUntranslated;
       return;
     }
 
     if (node.init != null) {
-      visitExpressionInStatementContext(node.init);
+      addExpressionStatement(visitExpression(node.init));
     }
     int startLabel = newLabel("for condition");
     // If there is no update, continuing the loop is the same as going to the
     // start.
     int continueLabel =
         (node.update == null) ? startLabel : newLabel("for update");
     continueLabels[node] = continueLabel;
     int afterLabel = newLabel("after for");
     breakLabels[node] = afterLabel;
     beginLabel(startLabel);
@@ skipping 103 matching lines @@
     return unsupported(node);
   }
 
   @override
   void visitLabeledStatement(js.LabeledStatement node) {
     if (!shouldTransform(node)) {
       addStatement(
           new js.LabeledStatement(node.label, translateInBlock(node.body)));
       return;
     }
+    // `continue label` is really continuing the nested loop.
+    // This is set up in [PreTranslationAnalysis.visitContinue].
+    // Here we only need a breakLabel:
     int breakLabel = newLabel("break ${node.label}");
-    int continueLabel = newLabel("continue ${node.label}");
     breakLabels[node] = breakLabel;
-    continueLabels[node] = continueLabel;
 
-    beginLabel(continueLabel);
     jumpTargets.add(node);
     visitStatement(node.body);
     jumpTargets.removeLast();
     beginLabel(breakLabel);
   }
 
   @override
   js.Expression visitLiteralBool(js.LiteralBool node) => node;
 
   @override
@@ skipping 355 matching lines @@
     }
     beginLabel(afterFinallyLabel);
   }
 
   @override
   visitVariableDeclaration(js.VariableDeclaration node) {
     unreachable(node);
   }
 
   @override
-  void visitVariableDeclarationList(js.VariableDeclarationList node) {
+  js.Expression visitVariableDeclarationList(js.VariableDeclarationList node) {
+    List<js.Assignment> initializations = new List<js.Assignment>();
+
     // Declaration of local variables is hoisted outside the helper but the
     // initialization is done here.
     for (js.VariableInitialization initialization in node.declarations) {
       js.VariableDeclaration declaration = initialization.declaration;
       localVariables.add(declaration);
       if (initialization.value != null) {
         withExpression(initialization.value, (js.Expression value) {
-          addStatement(new js.ExpressionStatement(
-              new js.Assignment(new js.VariableUse(declaration.name), value)));
+          initializations.add(
+              new js.Assignment(new js.VariableUse(declaration.name), value));
         }, store: false);
       }
     }
+    return initializations.isEmpty ? js.number(0)

[floitsch, 2015/03/13 14:20:22]

Make this an if.
Explain why "0".

[sigurdm, 2015/03/16 08:43:51]

Done.

+        : initializations.reduce((js.Expression first, js.Expression second) {
+      return new js.Binary(",", first, second);
+    });
   }
 
   @override
   void visitVariableInitialization(js.VariableInitialization node) {
     unreachable(node);
   }
 
   @override
   js.Expression visitVariableUse(js.VariableUse node) {
     Pair<String, String> renaming = variableRenamings.lastWhere(
@@ skipping 682 matching lines @@
   bool visitConditional(js.Conditional node) {
     bool condition = visit(node.condition);
     bool then = visit(node.then);
     bool otherwise = visit(node.otherwise);
     return condition || then || otherwise;
   }
 
   @override
   bool visitContinue(js.Continue node) {
     if (node.targetLabel != null) {
-      targets[node] = labelledStatements.lastWhere(
+      js.LabeledStatement targetLabel = labelledStatements.lastWhere(
           (js.LabeledStatement stm) => stm.label == node.targetLabel);
+      js.Loop targetStatement = targetLabel.body;
+      targets[node] = targetStatement;
     } else {
       targets[node] =
           loopsAndSwitches.lastWhere((js.Node node) => node is! js.Switch);
     }
     assert(() {
       js.Node target = targets[node];
       return target is js.Loop ||
           (target is js.LabeledStatement && target.body is js.Loop);
     });
     return false;
@@ skipping 258 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }