dart2js cps: Compile some loops as 'for' loops.

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.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 tree_ir_nodes;
 
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 428 matching lines @@
   final FunctionDefinition definition;
 
   FunctionExpression(this.definition);
 
   accept(ExpressionVisitor visitor) => visitor.visitFunctionExpression(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitFunctionExpression(this, arg);
   }
 }
 
-/// A [LabeledStatement] or [WhileTrue] or [WhileCondition].
+/// A [LabeledStatement] or [WhileTrue] or [For].
 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 JumpTarget {
   Statement next;
   final Label label;
   Statement body;
 
   LabeledStatement(this.label, this.body, this.next) {
     assert(label.binding == null);
     label.binding = this;
   }
 
   accept(StatementVisitor visitor) => visitor.visitLabeledStatement(this);
   accept1(StatementVisitor1 visitor, arg) {
     return visitor.visitLabeledStatement(this, arg);
   }
 }
 
-/// A [WhileTrue] or [WhileCondition] loop.
+/// A [WhileTrue] or [For] loop.
 abstract class Loop extends JumpTarget {
 }
 
 /**
  * A labeled while(true) loop.
  */
 class WhileTrue extends Loop {
   final Label label;
   Statement body;
 
   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);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitWhileTrue(this, arg);
 }
 
 /**
- * A while loop with a condition. If the condition is false, control resumes
- * at the [next] statement.
+ * A loop with a condition and update expressions. If there are any update
+ * expressions, this generates a for loop, otherwise a while loop.
+ * 
+ * When 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
+ * [For] statements are introduced in the [LoopRewriter] and are
  * assumed not to occur before then.
  */
-class WhileCondition extends Loop {
+class For extends Loop {
   final Label label;
   Expression condition;
+  List<Expression> updates;
   Statement body;
   Statement next;
 
-  WhileCondition(this.label, this.condition, this.body,
-                 this.next) {
+  For(this.label,
+      this.condition,
+      this.updates,
+      this.body,
+      this.next) {
     assert(label.binding == null);
     label.binding = this;
   }
 
-  accept(StatementVisitor visitor) => visitor.visitWhileCondition(this);
+  accept(StatementVisitor visitor) => visitor.visitFor(this);
   accept1(StatementVisitor1 visitor, arg) {
-    return visitor.visitWhileCondition(this, arg);
+    return visitor.visitFor(this, arg);
   }
 }
 
 /// 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);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitBreak(this, arg);
 }
 
 /**
- * A continue to an enclosing [WhileTrue] or [WhileCondition] loop.
+ * A continue to an enclosing [WhileTrue] or [For] 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;
@@ skipping 445 matching lines @@
 abstract class StatementVisitor<S> {
   S visitStatement(Statement node) => node.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitReturn(Return node);
   S visitThrow(Throw node);
   S visitRethrow(Rethrow node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
   S visitWhileTrue(WhileTrue node);
-  S visitWhileCondition(WhileCondition node);
+  S visitFor(For node);
   S visitExpressionStatement(ExpressionStatement node);
   S visitTry(Try node);
   S visitUnreachable(Unreachable node);
   S visitForeignStatement(ForeignStatement node);
 }
 
 abstract class StatementVisitor1<S, A> {
   S visitStatement(Statement node, A arg) => node.accept1(this, arg);
   S visitLabeledStatement(LabeledStatement node, A arg);
   S visitReturn(Return node, A arg);
   S visitThrow(Throw node, A arg);
   S visitRethrow(Rethrow node, A arg);
   S visitBreak(Break node, A arg);
   S visitContinue(Continue node, A arg);
   S visitIf(If node, A arg);
   S visitWhileTrue(WhileTrue node, A arg);
-  S visitWhileCondition(WhileCondition node, A arg);
+  S visitFor(For node, A arg);
   S visitExpressionStatement(ExpressionStatement node, A arg);
   S visitTry(Try node, A arg);
   S visitUnreachable(Unreachable node, A arg);
   S visitForeignStatement(ForeignStatement node, A arg);
 }
 
 abstract class RecursiveVisitor implements StatementVisitor, ExpressionVisitor {
   visitExpression(Expression e) => e.accept(this);
   visitStatement(Statement s) => s.accept(this);
 
@@ skipping 89 matching lines @@
   visitIf(If node) {
     visitExpression(node.condition);
     visitStatement(node.thenStatement);
     visitStatement(node.elseStatement);
   }
 
   visitWhileTrue(WhileTrue node) {
     visitStatement(node.body);
   }
 
-  visitWhileCondition(WhileCondition node) {
+  visitFor(For node) {
     visitExpression(node.condition);
+    node.updates.forEach(visitExpression);
     visitStatement(node.body);
     visitStatement(node.next);
   }
 
   visitExpressionStatement(ExpressionStatement inputNode) {
     // Iterate over chains of expression statements to avoid deep recursion.
     Statement node = inputNode;
     while (node is ExpressionStatement) {
       ExpressionStatement stmt = node;
       visitExpression(stmt.expression);
@@ skipping 209 matching lines @@
     node.thenStatement = visitStatement(node.thenStatement);
     node.elseStatement = visitStatement(node.elseStatement);
     return node;
   }
 
   visitWhileTrue(WhileTrue node) {
     node.body = visitStatement(node.body);
     return node;
   }
 
-  visitWhileCondition(WhileCondition node) {
+  visitFor(For node) {
     node.condition = visitExpression(node.condition);
+    _replaceExpressions(node.updates);
     node.body = visitStatement(node.body);
     node.next = visitStatement(node.next);
     return node;
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     // Iterate over chains of expression statements to avoid deep recursion.
     Statement first = node;
     while (true) {
       node.expression = visitExpression(node.expression);
@@ skipping 140 matching lines @@
 
   /// Number of uses of the current fallthrough target.
   int get useCount => _stack.last.useCount;
 
   /// Indicate that a statement will fall through to the current fallthrough
   /// target.
   void use() {
     ++_stack.last.useCount;
   }
 }