Continue for simple loops (while/for).

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 588 matching lines @@
     if (thisValue !== null) {
       // If there was a "this" for the scope, add it to the new locals.
       joinedLocals[closureData.thisElement] = thisValue;
     }
     directLocals = joinedLocals;
     return this;
   }
 }
 
 
-// Represents a single break instruction.
-class BreakHandlerEntry {
-  final HBreak breakInstruction;
+// Represents a single break/continue instruction.
+class JumpHandlerEntry {
+  final HGoto jumpInstruction;
   final LocalsHandler locals;
-  BreakHandlerEntry(this.breakInstruction, this.locals);
+  bool isBreak() => jumpInstruction is HBreak;
+  bool isContinue() => jumpInstruction is HContinue;
+  JumpHandlerEntry(this.jumpInstruction, this.locals);
 }
 
-interface BreakHandler default BreakHandlerImpl {
-  BreakHandler(SsaBuilder builder, TargetElement target);
-  void addBreak(HBreak breakInstruction, LocalsHandler locals);
-  void forEachBreak(Function action);
+
+interface JumpHandler default JumpHandlerImpl {
+  JumpHandler(SsaBuilder builder, TargetElement target);
+  void generateBreak([LabelElement label]);
+  void generateContinue([LabelElement label]);
+  void forEachBreak(void action(HBreak instruction, LocalsHandler locals));
+  void forEachContinue(void action(HBreak instruction, LocalsHandler locals));
   void close();
   List<LabelElement> labels();
 }
 
-// Inert break handler used to avoid null checks when a loop isn't
+// Insert break handler used to avoid null checks when a target isn't
 // used as the target of a break, and therefore doesn't need a break
 // handler associated with it.
-class NullBreakHandler implements BreakHandler {
-  const NullBreakHandler();
-  void addBreak(HBreak breakInstruction, LocalsHandler locals) {
-    unreachable();
-  }
+class NullJumpHandler implements JumpHandler {
+  const NullJumpHandler();
+  void generateBreak([LabelElement label]) { unreachable(); }
+  void generateContinue([LabelElement label]) { unreachable(); }
   void forEachBreak(Function ignored) { }
+  void forEachContinue(Function ignored) { }
   void close() { }
   List<LabelElement> labels() => const <LabelElement>[];
 }
 
 // Records breaks until a target block is available.
 // Breaks are always forward jumps.
-class BreakHandlerImpl implements BreakHandler {
-  final BreakHandler previous;
+// Continues in loops are implemented as breaks of the body.
+// Continues in switches is currently not handled.
+class JumpHandlerImpl implements JumpHandler {
   final SsaBuilder builder;
   final TargetElement target;
-  final List<BreakHandlerEntry> breaks;
-  BreakHandlerImpl(SsaBuilder builder, this.target)
+  final List<JumpHandlerEntry> jumps;
+
+  JumpHandlerImpl(SsaBuilder builder, this.target)
       : this.builder = builder,
-        previous = builder.currentBreakHandler,
-        breaks = <BreakHandlerEntry>[] {
-    builder.currentBreakHandler = this;
-    assert(builder.breakTargets[target] === null);
-    builder.breakTargets[target] = this;
+        jumps = <JumpHandlerEntry>[] {
+    assert(builder.jumpTargets[target] === null);
+    builder.jumpTargets[target] = this;
   }
 
-  void addBreak(HBreak breakInstruction, LocalsHandler locals) {
-    breaks.add(new BreakHandlerEntry(breakInstruction, locals));
+  void generateBreak([LabelElement label]) {
+    HInstruction breakInstruction;
+    if (label === null) {
+      breakInstruction = new HBreak(target);
+    } else {
+      breakInstruction = new HBreak.toLabel(label);
+    }
+    LocalsHandler locals = new LocalsHandler.from(builder.localsHandler);
+    builder.close(breakInstruction);
+    jumps.add(new JumpHandlerEntry(breakInstruction, locals));
+  }
+
+  void generateContinue([LabelElement label]) {
+    HInstruction continueInstruction;
+    if (label === null) {
+      continueInstruction = new HContinue(target);
+    } else {
+      continueInstruction = new HContinue.toLabel(label);
+    }
+    LocalsHandler locals = new LocalsHandler.from(builder.localsHandler);
+    builder.close(continueInstruction);
+    jumps.add(new JumpHandlerEntry(continueInstruction, locals));
   }
 
   void forEachBreak(Function action) {
-    for (BreakHandlerEntry entry in breaks) {
-      action(entry.breakInstruction, entry.locals);
+    for (JumpHandlerEntry entry in jumps) {
+      if (entry.isBreak()) action(entry.jumpInstruction, entry.locals);
+    }
+  }
+
+  void forEachContinue(Function action) {
+    for (JumpHandlerEntry entry in jumps) {
+      if (entry.isContinue()) action(entry.jumpInstruction, entry.locals);
     }
   }
 
   void close() {
-    assert(builder.currentBreakHandler === this);
-    // The mapping from TargetElement to BreakHandler is no longer needed.
-    builder.breakTargets.remove(target);
-    builder.currentBreakHandler = previous;
+    // The mapping from TargetElement to JumpHandler is no longer needed.
+    builder.jumpTargets.remove(target);
   }
 
   List<LabelElement> labels() {
     List<LabelElement> result = null;
     for (LabelElement element in target.labels) {
-      if (element.isBreakTarget) {
-        if (result === null) result = <LabelElement>[];
-        result.add(element);
-      }
+      if (result === null) result = <LabelElement>[];
+      result.add(element);
     }
     return (result === null) ? const <LabelElement>[] : result;
   }
 }
 
 class SsaBuilder implements Visitor {
   final Compiler compiler;
   TreeElements elements;
   final Interceptors interceptors;
   final WorkItem work;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
   HInstruction rethrowableException;
 
-  Map<TargetElement, BreakHandler> breakTargets;
+  Map<TargetElement, JumpHandler> jumpTargets;
 
   // We build the Ssa graph by simulating a stack machine.
   List<HInstruction> stack;
 
   // The current block to add instructions to. Might be null, if we are
   // visiting dead code.
   HBasicBlock current;
   // The most recently opened block. Has the same value as [current] while
   // the block is open, but unlike [current], it isn't cleared when the current
   // block is closed.
   HBasicBlock lastOpenedBlock;
 
-  // Linked list of active break-handlers. Will be removed in the order
-  // they are added.
-  BreakHandler currentBreakHandler = const NullBreakHandler();
-
   LibraryElement get currentLibrary() => work.element.getLibrary();
 
   SsaBuilder(Compiler compiler, WorkItem work)
     : this.compiler = compiler,
       this.work = work,
       interceptors = compiler.builder.interceptors,
       methodInterceptionEnabled = true,
       elements = work.resolutionTree,
       graph = new HGraph(),
       stack = new List<HInstruction>(),
-      breakTargets = new Map<TargetElement, BreakHandler>() {
+      jumpTargets = new Map<TargetElement, JumpHandler>() {
     localsHandler = new LocalsHandler(this);
   }
 
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
     methodInterceptionEnabled = false;
   }
 
   void enableMethodInterception() {
     assert(!methodInterceptionEnabled);
@@ skipping 138 matching lines @@
     FunctionParameters parameters = functionElement.computeParameters(compiler);
     parameters.forEachParameter((Element element) {
       if (element.kind == ElementKind.FIELD_PARAMETER) {
         // If the [element] is a field-parameter (such as [:this.x:] then
         // initialize the field element with its value.
         FieldParameterElement fieldParameterElement = element;
         HInstruction parameterValue = localsHandler.readLocal(element);
         fieldValues[fieldParameterElement.fieldElement] = parameterValue;
       }
     });
-    
+
     final Map<FunctionElement, TreeElements> constructorElements =
         compiler.resolver.constructorElements;
     List<FunctionElement> constructors = new List<FunctionElement>();
 
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
     inlineInitializers(functionElement, constructors, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     // TODO(floitsch,karlklose): move this code to ClassElement and share with
@@ skipping 133 matching lines @@
   visitExpressionStatement(ExpressionStatement node) {
     visit(node.expression);
     pop();
   }
 
   /**
    * Creates a new loop-header block. The previous [current] block
    * is closed with an [HGoto] and replaced by the newly created block.
    * Also notifies the locals handler that we're entering a loop.
    */
-  BreakHandler beginLoopHeader(Node node) {
+  JumpHandler beginLoopHeader(Node node) {
     assert(!isAborted());
     HBasicBlock previousBlock = close(new HGoto());
-    BreakHandler breakHandler = getBreakHandler(node);
-    HBasicBlock loopEntry = graph.addNewLoopHeaderBlock(breakHandler.labels());
+
+    JumpHandler jumpHandler = createJumpHandler(node);
+    HBasicBlock loopEntry = graph.addNewLoopHeaderBlock(jumpHandler.labels());
     previousBlock.addSuccessor(loopEntry);
     open(loopEntry);
 
     localsHandler.beginLoopHeader(node, loopEntry);
-    return breakHandler;
+    return jumpHandler;
   }
 
   /**
    * Ends the loop:
    * - creates a new block and adds it as successor to the [branchBlock].
    * - opens the new block (setting as [current]).
    * - notifies the locals handler that we're exiting a loop.
    */
   void endLoop(HBasicBlock loopEntry,
                HBasicBlock branchBlock,
-               BreakHandler breakHandler,
+               JumpHandler jumpHandler,
                LocalsHandler savedLocals) {
     HBasicBlock loopExitBlock = addNewBlock();
     assert(branchBlock.successors.length == 1);
     List<LocalsHandler> breakLocals = <LocalsHandler>[];
-    breakHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
+    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);
     } else {
       localsHandler = savedLocals;
     }
   }
 
   // For while loops, initializer and update are null.
-  visitLoop(Node loop, Node initializer, Expression condition, NodeList updates,
+  visitLoop(Node loop,
+            Node initializer,
+            Expression condition,
+            NodeList updates,
             Node body) {
     // Generate:
     //  <initializer>
     //  loop-entry:
     //    if (!<condition>) goto loop-exit;
     //    <body>
     //    <updates>
     //    goto loop-entry;
     //  loop-exit:
     if (body === null) {
       compiler.unimplemented(
           'SsaBuilder.visitLoop with empty body',
           node: loop);
     }
 
     localsHandler.startLoop(loop);
 
     // The initializer.
     if (initializer !== null) {
       visit(initializer);
       // We don't care about the value of the initialization.
       if (initializer.asExpression() !== null) pop();
     }
     assert(!isAborted());
 
-    BreakHandler breakHandler = beginLoopHeader(loop);
+    JumpHandler jumpHandler = beginLoopHeader(loop);
     HBasicBlock conditionBlock = current;
 
     HInstruction conditionInstruction;
     if (condition != null) {
       visit(condition);
       conditionInstruction = popBoolified();
     } else {
       // TODO(ngeoffray): Once our loop recognition does not require a
       // HLoopBranch, we could just generate a HGoto.
       conditionInstruction = graph.addConstantBool(true);
     }
     HBasicBlock conditionExitBlock =
         close(new HLoopBranch(conditionInstruction));
 
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
 
     // The body.
-    HBasicBlock bodyBlock = addNewBlock();
-    conditionExitBlock.addSuccessor(bodyBlock);
-    open(bodyBlock);
+    HBasicBlock beginBodyBlock = addNewBlock();
+    conditionExitBlock.addSuccessor(beginBodyBlock);
+    open(beginBodyBlock);
 
     localsHandler.enterLoopBody(loop);
+
     hackAroundPossiblyAbortingBody(body);
-    bodyBlock = close(new HGoto());
+    SubGraph bodyGraph = new SubGraph(beginBodyBlock, current);
+    HBasicBlock 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();
+
+    List<LocalsHandler> continueLocals = <LocalsHandler>[];
+    jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
+      instruction.block.addSuccessor(updateBlock);
+      continueLocals.add(locals);
+    });
     bodyBlock.addSuccessor(updateBlock);
+    continueLocals.add(localsHandler);
+
     open(updateBlock);
 
+    localsHandler = localsHandler.mergeMultiple(continueLocals, updateBlock);
+
+    HLabeledBlockInformation labelInfo;
+    List<LabelElement> labels = jumpHandler.labels();
+    if (!labels.isEmpty()) {
+      beginBodyBlock.labeledBlockInformation =
+          new HLabeledBlockInformation(bodyGraph, updateBlock,
+                                       jumpHandler.labels(), isContinue: true);
+    }
+
     localsHandler.enterLoopUpdates(loop);
+
     if (updates !== null) {
       for (Expression expression in updates) {
         visit(expression);
         assert(!isAborted());
         // The result of the update instruction isn't used, and can just
         // be dropped.
         HInstruction updateInstruction = pop();
       }
     }
     updateBlock = close(new HGoto());
     // The back-edge completing the cycle.
     updateBlock.addSuccessor(conditionBlock);
     conditionBlock.postProcessLoopHeader();
 
-    endLoop(conditionBlock, conditionExitBlock, breakHandler, savedLocals);
+    endLoop(conditionBlock, conditionExitBlock, jumpHandler, savedLocals);
   }
 
   visitFor(For node) {
     assert(node.body !== null);
     visitLoop(node, node.initializer, node.condition, node.update, node.body);
   }
 
   visitWhile(While node) {
     visitLoop(node, null, node.condition, null, node.body);
   }
 
   visitDoWhile(DoWhile node) {
     localsHandler.startLoop(node);
-    BreakHandler breakHandler = beginLoopHeader(node);
+    JumpHandler jumpHandler = beginLoopHeader(node);
     HBasicBlock loopEntryBlock = current;
 
     localsHandler.enterLoopBody(node);
     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);
+    jumpHandler.forEachContinue((x,y) {
+      // TODO(lrn): Handle continue in do-while loops.
+      compiler.cancel("do-while with continue", node: node);
+    });
     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, breakHandler, localsHandler);
+    endLoop(loopEntryBlock, conditionBlock, jumpHandler, localsHandler);
+    jumpHandler.close();
   }
 
   visitFunctionExpression(FunctionExpression node) {
     ClosureData nestedClosureData = closureDataCache[node];
     assert(nestedClosureData !== null);
     assert(nestedClosureData.closureClassElement !== null);
     ClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     FunctionElement callElement = nestedClosureData.callElement;
     compiler.enqueue(new WorkItem.toCodegen(callElement, elements));
@@ skipping 984 matching lines @@
 
   visitModifiers(Modifiers node) {
     compiler.unimplemented('SsaBuilder.visitModifiers', node: node);
   }
 
   visitBreakStatement(BreakStatement node) {
     work.allowSpeculativeOptimization = false;
     assert(!isAborted());
     TargetElement target = elements[node];
     assert(target !== null);
-    BreakHandler handler = breakTargets[target];
+    JumpHandler handler = jumpTargets[target];
     assert(handler !== null);
-    LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
-    HBreak breakInstruction;
     if (node.target === null) {
-      breakInstruction = new HBreak(target);
+      handler.generateBreak();
     } else {
       LabelElement label = elements[node.target];
-      breakInstruction = new HBreak.toLabel(label);
+      handler.generateBreak(label);
     }
-    close(breakInstruction);
-    handler.addBreak(breakInstruction, savedLocals);
   }
 
   visitContinueStatement(ContinueStatement node) {
-    // TODO(lrn): Replace this with a real implementation of continue.
-    compiler.reportWarning(node, 'continue not implemented');
-    generateUnimplemented('continue not implemented');
+    work.allowSpeculativeOptimization = false;
+    TargetElement target = elements[node];
+    assert(target !== null);
+    JumpHandler handler = jumpTargets[target];
+    assert(handler !== null);
+    if (node.target === null) {
+      handler.generateContinue();
+    } else {
+      LabelElement label = elements[node.target];
+      handler.generateContinue(label);
+    }
   }
 
-  BreakHandler getBreakHandler(Node node) {
+  /**
+   * Creates a [JumpHandler] for a statement. The node must be a jump
+   * target. If there are no breaks or continues targeting the statement,
+   * a special "null handler" is returned.
+   */
+  JumpHandler createJumpHandler(Statement node) {
     TargetElement element = elements[node];
-    if (element === null) return const NullBreakHandler();
-    return new BreakHandler(this, element);
+    if (element === null || element.statement !== node) {
+      // No breaks or continues to this node.
+      return const NullJumpHandler();
+    }
+    return new JumpHandler(this, element);
   }
 
   visitForInStatement(ForInStatement node) {
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator()
     //   while ($iter.hasNext()) {
     //     E <declaredIdentifier> = $iter.next();
     //     <body>
     //   }
     localsHandler.startLoop(node);
 
     SourceString iteratorName = const SourceString("iterator");
 
     Selector selector = Selector.INVOCATION_0;
     Element interceptor = interceptors.getStaticInterceptor(iteratorName, 0);
     assert(interceptor != null);
     HStatic target = new HStatic(interceptor);
     add(target);
     visit(node.expression);
     List<HInstruction> inputs = <HInstruction>[target, pop()];
     HInstruction iterator = new HInvokeInterceptor(
         selector, iteratorName, false, inputs);
     add(iterator);
 
-    BreakHandler breakHandler = beginLoopHeader(node);
+    JumpHandler jumpHandler = beginLoopHeader(node);
     HBasicBlock conditionBlock = current;
 
     // The condition.
     push(new HInvokeDynamicMethod(
         selector, const SourceString('hasNext'), [iterator]));
     HBasicBlock conditionExitBlock = close(new HLoopBranch(popBoolified()));
 
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
 
     // The body.
@@ skipping 13 matching lines @@
     } else {
       assert(node.declaredIdentifier.asVariableDefinitions() !== null);
       VariableDefinitions variableDefinitions = node.declaredIdentifier;
       variable = elements[variableDefinitions.definitions.nodes.head];
     }
     localsHandler.updateLocal(variable, pop());
 
     hackAroundPossiblyAbortingBody(node.body);
     bodyBlock = close(new HGoto());
 
+    jumpHandler.forEachContinue((x,y) {
+      // TODO(lrn): Handle continue in for-in.
+      // TODO(lrn): Or, preferably, use an abstraction of visitLoop for for-in.
+      compiler.cancel('for-in with continue', node: node);
+    });
+
     // 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());
     // The back-edge completing the cycle.
     updateBlock.addSuccessor(conditionBlock);
     conditionBlock.postProcessLoopHeader();
 
-    endLoop(conditionBlock, conditionExitBlock, breakHandler, savedLocals);
-    breakHandler.close();
+    endLoop(conditionBlock, conditionExitBlock, jumpHandler, savedLocals);
+    jumpHandler.close();
   }
 
   visitLabeledStatement(LabeledStatement node) {
     Statement body = node.getBody();
     if (body is Loop || body is SwitchStatement) {
       // Loops and switches handle their own labels.
       visit(body);
       return;
     }
     // Non-loop statements can only be break targets, not continue targets.
     TargetElement targetElement = elements[body];
     if (targetElement === null || targetElement.statement !== body) {
       // Labeled statements with no element on the body have no breaks.
       // A different target statement only happens if the body is itself
       // a break or continue for a different target. In that case, this
       // label is also always unused.
       visit(body);
       return;
     }
     LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler);
     assert(targetElement.isBreakTarget);
-    BreakHandler handler = new BreakHandler(this, targetElement);
+    JumpHandler handler = new JumpHandler(this, targetElement);
     // Introduce a new basic block.
     HBasicBlock entryBlock = graph.addNewBlock();
     goto(current, entryBlock);
     open(entryBlock);
     hackAroundPossiblyAbortingBody(body);
     SubGraph bodyGraph = new SubGraph(entryBlock, lastOpenedBlock);
 
     HBasicBlock joinBlock = graph.addNewBlock();
     List<LocalsHandler> breakLocals = <LocalsHandler>[];
     handler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
@@ skipping 49 matching lines @@
     HBasicBlock startBlock = graph.addNewBlock();
     goto(current, startBlock);
     open(startBlock);
     visit(node.expression);
     HInstruction expression = pop();
     if (node.cases.isEmpty()) {
       return;
     }
     Link<Node> cases = node.cases.nodes;
 
-    BreakHandler breakHandler = getBreakHandler(node);
+    JumpHandler jumpHandler = createJumpHandler(node);
 
     buildSwitchCases(cases, expression);
 
     HBasicBlock lastBlock = lastOpenedBlock;
 
     // Create merge block for break targets.
     HBasicBlock joinBlock = new HBasicBlock();
     List<LocalsHandler> caseLocals = <LocalsHandler>[];
-    breakHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
+    jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(joinBlock);
       caseLocals.add(locals);
     });
     if (!isAborted()) {
       // The current flow is only aborted if the switch has a default that
       // aborts (all previous cases must abort, and if there is no default,
       // it's possible to miss all the cases).
       caseLocals.add(localsHandler);
       goto(current, joinBlock);
     }
     if (caseLocals.length != 0) {
       graph.addBlock(joinBlock);
       open(joinBlock);
       if (caseLocals.length == 1) {
         localsHandler = caseLocals[0];
       } else {
         localsHandler = savedLocals.mergeMultiple(caseLocals, joinBlock);
       }
     } else {
       // The joinblock is not used.
       joinBlock = null;
     }
     startBlock.labeledBlockInformation = new HLabeledBlockInformation.implicit(
         new SubGraph(startBlock, lastBlock),
         joinBlock,
         elements[node]);
+    jumpHandler.close();
   }
 
 
   // Recursively build an if/else structure to match the cases.
   buildSwitchCases(Link<Node> cases, HInstruction expression) {
     SwitchCase node = cases.head;
 
     // Called for the statements on all but the last case block.
     // Ensures that a user expecting a fallthrough gets an error.
     void visitStatementsAndAbort() {
@@ skipping 208 matching lines @@
     buildBody() {
       // TODO(lrn): Make sure to take continue into account.
       visit(body);
       if (isAborted()) {
         compiler.reportWarning(body, "aborting loop body");
       }
     }
     handleIf(buildBody, null);
   }
 }