Make continue work in do-while.

frog/leg/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1072 matching lines @@
     List<LocalsHandler> breakLocals = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(loopExitBlock);
       breakLocals.add(locals);
     });
     branchBlock.addSuccessor(loopExitBlock);
     open(loopExitBlock);
     localsHandler.endLoop(loopEntry);
     if (!breakLocals.isEmpty()) {
       breakLocals.add(savedLocals);
-      localsHandler = localsHandler.mergeMultiple(breakLocals, loopExitBlock);
+      localsHandler = savedLocals.mergeMultiple(breakLocals, loopExitBlock);
     } else {
       localsHandler = savedLocals;
     }
   }
 
   // For while loops, initializer and update are null.
   // The condition function must return a boolean result.
   // None of the functions must leave anything on the stack.
   handleLoop(Node loop,
              void initialize(),
@@ skipping 113 matching lines @@
       return popBoolified();
     }
     handleLoop(node,
                () {},
                buildCondition,
                () {},
                () { visit(node.body); });
   }
 
   visitDoWhile(DoWhile node) {
+    LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     localsHandler.startLoop(node);
     JumpHandler jumpHandler = beginLoopHeader(node);
     HBasicBlock loopEntryBlock = current;
-
+    HBasicBlock bodyEntryBlock = current;
+    TargetElement target = elements[node];
+    bool hasContinues = target !== null && target.isContinueTarget;
+    if (hasContinues) {
+      // Add extra block to hang labels on.
+      // It doesn't currently work if they are on the same block as the
+      // HLoopInfo. The handling of HLabeledBlockInformation will visit a
+      // SubGraph that starts at the same block again, so the HLoopInfo is
+      // either handled twice, or it's handled after the labeled block info,
+      // both of which generate the wrong code.
+      // Using a separate block is just a simple workaround.
+      bodyEntryBlock = graph.addNewBlock();
+      goto(current, bodyEntryBlock);
+      open(bodyEntryBlock);
+    }
     localsHandler.enterLoopBody(node);
     hackAroundPossiblyAbortingBody(node, () { visit(node.body); });
 
     // If there are no continues we could avoid the creation of the condition
     // block. This could also lead to a block having multiple entries and exits.
     HBasicBlock bodyExitBlock = close(new HGoto());
     HBasicBlock conditionBlock = addNewBlock();
+
+    List<LocalsHandler> continueLocals = <LocalsHandler>[];
+    jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
+      instruction.block.addSuccessor(conditionBlock);
+      continueLocals.add(locals);
+    });
     bodyExitBlock.addSuccessor(conditionBlock);
-    jumpHandler.forEachContinue((x,y) {
-      // TODO(lrn): Handle continue in do-while loops.
-      compiler.cancel("do-while with continue", node: node);
-    });
+    if (!continueLocals.isEmpty()) {
+      continueLocals.add(localsHandler);
+      localsHandler = savedLocals.mergeMultiple(continueLocals, conditionBlock);
+      SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
+      List<LabelElement> labels = jumpHandler.labels();
+      if (!labels.isEmpty()) {
+        bodyEntryBlock.labeledBlockInformation =
+            new HLabeledBlockInformation(bodyGraph,
+                                         conditionBlock,
+                                         labels,
+                                         isContinue: true);
+      } else {
+        bodyEntryBlock.labeledBlockInformation =
+            new HLabeledBlockInformation.implicit(bodyGraph,
+                                                  conditionBlock,
+                                                  target,
+                                                  isContinue: true);
+      }
+    }
     open(conditionBlock);
+
     visit(node.condition);
     assert(!isAborted());
     conditionBlock = close(new HLoopBranch(popBoolified(),
                                            HLoopBranch.DO_WHILE_LOOP));
 
     conditionBlock.addSuccessor(loopEntryBlock);  // The back-edge.
     loopEntryBlock.postProcessLoopHeader();
 
     endLoop(loopEntryBlock, conditionBlock, jumpHandler, localsHandler);
     jumpHandler.close();
@@ skipping 1550 matching lines @@
     HInstruction concat = new HAdd(target, left, right);
     builder.add(concat);
     return concat;
   }
 
   HInstruction result() {
     flushAccumulator();
     return prefix;
   }
 }