dart2dart: Restore loops with conditions and updates in backend.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree.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 dart_tree;
 
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart'
     show Element, FunctionElement, FunctionSignature, ParameterElement,
          ClassElement;
@@ skipping 20 matching lines @@
 /**
  * The base class of all Tree nodes.
  */
 abstract class Node {
 }
 
 /**
  * The base class of [Expression]s.
  */
 abstract class Expression extends Node {
-  accept(Visitor v);
+  accept(ExpressionVisitor v);
 
   /// Temporary variable used by [StatementRewriter].
   /// If set to true, this expression has already had enclosing assignments
   /// propagated into its variables, and should not be processed again.
   /// It is only set for expressions that are known to be in risk of redundant
   /// processing.
   bool processed = false;
 }
 
 abstract class Statement extends Node {
   Statement get next;
   void set next(Statement s);
-  accept(Visitor v);
+  accept(StatementVisitor v);
 }
 
 /**
  * Labels name [LabeledStatement]s.
  */
 class Label {
   // A counter used to generate names.  The counter is reset to 0 for each
   // function emitted.
   static int counter = 0;
   static String _newName() => 'L${counter++}';
 
   String cachedName;
 
   String get name {
     if (cachedName == null) cachedName = _newName();
     return cachedName;
   }
 
-  /// Number of [Break] statements that target this label.
+  /// Number of [Break] or [Continue] statements that target this label.
   /// The [Break] constructor will increment this automatically, but the
   /// counter must be decremented by hand when a [Break] becomes orphaned.
-  int breakCount = 0;
+  int useCount = 0;
 
-  /// The [LabeledStatement] binding this label.
-  LabeledStatement binding;
+  /// The [LabeledStatement] or [WhileTrue] binding this label.
+  JumpTarget binding;
 }
 
 /**
  * Variables are [Expression]s.
  */
 class Variable extends Expression {
   // A counter used to generate names.  The counter is reset to 0 for each
   // function emitted.
   static int counter = 0;
   static String _newName() => 'v${counter++}';
 
   Element element;
   String cachedName;
 
   String get name {
     if (cachedName != null) return cachedName;
     return cachedName = ((element == null) ? _newName() : element.name);
   }
 
   Variable(this.element);
 
-  accept(Visitor visitor) => visitor.visitVariable(this);
+  accept(ExpressionVisitor visitor) => visitor.visitVariable(this);
 }
 
 /**
  * Common interface for invocations with arguments.
  */
 abstract class Invoke {
   List<Expression> get arguments;
   Selector get selector;
 }
 
 /**
  * A call to a static target.
  *
  * In contrast to the CPS-based IR, the arguments can be arbitrary expressions.
  */
 class InvokeStatic extends Expression implements Invoke {
   final FunctionElement target;
   final List<Expression> arguments;
   final Selector selector;
 
   InvokeStatic(this.target, this.selector, this.arguments);
 
-  accept(Visitor visitor) => visitor.visitInvokeStatic(this);
+  accept(ExpressionVisitor visitor) => visitor.visitInvokeStatic(this);
 }
 
 /**
  * A call to a method, operator, getter, setter or index getter/setter.
  *
  * In contrast to the CPS-based IR, the receiver and arguments can be
  * arbitrary expressions.
  */
 class InvokeMethod extends Expression implements Invoke {
   Expression receiver;
   final Selector selector;
   final List<Expression> arguments;
 
   InvokeMethod(this.receiver, this.selector, this.arguments) {
     assert(receiver != null);
   }
 
-  accept(Visitor visitor) => visitor.visitInvokeMethod(this);
+  accept(ExpressionVisitor visitor) => visitor.visitInvokeMethod(this);
 }
 
 /**
  * Non-const call to a factory or generative constructor.
  */
 class InvokeConstructor extends Expression implements Invoke {
   final GenericType type;
   final FunctionElement target;
   final List<Expression> arguments;
   final Selector selector;
 
   InvokeConstructor(this.type, this.target, this.selector, this.arguments);
 
   ClassElement get targetClass => target.enclosingElement;
 
-  accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
+  accept(ExpressionVisitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
 /// Calls [toString] on each argument and concatenates the results.
 class ConcatenateStrings extends Expression {
   final List<Expression> arguments;
 
   ConcatenateStrings(this.arguments);
 
-  accept(Visitor visitor) => visitor.visitConcatenateStrings(this);
+  accept(ExpressionVisitor visitor) => visitor.visitConcatenateStrings(this);
 }
 
 /**
  * A constant.
  */
 class Constant extends Expression {
   dart2js.Constant value;
 
   Constant(this.value);
 
-  accept(Visitor visitor) => visitor.visitConstant(this);
+  accept(ExpressionVisitor visitor) => visitor.visitConstant(this);
 }
 
 class LiteralList extends Expression {
   final List<Expression> values;
 
   LiteralList(this.values) ;
 
-  accept(Visitor visitor) => visitor.visitLiteralList(this);
+  accept(ExpressionVisitor visitor) => visitor.visitLiteralList(this);
 }
 
 class LiteralMap extends Expression {
   final List<Expression> keys;
   final List<Expression> values;
 
   LiteralMap(this.keys, this.values) ;
 
-  accept(Visitor visitor) => visitor.visitLiteralMap(this);
+  accept(ExpressionVisitor visitor) => visitor.visitLiteralMap(this);
 }
 
 class InvokeConstConstructor extends Expression implements Invoke {
   final GenericType type;
   final FunctionElement target;
   final List<Expression> arguments;
   final Selector selector;
 
   ClassElement get targetClass => target.enclosingElement;
 
   InvokeConstConstructor(this.type, this.target, this.selector, this.arguments);
 
-  accept(Visitor visitor) => visitor.visitInvokeConstConstructor(this);
+  accept(ExpressionVisitor visitor) => visitor.visitInvokeConstConstructor(this);
 }
 
 /// A conditional expression.
 class Conditional extends Expression {
   Expression condition;
   Expression thenExpression;
   Expression elseExpression;
 
   Conditional(this.condition, this.thenExpression, this.elseExpression);
 
-  accept(Visitor visitor) => visitor.visitConditional(this);
+  accept(ExpressionVisitor visitor) => visitor.visitConditional(this);
 }
 
 /// An && or || expression. The operator is internally represented as a boolean
 /// [isAnd] to simplify rewriting of logical operators.
 class LogicalOperator extends Expression {
   Expression left;
   bool isAnd;
   Expression right;
 
   LogicalOperator(this.left, this.right, this.isAnd);
   LogicalOperator.and(this.left, this.right) : isAnd = true;
   LogicalOperator.or(this.left, this.right) : isAnd = false;
 
   String get operator => isAnd ? '&&' : '||';
 
-  accept(Visitor visitor) => visitor.visitLogicalOperator(this);
+  accept(ExpressionVisitor visitor) => visitor.visitLogicalOperator(this);
 }
 
 /// Logical negation.
 class Not extends Expression {
   Expression operand;
 
   Not(this.operand);
 
-  accept(Visitor visitor) => visitor.visitNot(this);
+  accept(ExpressionVisitor visitor) => visitor.visitNot(this);
+}
+
+/// A [LabeledStatement] or [WhileTrue] or [WhileCondition].
+abstract class JumpTarget extends Statement {
+  Label get label;
+  Statement get body;
 }
 
 /**
  * A labeled statement.  Breaks to the label within the labeled statement
  * target the successor statement.
  */
-class LabeledStatement extends Statement {
+class LabeledStatement extends JumpTarget {
   Statement next;
   final Label label;
   Statement body;
 
   LabeledStatement(this.label, this.body, this.next) {
     assert(label.binding == null);
     label.binding = this;
   }
 
-  accept(Visitor visitor) => visitor.visitLabeledStatement(this);
+  accept(StatementVisitor visitor) => visitor.visitLabeledStatement(this);
+}
+
+/// A [WhileTrue] or [WhileCondition] loop.
+abstract class Loop extends JumpTarget {
+  /// When a [Continue] to a loop is executed, all update expressions are
+  /// evaluated right-to-left before control resumes at the head of the loop.
+  List<Expression> get updates;
+}
+
+/**
+ * A labeled while(true) loop.
+ */
+class WhileTrue extends Loop {
+  final Label label;
+  Statement body;
+  final List<Expression> updates = <Expression>[];
+
+  WhileTrue(this.label, this.body) {
+    assert(label.binding == null);
+    label.binding = this;
+  }
+
+  Statement get next => null;
+  void set next(Statement s) => throw 'UNREACHABLE';
+
+  accept(StatementVisitor visitor) => visitor.visitWhileTrue(this);
+}
+
+/**
+ * A while loop with a condition. If the condition is false, control resumes
+ * at the [next] statement.
+ *
+ * It is NOT valid to target this statement with a [Break].
+ * The only way to reach [next] is for the condition to evaluate to false.
+ *
+ * [WhileCondition] statements are introduced in the [LoopRewriter] and is
+ * assumed not to occur before then.
+ */
+class WhileCondition extends Loop {
+  final Label label;
+  Expression condition;
+  Statement body;
+  Statement next;
+  final List<Expression> updates;
+
+  WhileCondition(this.label, this.condition, this.body,
+                 this.next, this.updates) {
+    assert(label.binding == null);
+    label.binding = this;
+  }
+
+  accept(StatementVisitor visitor) => visitor.visitWhileCondition(this);
+}
+
+
+/// A [Break] or [Continue] statement.
+abstract class Jump extends Statement {
+  Label get target;
+}
+
+/**
+ * A break from an enclosing [LabeledStatement].  The break targets the
+ * labeled statement's successor statement.
+ */
+class Break extends Jump {
+  final Label target;
+
+  Statement get next => null;
+  void set next(Statement s) => throw 'UNREACHABLE';
+
+  Break(this.target) {
+    ++target.useCount;
+  }
+
+  accept(StatementVisitor visitor) => visitor.visitBreak(this);
+}
+
+/**
+ * A continue to an enclosing [WhileTrue] loop.  The continue targets the
+ * loop's body.
+ */
+class Continue extends Jump {
+  final Label target;
+
+  Statement get next => null;
+  void set next(Statement s) => throw 'UNREACHABLE';
+
+  Continue(this.target) {
+    ++target.useCount;
+  }
+
+  accept(StatementVisitor visitor) => visitor.visitContinue(this);
 }
 
 /**
  * An assignments of an [Expression] to a [Variable].
  *
  * In contrast to the CPS-based IR, non-primitive expressions can be assigned
  * to variables.
  */
 class Assign extends Statement {
   Statement next;
   final Variable variable;
   Expression definition;
   final bool hasExactlyOneUse;
 
   Assign(this.variable, this.definition, this.next, this.hasExactlyOneUse);
 
-  accept(Visitor visitor) => visitor.visitAssign(this);
+  accept(StatementVisitor visitor) => visitor.visitAssign(this);
 }
 
+
 /**
  * A return exit from the function.
  *
  * In contrast to the CPS-based IR, the return value is an arbitrary
  * expression.
  */
 class Return extends Statement {
   /// Should not be null. Use [Constant] with [NullConstant] for void returns.
   Expression value;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Return(this.value);
 
-  accept(Visitor visitor) => visitor.visitReturn(this);
+  accept(StatementVisitor visitor) => visitor.visitReturn(this);
 }
 
-/**
- * A break from an enclosing [LabeledStatement].  The break targets the
- * labeled statement's successor statement.
- */
-class Break extends Statement {
-  Label _target;
 
-  Label get target => _target;
-  void set target(Label newTarget) {
-    ++newTarget.breakCount;
-    --_target.breakCount;
-    _target = newTarget;
-  }
 
-  Statement get next => null;
-  void set next(Statement s) => throw 'UNREACHABLE';
-
-  Break(this._target) {
-    ++target.breakCount;
-  }
-
-  accept(Visitor visitor) => visitor.visitBreak(this);
-}
-
-/**
- * A continue to an enclosing [While] loop.  The continue targets the
- * loop's body.
- */
-class Continue extends Statement {
-  Label target;
-
-  Statement get next => null;
-  void set next(Statement s) => throw 'UNREACHABLE';
-
-  Continue(this.target);
-
-  accept(Visitor visitor) => visitor.visitContinue(this);
-}
 
 /**
  * A conditional branch based on the true value of an [Expression].
  */
 class If extends Statement {
   Expression condition;
   Statement thenStatement;
   Statement elseStatement;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   If(this.condition, this.thenStatement, this.elseStatement);
 
-  accept(Visitor visitor) => visitor.visitIf(this);
-}
-
-/**
- * A labeled while(true) loop.
- */
-class While extends Statement {
-  final Label label;
-  Statement body;
-
-  While(this.label, this.body);
-
-  Statement get next => null;
-  void set next(Statement s) => throw 'UNREACHABLE';
-
-  accept(Visitor visitor) => visitor.visitWhile(this);
+  accept(StatementVisitor visitor) => visitor.visitIf(this);
 }
 
 
 class ExpressionStatement extends Statement {
   Statement next;
   Expression expression;
 
   ExpressionStatement(this.expression, this.next);
 
-  accept(Visitor visitor) => visitor.visitExpressionStatement(this);
+  accept(StatementVisitor visitor) => visitor.visitExpressionStatement(this);
 }
 
 class FunctionDefinition extends Node {
   final List<Variable> parameters;
   Statement body;
 
   FunctionDefinition(this.parameters, this.body);
 }
 
-abstract class Visitor<S, E> {
+abstract class ExpressionVisitor<E> {
   E visitExpression(Expression e) => e.accept(this);
   E visitVariable(Variable node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitInvokeConstConstructor(InvokeConstConstructor node);
+}
 
+abstract class StatementVisitor<S> {
   S visitStatement(Statement s) => s.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitAssign(Assign node);
   S visitReturn(Return node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
-  S visitWhile(While node);
+  S visitWhileTrue(WhileTrue node);
+  S visitWhileCondition(WhileCondition node);
   S visitExpressionStatement(ExpressionStatement node);
 }
 
+abstract class Visitor<S,E> implements ExpressionVisitor<E>,
+                                       StatementVisitor<S> {
+   E visitExpression(Expression e) => e.accept(this);
+   S visitStatement(Statement s) => s.accept(this);
+}
+
 /**
  * Builder translates from CPS-based IR to direct-style Tree.
  *
  * A call `Invoke(fun, cont, args)`, where cont is a singly-referenced
  * non-exit continuation `Cont(v, body)` is translated into a direct-style call
  * whose value is bound in the continuation body:
  *
  * `LetVal(v, Invoke(fun, args), body)`
  *
  * and the continuation definition is eliminated.  A similar translation is
@@ skipping 207 matching lines @@
             //       inline at the invocation site.
             //     - If there are multiple uses, translate to Break.
             //   * Recursive continuations
             //     - There is a single non-recursive invocation.  Translate
             //       the continuation body inline as a labeled loop at the
             //       invocation site.
             //     - Translate the recursive invocations to Continue.
             if (cont.isRecursive) {
               return node.isRecursive
                   ? new Continue(labels[cont])
-                  : new While(labels[cont], visit(cont.body));
+                  : new WhileTrue(labels[cont], visit(cont.body));
             } else {
               return cont.hasExactlyOneUse
                   ? visit(cont.body)
                   : new Break(labels[cont]);
             }
           });
     }
   }
 
   Statement visitBranch(ir.Branch node) {
@@ skipping 119 matching lines @@
  *   v0 = foo(); return v0;
  *
  * This can lead to propagation of v0.
  *
  * See [visitBreak] and [visitLabeledStatement].
  *
  *
  * REDIRECT BREAKS:
  * Labeled statements whose next is a break become flattened and all breaks
  * to their label are redirected.
- * For example:
+ * For example, where 'jump' is either break or continue:
  *
- *   L0: {... break L0 ...}; break L1
+ *   L0: {... break L0 ...}; jump L1
  *     ==>
- *   {... break L1 ...}
+ *   {... jump L1 ...}
  *
  * This may trigger a flattening of nested ifs in case the eliminated label
  * separated two ifs.
  */
 class StatementRewriter extends Visitor<Statement, Expression> {
   // The binding environment.  The rightmost element of the list is the nearest
   // available enclosing binding.
   List<Assign> environment;
 
   /// Substitution map for labels. Any break to a label L should be substituted
   /// for a break to L' if L maps to L'.
-  Map<Label, Label> labelRedirects = <Label, Label>{};
+  Map<Label, Jump> labelRedirects = <Label, Jump>{};
 
   /// Returns the redirect target of [label] or [label] itself if it should not
   /// be redirected.
-  Label redirect(Label label) {
-    Label newTarget = labelRedirects[label];
-    return newTarget != null ? newTarget : label;
+  Jump redirect(Break jump) {
+    Jump newJump = labelRedirects[jump.target];
+    return newJump != null ? newJump : jump;
   }
 
   void rewrite(FunctionDefinition definition) {
     environment = <Assign>[];
     definition.body = visitStatement(definition.body);
 
     // TODO(kmillikin):  Allow definitions that are not propagated.  Here,
     // this means rebuilding the binding with a recursively unnamed definition,
     // or else introducing a variable definition and an assignment.
     assert(environment.isEmpty);
@@ skipping 99 matching lines @@
   }
 
   Statement visitReturn(Return node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
 
   Statement visitBreak(Break node) {
     // Redirect through chain of breaks.
-    // Note that breakCount was accounted for at visitLabeledStatement.
-    node.target = redirect(node.target);
-    if (node.target.breakCount == 1) {
-      --node.target.breakCount;
+    // Note that useCount was accounted for at visitLabeledStatement.
+    // Note redirect may return either a Break or Continue statement.
+    node = redirect(node);
+    if (node is Break && node.target.useCount == 1) {
+      --node.target.useCount;
       return visitStatement(node.target.binding.next);
     }
     return node;
   }
 
   Statement visitContinue(Continue node) {
     return node;
   }
 
   Statement visitLabeledStatement(LabeledStatement node) {
-    if (node.next is Break) {
-      // Eliminate label if next is just a break statement
+    if (node.next is Jump) {
+      // Eliminate label if next is a break or continue statement
       // Breaks to this label are redirected to the outer label.
       // Note that breakCount for the two labels is updated proactively here
       // so breaks can reliably tell if they should inline their target.
-      Break next = node.next;
-      Label newTarget = redirect(next.target);
-      labelRedirects[node.label] = newTarget;
-      newTarget.breakCount += node.label.breakCount;
-      node.label.breakCount = 0;
+      Jump next = node.next;
+      Jump newJump = redirect(next);
+      labelRedirects[node.label] = newJump;
+      newJump.target.useCount += node.label.useCount - 1;
+      node.label.useCount = 0;
       Statement result = visitStatement(node.body);
       labelRedirects.remove(node.label); // Save some space.
       return result;
     }
 
     node.body = visitStatement(node.body);
 
-    if (node.label.breakCount == 0) {
+    if (node.label.useCount == 0) {
       // Eliminate the label if next was inlined at a break
       return node.body;
     }
 
     node.next = visitStatement(node.next);
     return node;
   }
 
   Statement visitIf(If node) {
     node.condition = visitExpression(node.condition);
@@ skipping 21 matching lines @@
       if (reduced.next is Break) {
         // In case the break can now be inlined.
         reduced = visitStatement(reduced);
       }
       return reduced;
     }
 
     return node;
   }
 
-  Statement visitWhile(While node) {
+  Statement visitWhileTrue(WhileTrue node) {
     // Do not propagate assignments into loops.  Doing so is not safe for
     // variables modified in the loop (the initial value will be propagated).
     List<Assign> savedEnvironment = environment;
     environment = <Assign>[];
     node.body = visitStatement(node.body);
     assert(environment.isEmpty);
     environment = savedEnvironment;
     return node;
   }
 
+  Statement visitWhileCondition(WhileCondition node) {
+    // Not introduced yet
+    throw "Unexpected WhileCondition in StatementRewriter";
+  }
+
   Expression visitConstant(Constant node) {
     return node;
   }
 
   Expression visitLiteralList(LiteralList node) {
     // Process values right-to-left, the opposite of evaluation order.
     for (int i = node.values.length - 1; i >= 0; --i) {
       node.values[i] = visitExpression(node.values[i]);
     }
     return node;
@@ skipping 66 matching lines @@
     return null;
   }
 
   /// Returns a statement equivalent to both [s] and [t], or null if [s] and
   /// [t] are incompatible.
   /// If non-null is returned, the caller MUST discard [s] and [t] and use
   /// the returned statement instead.
   /// If two breaks are combined, the label's break counter will be decremented.
   static Statement combineStatements(Statement s, Statement t) {
     if (s is Break && t is Break && s.target == t.target) {
-      --t.target.breakCount; // Two breaks become one.
+      --t.target.useCount; // Two breaks become one.
+      return s;
+    }
+    if (s is Continue && t is Continue && s.target == t.target) {
+      --t.target.useCount; // Two continues become one.
       return s;
     }
     if (s is Return && t is Return && equivalentExpressions(s.value, t.value)) {
       return s;
     }
     return null;
   }
 
   /// True if the two expressions both syntactically and semantically
   /// equivalent.
@@ skipping 66 matching lines @@
       If innerIf = outerThen;
       Statement innerThen = getBranch(innerIf, branch2);
       Statement innerElse = getBranch(innerIf, !branch2);
       if (innerElse is Break && innerElse.target == outerElse.target) {
         // We always put S in the then branch of the result, and adjust the
         // condition expression if S was actually found in the else branch(es).
         outerIf.condition = new LogicalOperator.and(
             makeCondition(outerIf.condition, branch1),
             makeCondition(innerIf.condition, branch2));
         outerIf.thenStatement = innerThen;
-        --innerElse.target.breakCount;
+        --innerElse.target.useCount;
 
         // Try to inline the remaining break.  Do not propagate assignments.
         List<Assign> savedEnvironment = environment;
         environment = <Assign>[];
         outerIf.elseStatement = visitStatement(outerElse);
         assert(environment.isEmpty);
         environment = savedEnvironment;
 
         return outerIf.elseStatement is If && innerThen is Break;
       }
     }
     return false;
   }
 
   Expression makeCondition(Expression e, bool polarity) {
     return polarity ? e : new Not(e);
   }
 
   Statement getBranch(If node, bool polarity) {
     return polarity ? node.thenStatement : node.elseStatement;
   }
 }
 
+/// Rewrites [WhileTrue] statements with an [If] body into a [WhileCondition],
+/// in situations where only one of the branches contains a [Continue] to the
+/// loop. Schematically:
+///
+///   L:
+///   while (true) {
+///     if (E) {
+///       S1  (has references to L)
+///     } else {
+///       S2  (has no references to L)
+///     }
+///   }
+///     ==>
+///   L:
+///   while (E) {
+///     S1
+///   };
+///   S2
+///
+/// A similar transformation is used when S2 occurs in the 'then' position.
+///
+/// Note that the above pattern needs no iteration since nested ifs
+/// have been collapsed previously in the [StatementRewriter] phase.
+class LoopRewriter extends StatementVisitor<Statement> {
+
+  Set<Label> usedContinueLabels = new Set<Label>();
+
+  void rewrite(FunctionDefinition function) {
+    function.body = visitStatement(function.body);
+  }
+
+  Statement visitLabeledStatement(LabeledStatement node) {
+    node.body = visitStatement(node.body);
+    node.next = visitStatement(node.next);
+    return node;
+  }
+
+  Statement visitAssign(Assign node) {
+    node.next = visitStatement(node.next);
+    return node;
+  }
+
+  Statement visitReturn(Return node) {
+    return node;
+  }
+
+  Statement visitBreak(Break node) {
+    return node;
+  }
+
+  Statement visitContinue(Continue node) {
+    usedContinueLabels.add(node.target);
+    return node;
+  }
+
+  Statement visitIf(If node) {
+    node.thenStatement = visitStatement(node.thenStatement);
+    node.elseStatement = visitStatement(node.elseStatement);
+    return node;
+  }
+
+  Statement visitWhileTrue(WhileTrue node) {
+    assert(!usedContinueLabels.contains(node.label));
+    if (node.body is If) {
+      If body = node.body;
+      body.thenStatement = visitStatement(body.thenStatement);
+      bool thenHasContinue = usedContinueLabels.remove(node.label);
+      body.elseStatement = visitStatement(body.elseStatement);
+      bool elseHasContinue = usedContinueLabels.remove(node.label);
+      if (thenHasContinue && !elseHasContinue) {
+        node.label.binding = null; // Prepare to rebind the label.
+        return new WhileCondition(
+            node.label,
+            body.condition,
+            body.thenStatement,
+            body.elseStatement,
+            node.updates);
+      } else if (!thenHasContinue && elseHasContinue) {
+        node.label.binding = null;
+        return new WhileCondition(
+            node.label,
+            new Not(body.condition),
+            body.elseStatement,
+            body.thenStatement,
+            node.updates);
+      }
+    } else {
+      node.body = visitStatement(node.body);
+      usedContinueLabels.remove(node.label);
+    }
+    return node;
+  }
+
+  Statement visitWhileCondition(WhileCondition node) {
+    // Note: not reachable but the implementation is trivial
+    node.body = visitStatement(node.body);
+    node.next = visitStatement(node.next);
+    return node;
+  }
+
+  Statement visitExpressionStatement(ExpressionStatement node) {
+    node.next = visitStatement(node.next);
+    // for (;;) { ... E; continue* L ... }
+    //   ==>
+    // for(;;E) { ... continue* L ... }
+    if (node.next is Continue) {
+      Continue jump = node.next;
+      if (jump.target.useCount == 1) {
+        Loop target = jump.target.binding;
+        target.updates.add(node.expression);
+        return jump; // Return the continue statement.
+        // NOTE: The pattern may reclick in an enclosing expression statement.
+      }
+    }
+    return node;
+  }
+
+}
 
 
 /// Rewrites logical expressions to be more compact.
 ///
 /// In this class an expression is said to occur in "boolean context" if
 /// its result is immediately applied to boolean conversion.
 ///
 /// IF STATEMENTS:
 ///
 /// We apply the following two rules to [If] statements (see [visitIf]).
@@ skipping 115 matching lines @@
     if (!emptyElse && node.condition is Not) {
       node.condition = (node.condition as Not).operand;
       Statement tmp = node.thenStatement;
       node.thenStatement = node.elseStatement;
       node.elseStatement = tmp;
     }
 
     return node;
   }
 
-  Statement visitWhile(While node) {
+  Statement visitWhileTrue(WhileTrue node) {
     node.body = visitStatement(node.body);
     return node;
   }
 
+  Statement visitWhileCondition(WhileCondition node) {
+    node.condition = makeCondition(node.condition, true, liftNots: false);
+    node.body = visitStatement(node.body);
+    node.next = visitStatement(node.next);
+    return node;
+  }
+
   Statement visitExpressionStatement(ExpressionStatement node) {
     // TODO(asgerf): in non-checked mode we can remove Not from the expression.
     node.expression = visitExpression(node.expression);
     node.next = visitStatement(node.next);
     return node;
   }
 
 
   Expression visitVariable(Variable node) {
     return node;
@@ skipping 250 matching lines @@
     }
   }
 
   /// Destructively updates each entry of [l] with the result of visiting it.
   void _rewriteList(List<Expression> l) {
     for (int i = 0; i < l.length; i++) {
       l[i] = visitExpression(l[i]);
     }
   }
 }