dart2js cps: Emit unlabeled breaks and continues when possible.

pkg/compiler/lib/src/js_backend/codegen/codegen.dart

 // Copyright (c) 2014, 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 code_generator;
 
 import 'glue.dart';
 
 import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
 import '../../tree_ir/tree_ir_nodes.dart' show BuiltinOperator;
@@ skipping 30 matching lines @@
 
   /// Maps local constants to their name.
   Maplet<VariableElement, String> constantNames =
       new Maplet<VariableElement, String>();
 
   /// Variable names that have already been used. Used to avoid name clashes.
   Set<String> usedVariableNames = new Set<String>();
 
   final tree_ir.FallthroughStack fallthrough = new tree_ir.FallthroughStack();
 
+  /// Stacks whose top element is the current target of an unlabeled break
+  /// or continue. For continues, this is the loop node itself.
+  final tree_ir.FallthroughStack shortBreak = new tree_ir.FallthroughStack();
+  final tree_ir.FallthroughStack shortContinue = 
+      new tree_ir.FallthroughStack();
+
   Set<tree_ir.Label> usedLabels = new Set<tree_ir.Label>();
 
   List<js.Statement> accumulator = new List<js.Statement>();
 
   CodeGenerator(this.glue, this.registry);
 
   /// Generates JavaScript code for the body of [function].
   js.Fun buildFunction(tree_ir.FunctionDefinition function) {
     currentFunction = function.element;
     visitStatement(function.body);
@@ skipping 322 matching lines @@
   @override
   js.Expression visitAssign(tree_ir.Assign node) {
     return new js.Assignment(
         buildVariableAccess(node.variable),
         visitExpression(node.value));
   }
 
   @override
   void visitContinue(tree_ir.Continue node) {
     tree_ir.Statement next = fallthrough.target;
-    if (node.target.binding == next) {
-      // Fall through to continue target
+    if (node.target.binding == next ||
+        next is tree_ir.Continue && node.target == next.target) {
+      // Fall through to continue target or to equivalent continue.
       fallthrough.use();
-    } else if (next is tree_ir.Continue && next.target == node.target) {
-      // Fall through to equivalent continue
-      fallthrough.use();
+    } else if (node.target.binding == shortContinue.target) {
+      // The target is the immediately enclosing loop.
+      shortContinue.use();
+      accumulator.add(new js.Continue(null));
     } else {
       usedLabels.add(node.target);
       accumulator.add(new js.Continue(node.target.name));
     }
   }
 
+  /// True if [other] is the target of [node] or is a [Break] with the same
+  /// target. This means jumping to [other] is equivalent to executing [node].
+  bool isEffectiveBreakTarget(tree_ir.Break node, tree_ir.Statement other) {
+    return node.target.binding.next == other ||
+           other is tree_ir.Break && node.target == other.target;
+  }
+
   @override
   void visitBreak(tree_ir.Break node) {
-    tree_ir.Statement next = fallthrough.target;
-    if (node.target.binding.next == next) {
-      // Fall through to break target
+    if (isEffectiveBreakTarget(node, fallthrough.target)) {
+      // Fall through to break target or to equivalent break.
       fallthrough.use();
-    } else if (next is tree_ir.Break && next.target == node.target) {
-      // Fall through to equivalent break
-      fallthrough.use();
+    } else if (isEffectiveBreakTarget(node, shortBreak.target)) {
+      // Unlabeled break to the break target or to an equivalent break.
+      shortBreak.use();
+      accumulator.add(new js.Break(null)); 
     } else {
       usedLabels.add(node.target);
       accumulator.add(new js.Break(node.target.name));
     }
   }
 
   @override
   void visitExpressionStatement(tree_ir.ExpressionStatement node) {
     accumulator.add(new js.ExpressionStatement(
         visitExpression(node.expression)));
@@ skipping 12 matching lines @@
     } else {
       // The 'then' body cannot complete normally, so emit a short 'if'
       // and put the 'else' body after it.
       accumulator.add(new js.If.noElse(condition, thenBody));
       visitStatement(node.elseStatement);
     }
   }
 
   @override
   void visitLabeledStatement(tree_ir.LabeledStatement node) {
-    accumulator.add(buildLabeled(() => buildBodyStatement(node.body),
-                                 node.label,
-                                 node.next));
+    fallthrough.push(node.next);
+    js.Statement body = buildBodyStatement(node.body);
+    fallthrough.pop();
+    accumulator.add(insertLabel(node.label, body));
     visitStatement(node.next);
   }
 
-  js.Statement buildLabeled(js.Statement buildBody(),
-                            tree_ir.Label label,
-                            tree_ir.Statement fallthroughStatement) {
-    fallthrough.push(fallthroughStatement);
-    js.Statement result = buildBody();
+  /// Wraps a node in a labeled statement unless the label is unused.
+  js.Statement insertLabel(tree_ir.Label label, js.Statement node) {
     if (usedLabels.remove(label)) {
-      result = new js.LabeledStatement(label.name, result);
+      return new js.LabeledStatement(label.name, node);
+    } else {
+      return node;
     }
-    fallthrough.pop();
-    return result;
   }
 
   /// Returns the current [accumulator] wrapped in a block if neccessary.
   js.Statement _bodyAsStatement() {
     if (accumulator.length == 0) {
       return new js.EmptyStatement();
     }
     if (accumulator.length == 1) {
       return accumulator.single;
     }
@@ skipping 12 matching lines @@
 
   js.Block buildBodyBlock(tree_ir.Statement statement) {
     List<js.Statement> savedAccumulator = accumulator;
     accumulator = <js.Statement>[];
     visitStatement(statement);
     js.Statement result = new js.Block(accumulator);
     accumulator = savedAccumulator;
     return result;
   }
 
-  js.Statement buildWhile(js.Expression condition,
-                          tree_ir.Statement body,
-                          tree_ir.Label label,
-                          tree_ir.Statement fallthroughStatement) {
-    return buildLabeled(() => new js.While(condition, buildBodyStatement(body)),
-                        label,
-                        fallthroughStatement);
-  }
-
   @override
   void visitWhileCondition(tree_ir.WhileCondition node) {
-    accumulator.add(
-        buildWhile(visitExpression(node.condition),
-                   node.body,
-                   node.label,
-                   node));
+    js.Expression condition = visitExpression(node.condition);
+    shortBreak.push(node.next);
+    shortContinue.push(node);
+    fallthrough.push(node);
+    js.Statement jsBody = buildBodyStatement(node.body);
+    fallthrough.pop();
+    shortContinue.pop();
+    shortBreak.pop();
+    accumulator.add(insertLabel(node.label, new js.While(condition, jsBody)));
     visitStatement(node.next);
   }
 
   @override
   void visitWhileTrue(tree_ir.WhileTrue node) {
-    accumulator.add(
-        buildWhile(new js.LiteralBool(true), node.body, node.label, node));
+    js.Expression condition = new js.LiteralBool(true);
+    // A short break in the while will jump to the current fallthrough target.
+    shortBreak.push(fallthrough.target);
+    shortContinue.push(node);
+    fallthrough.push(node);
+    js.Statement jsBody = buildBodyStatement(node.body);
+    fallthrough.pop();
+    shortContinue.pop();
+    if (shortBreak.useCount > 0) {
+      // Short breaks use the current fallthrough target.
+      fallthrough.use();
+    }
+    shortBreak.pop();
+    accumulator.add(insertLabel(node.label, new js.While(condition, jsBody)));
   }
 
   bool isNull(tree_ir.Expression node) {
     return node is tree_ir.Constant && node.value.isNull;
   }
 
   @override
   void visitReturn(tree_ir.Return node) {
     if (isNull(node.value) && fallthrough.target == null) {
       // Do nothing. Implicitly return JS undefined by falling over the end.
@@ skipping 259 matching lines @@
         return js.js("typeof # === 'number' && Math.floor(#) === #", args);
     }
   }
 
   visitFunctionExpression(tree_ir.FunctionExpression node) {
     // FunctionExpressions are currently unused.
     // We might need them if we want to emit raw JS nested functions.
     throw 'FunctionExpressions should not be used';
   }
 }