Hack around aborting loop body.

dart/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 1071 matching lines @@
         close(new HLoopBranch(conditionInstruction));
 
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
 
     // The body.
     HBasicBlock bodyBlock = addNewBlock();
     conditionExitBlock.addSuccessor(bodyBlock);
     open(bodyBlock);
 
     localsHandler.enterLoopBody(loop);
-    visit(body);
-    if (isAborted()) {
-      compiler.unimplemented("SsaBuilder for loop with aborting body",
-                             node: body);
-    }
+    hackAroundPossiblyAbortingBody(body);
     bodyBlock = close(new HGoto());
 
     // Update.
     // We create an update block, even when we are in a while loop. There the
     // update block is the jump-target for continue statements. We could avoid
     // the creation if there is no continue, but for now we always create it.
     HBasicBlock updateBlock = addNewBlock();
     bodyBlock.addSuccessor(updateBlock);
     open(updateBlock);
 
@@ skipping 24 matching lines @@
   visitWhile(While node) {
     visitLoop(node, null, node.condition, null, node.body);
   }
 
   visitDoWhile(DoWhile node) {
     localsHandler.startLoop(node);
     BreakHandler breakHandler = beginLoopHeader(node);
     HBasicBlock loopEntryBlock = current;
 
     localsHandler.enterLoopBody(node);
-    visit(node.body);
-    if (isAborted()) {
-      compiler.unimplemented("SsaBuilder for loop with aborting body");
-    }
+    hackAroundPossiblyAbortingBody(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();
     bodyExitBlock.addSuccessor(conditionBlock);
     open(conditionBlock);
     visit(node.condition);
     assert(!isAborted());
     conditionBlock = close(new HLoopBranch(popBoolified(),
@@ skipping 1039 matching lines @@
     Element variable;
     if (node.declaredIdentifier.asSend() !== null) {
       variable = elements[node.declaredIdentifier];
     } else {
       assert(node.declaredIdentifier.asVariableDefinitions() !== null);
       VariableDefinitions variableDefinitions = node.declaredIdentifier;
       variable = elements[variableDefinitions.definitions.nodes.head];
     }
     localsHandler.updateLocal(variable, pop());
 
-    visit(node.body);
-    if (isAborted()) {
-      compiler.unimplemented("SsaBuilder for loop with aborting body",
-                             node: node);
-    }
+    hackAroundPossiblyAbortingBody(node.body);
     bodyBlock = close(new HGoto());
 
     // Update.
     // We create an update block, even if we are in a for-in loop. The
     // update block is the jump-target for continue statements. We could avoid
     // the creation if there is no continue, but for now we always create it.
     HBasicBlock updateBlock = addNewBlock();
     bodyBlock.addSuccessor(updateBlock);
     open(updateBlock);
     updateBlock = close(new HGoto());
@@ skipping 23 matching lines @@
       visit(body);
       return;
     }
     LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler);
     assert(targetElement.isBreakTarget);
     BreakHandler handler = new BreakHandler(this, targetElement);
     // Introduce a new basic block.
     HBasicBlock entryBlock = graph.addNewBlock();
     goto(current, entryBlock);
     open(entryBlock);
-    visit(body);
+    hackAroundPossiblyAbortingBody(body);
     SubGraph bodyGraph = new SubGraph(entryBlock, lastOpenedBlock);
-    if (isAborted()) {
-      compiler.unimplemented(
-          "SsaBuilder for labeled statement with aborting body", node: node);
-    }
 
     HBasicBlock joinBlock = graph.addNewBlock();
     List<LocalsHandler> breakLocals = <LocalsHandler>[];
     handler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(joinBlock);
       breakLocals.add(locals);
     });
     bool hasBreak = breakLocals.length > 0;
     if (!isAborted()) {
       goto(current, joinBlock);
@@ skipping 217 matching lines @@
 
     // Normally, we would call [close] here. However, then we hit
     // another unimplemented feature: aborting loop body. Simply
     // calling [add] does not work as it asserts that the instruction
     // isn't a control flow instruction. So we inline parts of [add].
     current.addAfter(current.last, new HThrow(message));
     if (isExpression) {
       stack.add(graph.addConstantNull());
     }
   }
+
+  /** HACK HACK HACK */
+  void hackAroundPossiblyAbortingBody(Node body) {
+    stack.add(graph.addConstantBool(true));
+    buildBody() {
+      // TODO(lrn): Make sure to take continue into account.
+      visit(body);
+      if (isAborted()) {
+        compiler.reportWarning(body, "aborting loop body");
+      }
+    }
+    handleIf(buildBody, null);
+  }
 }