Implement jump targets in for-in.

lib/kernel_visitor.dart

 // Copyright (c) 2016, 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.md file.
 
 library rasta.kernel_visitor;
 
 import 'package:kernel/ast.dart' as ir;
 
 import 'package:kernel/accessors.dart' show
     Accessor,
@@ skipping 240 matching lines @@
     throw new Unsupported("Not implemented yet.");
   }
 
   @override
   ir.AssertStatement visitAssert(Assert node) {
     return new ir.AssertStatement(
         node.condition.accept(this),
         node.message?.accept(this));
   }
 
-  ir.ForInStatement buildForIn(ForIn node, {bool isAsync}) {
-    return new ir.ForInStatement(
-        buildStatementInBlock(node.declaredIdentifier),
-        node.expression.accept(this),
-        buildStatementInBlock(node.body),
-        isAsync: isAsync);
+  ir.LabeledStatement getBreakTarget(JumpTarget target) {
+    return breakTargets.putIfAbsent(
+        target, () => new ir.LabeledStatement(null));
   }
 
-  @override
-  ir.ForInStatement visitAsyncForIn(AsyncForIn node) {
-    return buildForIn(node, isAsync: true);
+  ir.LabeledStatement getContinueTarget(JumpTarget target) {
+    return continueTargets.putIfAbsent(
+        target, () => new ir.LabeledStatement(null));
   }
 
-  @override
-  ir.Throw visitAwait(Await node) {
-    return buildUnsupported(node, "Await");
+  ir.SwitchCase getContinueSwitchTarget(JumpTarget target) {
+    return continueSwitchTargets[target];
   }
 
   ir.Statement buildBreakTarget(
       ir.Statement statement,
       Node node,
       JumpTarget jumpTarget) {
     assert(jumpTarget == elements.getTargetDefinition(node));
     if (jumpTarget != null && jumpTarget.isBreakTarget) {
       ir.LabeledStatement breakTarget = getBreakTarget(jumpTarget);
       breakTarget.body = statement;
       statement.parent = breakTarget;
       return breakTarget;
     } else {
       return statement;
     }
   }
 
+  ir.Statement buildContinueTarget(

[kasperl, 2016/05/19 14:13:30]

This helper makes a big difference for the readability of the users of it.

[ahe, 2016/05/19 18:41:46]

Acknowledged.

+      ir.Statement statement,
+      Node node,
+      JumpTarget jumpTarget) {
+    assert(jumpTarget == elements.getTargetDefinition(node));
+    if (jumpTarget != null && jumpTarget.isContinueTarget) {
+      ir.LabeledStatement continueTarget = getContinueTarget(jumpTarget);
+      continueTarget.body = statement;
+      statement.parent = continueTarget;
+      return continueTarget;
+    } else {
+      return statement;
+    }
+  }
+
+ ir.Statement buildForIn(ForIn node, {bool isAsync}) {
+    ir.VariableDeclaration variable =
+        buildStatementInBlock(node.declaredIdentifier);
+    ir.Expression iterable = node.expression.accept(this);
+    JumpTarget jumpTarget = elements.getTargetDefinition(node);
+    ir.Statement body = buildContinueTarget(
+        buildStatementInBlock(node.body), node, jumpTarget);
+    return buildBreakTarget(
+        new ir.ForInStatement(variable, iterable, body, isAsync: isAsync),
+        node, jumpTarget);
+  }
+
+  @override
+  ir.Statement visitAsyncForIn(AsyncForIn node) {
+    return buildForIn(node, isAsync: true);
+  }
+
+  @override
+  ir.Throw visitAwait(Await node) {
+    return buildUnsupported(node, "Await");
+  }
+
   @override
   ir.Statement visitBlock(Block node) {
     return buildBreakTarget(
         buildStatementInBlock(node), node, elements.getTargetDefinition(node));
   }
 
   void buildStatement(Statement statement, List<ir.Statement> statements) {
     ir.Node irNode = statement.accept(this);
     if (irNode is VariableDeclarations) {
       statements.addAll(irNode.variables);
@@ skipping 120 matching lines @@
 
   @override
   ir.ConditionalExpression visitConditional(Conditional node) {
     return new ir.ConditionalExpression(
         node.condition.accept(this),
         node.thenExpression.accept(this),
         node.elseExpression.accept(this));
   }
 
   @override
-  ir.BreakStatement visitContinueStatement(ContinueStatement node) {
+  ir.Statement visitContinueStatement(ContinueStatement node) {
     JumpTarget target = elements.getTargetOf(node);
     ir.SwitchCase switchCase = getContinueSwitchTarget(target);
     if (switchCase == null) {
       return new ir.BreakStatement(getContinueTarget(target));
     } else {
       return new ir.ContinueSwitchStatement(switchCase);
     }
   }
 
   @override
   ir.Statement visitDoWhile(DoWhile node) {
-    ir.Statement body = buildStatementInBlock(node.body);
+    JumpTarget jumpTarget = elements.getTargetDefinition(node);
+    ir.Statement body = buildContinueTarget(
+        buildStatementInBlock(node.body), node, jumpTarget);
     ir.Expression condition = node.condition?.accept(this);
-
-    // TODO(ahe): Unify jump target handling between For, While, and Do.
-    JumpTarget jumpTarget = elements.getTargetDefinition(node);
-
-    if (jumpTarget != null && jumpTarget.isContinueTarget) {
-      ir.LabeledStatement continueTarget = getContinueTarget(jumpTarget);
-      continueTarget.body = body;
-      body.parent = continueTarget;
-      body = continueTarget;
-    }
-
     return buildBreakTarget(
         new ir.DoStatement(body, condition), node, jumpTarget);
   }
 
   @override
   ir.EmptyStatement visitEmptyStatement(EmptyStatement node) {
     return new ir.EmptyStatement();
   }
 
   @override
   ir.Throw visitEnum(Enum node) {
     return buildUnsupported(node, "Enum");
   }
 
   @override
   ir.ExpressionStatement visitExpressionStatement(ExpressionStatement node) {
     return new ir.ExpressionStatement(node.expression.accept(this));
   }
 
-  ir.LabeledStatement getBreakTarget(JumpTarget target) {
-    return breakTargets.putIfAbsent(
-        target, () => new ir.LabeledStatement(null));
-  }
-
-  ir.LabeledStatement getContinueTarget(JumpTarget target) {
-    return continueTargets.putIfAbsent(
-        target, () => new ir.LabeledStatement(null));
-  }
-
-  ir.SwitchCase getContinueSwitchTarget(JumpTarget target) {
-    return continueSwitchTargets[target];
-  }
-
   @override
   ir.Statement visitFor(For node) {
     VariableDefinitions initializers =
         node.initializer?.asVariableDefinitions();
     ir.Expression initializer;
     List<ir.VariableDeclaration> variables;
     if (initializers != null) {
       ir.Block block = buildStatementInBlock(initializers, forceBlock: true);
       variables = new List<ir.VariableDeclaration>.from(block.statements);
     } else {
       if (node.initializer != null) {
         initializer = node.initializer.accept(this);
       }
       variables = const <ir.VariableDeclaration>[];
     }
     ir.Expression condition = node.condition?.accept(this);
     List<ir.Expression> updates = <ir.Expression>[];
     for (Expression update in node.update) {
       updates.add(update.accept(this));
     }
-    ir.Statement body = buildStatementInBlock(node.body);
+
     JumpTarget jumpTarget = elements.getTargetDefinition(node);
-
-    if (jumpTarget != null && jumpTarget.isContinueTarget) {
-      ir.LabeledStatement continueTarget = getContinueTarget(jumpTarget);
-      continueTarget.body = body;
-      body.parent = continueTarget;
-      body = continueTarget;
-    }
+    ir.Statement body = buildContinueTarget(
+        buildStatementInBlock(node.body), node, jumpTarget);
     ir.ForStatement forStatement = new ir.ForStatement(
         variables, condition, updates, body);
     ir.Statement result = buildBreakTarget(forStatement, node, jumpTarget);
     if (initializer != null) {
       result = new ir.Block(<ir.Statement>[
           new ir.ExpressionStatement(initializer), result]);
     }
     return result;
   }
 
@@ skipping 210 matching lines @@
       irCase.body = body;
       body.parent = irCase;
     }
 
     return  buildBreakTarget(
         new ir.SwitchStatement(expression, cases),
         node, elements.getTargetDefinition(node));
   }
 
   @override
-  ir.ForInStatement visitSyncForIn(SyncForIn node) {
+  ir.Statement visitSyncForIn(SyncForIn node) {
     return buildForIn(node, isAsync: false);
   }
 
   @override
   ir.Throw visitThrow(Throw node) {
     return new ir.Throw(node?.expression?.accept(this));
   }
 
   @override
   ir.Statement visitTryStatement(TryStatement node) {
@@ skipping 18 matching lines @@
   }
 
   @override
   ir.Throw visitTypeVariable(TypeVariable node) {
     return buildUnsupported(node, "TypeVariable");
   }
 
   @override
   ir.Statement visitWhile(While node) {
     ir.Expression condition = node.condition?.accept(this);
-
-    ir.Statement body = buildStatementInBlock(node.body);
     JumpTarget jumpTarget = elements.getTargetDefinition(node);
-
-    if (jumpTarget != null && jumpTarget.isContinueTarget) {
-      ir.LabeledStatement continueTarget = getContinueTarget(jumpTarget);
-      continueTarget.body = body;
-      body.parent = continueTarget;
-      body = continueTarget;
-    }
-
+    ir.Statement body = buildContinueTarget(
+        buildStatementInBlock(node.body), node, jumpTarget);
     return buildBreakTarget(
         new ir.WhileStatement(condition, body), node, jumpTarget);
   }
 
   @override
   ir.YieldStatement visitYield(Yield node) {
     return new ir.YieldStatement(
         node.expression.accept(this), isYieldStar: node.hasStar);
   }
 
@@ skipping 1757 matching lines @@
   GenerativeConstructorFunction(this.function, this.initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "GenerativeConstructorFunction($function, $initializers)";
   }
 }