dart2js: Fix SSA corner case with always breaking loop and failing assert

sdk/lib/_internal/compiler/implementation/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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 478 matching lines @@
     if (scopeData == null) return;
     if (scopeData.hasBoxedLoopVariables()) {
       // If there are boxed loop variables then we set up the box and
       // redirections already now. This way the initializer can write its
       // values into the box.
       // For other loops the box will be created when entering the body.
       enterScope(node, null);
     }
   }
 
-  void beginLoopHeader(Node node, HBasicBlock loopEntry) {
+  /**
+   * Create phis at the loop entry for local variables (ready for the values
+   * from the back edge).  Populate the phis with the current values.
+   */
+  void beginLoopHeader(HBasicBlock loopEntry) {
     // Create a copy because we modify the map while iterating over it.
-    Map<Element, HInstruction> saved =
+    Map<Element, HInstruction> savedDirectLocals =
         new LinkedHashMap<Element, HInstruction>.from(directLocals);
 
     // Create phis for all elements in the definitions environment.
-    saved.forEach((Element element, HInstruction instruction) {
+    savedDirectLocals.forEach((Element element, HInstruction instruction) {
       if (isAccessedDirectly(element)) {
         // We know 'this' cannot be modified.
         if (!identical(element, closureData.thisElement)) {
           HPhi phi = new HPhi.singleInput(element, instruction);
           loopEntry.addPhi(phi);
           directLocals[element] = phi;
         } else {
           directLocals[element] = instruction;
         }
       }
@@ skipping 16 matching lines @@
     // updates.
     // In all other cases a new box will be created when entering the body of
     // the next iteration.
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     if (scopeData.hasBoxedLoopVariables()) {
       updateCaptureBox(scopeData.boxElement, scopeData.boxedLoopVariables);
     }
   }
 
+  /**
+   * Goes through the phis created in beginLoopHeader entry and adds the
+   * input from the back edge (from the current value of directLocals) to them.
+   */
   void endLoop(HBasicBlock loopEntry) {
     // If the loop has an aborting body, we don't update the loop
     // phis.
     if (loopEntry.predecessors.length == 1) return;
     loopEntry.forEachPhi((HPhi phi) {
       Element element = phi.sourceElement;
       HInstruction postLoopDefinition = directLocals[element];
       phi.addInput(postLoopDefinition);
     });
   }
@@ skipping 27 matching lines @@
               new HPhi.manyInputs(element, <HInstruction>[mine, instruction]);
           joinBlock.addPhi(phi);
           joinedLocals[element] = phi;
         }
       }
     });
     directLocals = joinedLocals;
   }
 
   /**
-   * The current localsHandler is not used for its values, only for its
-   * declared variables. This is a way to exclude local values from the
-   * result when they are no longer in scope.
-   * Returns the new LocalsHandler to use (may not be [this]).
+   * When control flow merges, this method can be used to merge several
+   * localsHandlers into a new one using phis.  The new localsHandler is
+   * returned.  Unless it is also in the list, the current localsHandler is not
+   * used for its values, only for its declared variables. This is a way to
+   * exclude local values from the result when they are no longer in scope.
    */
-  LocalsHandler mergeMultiple(List<LocalsHandler> locals,
+  LocalsHandler mergeMultiple(List<LocalsHandler> localsHandlers,
                               HBasicBlock joinBlock) {
-    assert(locals.length > 0);
-    if (locals.length == 1) return locals[0];
+    assert(localsHandlers.length > 0);
+    if (localsHandlers.length == 1) return localsHandlers[0];
     Map<Element, HInstruction> joinedLocals =
         new LinkedHashMap<Element,HInstruction>();
     HInstruction thisValue = null;
     directLocals.forEach((Element element, HInstruction instruction) {
       if (!identical(element, closureData.thisElement)) {
         HPhi phi = new HPhi.noInputs(element);
         joinedLocals[element] = phi;
         joinBlock.addPhi(phi);
       } else {
         // We know that "this" never changes, if it's there.
         // Save it for later. While merging, there is no phi for "this",
         // so we don't have to special case it in the merge loop.
         thisValue = instruction;
       }
     });
-    for (LocalsHandler local in locals) {
-      local.directLocals.forEach((Element element, HInstruction instruction) {
+    for (LocalsHandler handler in localsHandlers) {
+      handler.directLocals.forEach((Element element, HInstruction instruction) {
         HPhi phi = joinedLocals[element];
         if (phi != null) {
           phi.addInput(instruction);
         }
       });
     }
     if (thisValue != null) {
       // If there was a "this" for the scope, add it to the new locals.
       joinedLocals[closureData.thisElement] = thisValue;
     }
@@ skipping 1104 matching lines @@
     Script script = element.getCompilationUnit().script;
     SourceFile sourceFile = script.file;
     SourceFileLocation location = new SourceFileLocation(sourceFile, token);
     if (!location.isValid()) {
       throw MessageKind.INVALID_SOURCE_FILE_LOCATION.message(
           {'offset': token.charOffset,
            'fileName': sourceFile.filename,
            'length': sourceFile.text.length});
     }
     return location;
-}
+  }
 
   void visit(Node node) {
     if (node != null) node.accept(this);
   }
 
   visitBlock(Block node) {
     for (Link<Node> link = node.statements.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
@@ skipping 25 matching lines @@
     assert(!isAborted());
     HBasicBlock previousBlock = close(new HGoto());
 
     JumpHandler jumpHandler = createJumpHandler(node);
     HBasicBlock loopEntry = graph.addNewLoopHeaderBlock(
         jumpHandler.target,
         jumpHandler.labels());
     previousBlock.addSuccessor(loopEntry);
     open(loopEntry);
 
-    localsHandler.beginLoopHeader(node, loopEntry);
+    localsHandler.beginLoopHeader(loopEntry);
     return jumpHandler;
   }
 
   /**
    * Ends the loop:
-   * - creates a new block and adds it as successor to the [branchBlock].
+   * - creates a new block and adds it as successor to the [branchBlock] and
+   *   any blocks that end in break.
    * - opens the new block (setting as [current]).
    * - notifies the locals handler that we're exiting a loop.
+   * [savedLocals] are the locals from the end of the loop condition.
+   * [branchBlock] is the exit (branching) block of the condition.  For the
+   * while and for loops this is at the top of the loop.  For do-while it is
+   * the end of the body.  It is null for degenerate do-while loops that have
+   * no back edge because they abort (throw/return/break in the body and have
+   * no continues).
    */
   void endLoop(HBasicBlock loopEntry,
                HBasicBlock branchBlock,
                JumpHandler jumpHandler,
                LocalsHandler savedLocals) {
-    if (branchBlock == null && !jumpHandler.hasAnyBreak()) return;
-
     HBasicBlock loopExitBlock = addNewBlock();
-    assert(branchBlock == null || branchBlock.successors.length == 1);
-    List<LocalsHandler> breakLocals = <LocalsHandler>[];
+    List<LocalsHandler> breakHandlers = <LocalsHandler>[];
+    // Collect data for the successors and the phis at each break.
     jumpHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(loopExitBlock);
-      breakLocals.add(locals);
+      breakHandlers.add(locals);
     });
+    // The exit block is a successor of the loop condition if it is reached.
+    // We don't add the successor in the case of a while/for loop that aborts
+    // because the caller of endLoop will be wiring up a special empty else
+    // block instead.
     if (branchBlock != null) {
       branchBlock.addSuccessor(loopExitBlock);
     }
+    // Update the phis at the loop entry with the current values of locals.
+    localsHandler.endLoop(loopEntry);
+
+    // Start generating code for the exit block.
     open(loopExitBlock);
-    localsHandler.endLoop(loopEntry);
-    if (!breakLocals.isEmpty) {
-      breakLocals.add(savedLocals);
-      localsHandler = savedLocals.mergeMultiple(breakLocals, loopExitBlock);
+
+    // Create a new localsHandler for the loopExitBlock with the correct phis.
+    if (!breakHandlers.isEmpty) {
+      if (branchBlock != null) {
+        // Add the values of the locals at the end of the condition block to
+        // the phis.  These are the values that flow to the exit if the
+        // condition fails.
+        breakHandlers.add(savedLocals);
+      }
+      localsHandler = savedLocals.mergeMultiple(breakHandlers, loopExitBlock);
     } else {
       localsHandler = savedLocals;
     }
   }
 
   HSubGraphBlockInformation wrapStatementGraph(SubGraph statements) {
     if (statements == null) return null;
     return new HSubGraphBlockInformation(statements);
   }
 
@@ skipping 37 matching lines @@
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock conditionBlock = current;
     if (startBlock == null) startBlock = conditionBlock;
 
     HInstruction conditionInstruction = condition();
     HBasicBlock conditionExitBlock =
         close(new HLoopBranch(conditionInstruction));
     SubExpression conditionExpression =
         new SubExpression(conditionBlock, conditionExitBlock);
 
+    // Save the values of the local variables at the end of the condition
+    // block.  These are the values that will flow to the loop exit if the
+    // condition fails.
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
 
     // The body.
     HBasicBlock beginBodyBlock = addNewBlock();
     conditionExitBlock.addSuccessor(beginBodyBlock);
     open(beginBodyBlock);
 
     localsHandler.enterLoopBody(loop);
     body();
 
     SubGraph bodyGraph = new SubGraph(beginBodyBlock, lastOpenedBlock);
     HBasicBlock bodyBlock = current;
     if (current != null) close(new HGoto());
 
     SubExpression updateGraph;
 
-    // Check that the loop has at least one back-edge.
-    if (jumpHandler.hasAnyContinue() || bodyBlock != null) {
+    bool loopIsDegenerate = !jumpHandler.hasAnyContinue() && bodyBlock == null;
+    if (!loopIsDegenerate) {
       // 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>[];
+      List<LocalsHandler> continueHandlers = <LocalsHandler>[];
       jumpHandler.forEachContinue((HContinue instruction,
                                    LocalsHandler locals) {
         instruction.block.addSuccessor(updateBlock);
-        continueLocals.add(locals);
+        continueHandlers.add(locals);
       });
 
 
       if (bodyBlock != null) {
-        continueLocals.add(localsHandler);
+        continueHandlers.add(localsHandler);
         bodyBlock.addSuccessor(updateBlock);
       }
 
       open(updateBlock);
       localsHandler =
-          continueLocals[0].mergeMultiple(continueLocals, updateBlock);
+          continueHandlers[0].mergeMultiple(continueHandlers, updateBlock);
 
       HLabeledBlockInformation labelInfo;
       List<LabelElement> labels = jumpHandler.labels();
       TargetElement target = elements[loop];
       if (!labels.isEmpty) {
         beginBodyBlock.setBlockFlow(
             new HLabeledBlockInformation(
                 new HSubGraphBlockInformation(bodyGraph),
                 jumpHandler.labels(),
                 isContinue: true),
             updateBlock);
       } else if (target != null && target.isContinueTarget) {
         beginBodyBlock.setBlockFlow(
             new HLabeledBlockInformation.implicit(
                 new HSubGraphBlockInformation(bodyGraph),
                 target,
                 isContinue: true),
             updateBlock);
       }
 
       localsHandler.enterLoopUpdates(loop);
 
       update();
 
       HBasicBlock updateEndBlock = close(new HGoto());
       // The back-edge completing the cycle.
       updateEndBlock.addSuccessor(conditionBlock);
       updateGraph = new SubExpression(updateBlock, updateEndBlock);
-    }
 
-    if (jumpHandler.hasAnyContinue() || bodyBlock != null) {
       endLoop(conditionBlock, conditionExitBlock, jumpHandler, savedLocals);
+
       conditionBlock.postProcessLoopHeader();
       HLoopBlockInformation info =
           new HLoopBlockInformation(
               HLoopBlockInformation.loopType(loop),
               wrapExpressionGraph(initializerGraph),
               wrapExpressionGraph(conditionExpression),
               wrapStatementGraph(bodyGraph),
               wrapExpressionGraph(updateGraph),
               conditionBlock.loopInformation.target,
               conditionBlock.loopInformation.labels,
               sourceFileLocationForBeginToken(loop),
               sourceFileLocationForEndToken(loop));
 
       startBlock.setBlockFlow(info, current);
       loopInfo.loopBlockInformation = info;
     } else {
-      // There is no back edge for the loop, so we turn the code into:
+      // The body of the for/while loop always aborts, so there is no back edge.
+      // We turn the code into:
       // if (condition) {
       //   body;
       // } else {
       //   // We always create an empty else block to avoid critical edges.
       // }
       //
       // If there is any break in the body, we attach a synthetic
       // label to the if.
       HBasicBlock elseBlock = addNewBlock();
       open(elseBlock);
       close(new HGoto());
-      endLoop(conditionBlock, null, jumpHandler, savedLocals);
+      // Pass the elseBlock as the branchBlock, because that's the block we go
+      // to just before leaving the 'loop'.
+      endLoop(conditionBlock, elseBlock, jumpHandler, savedLocals);
 
-      // [endLoop] will not create an exit block if there are no
-      // breaks.
-      if (current == null) open(addNewBlock());
-      elseBlock.addSuccessor(current);
       SubGraph elseGraph = new SubGraph(elseBlock, elseBlock);
       // Remove the loop information attached to the header.
       conditionBlock.loopInformation = null;
 
       // Remove the [HLoopBranch] instruction and replace it with
       // [HIf].
       HInstruction condition = conditionExitBlock.last.inputs[0];
       conditionExitBlock.addAtExit(new HIf(condition));
       conditionExitBlock.addSuccessor(elseBlock);
       conditionExitBlock.remove(conditionExitBlock.last);
@@ skipping 103 matching lines @@
     HBasicBlock bodyExitBlock;
     bool isAbortingBody = false;
     if (current != null) {
       bodyExitBlock = close(new HGoto());
     } else {
       isAbortingBody = true;
       bodyExitBlock = lastOpenedBlock;
     }
 
     SubExpression conditionExpression;
-    HBasicBlock conditionEndBlock;
-    if (!isAbortingBody || hasContinues) {
+    bool loopIsDegenerate = isAbortingBody && !hasContinues;
+    if (!loopIsDegenerate) {
       HBasicBlock conditionBlock = addNewBlock();
 
-      List<LocalsHandler> continueLocals = <LocalsHandler>[];
+      List<LocalsHandler> continueHandlers = <LocalsHandler>[];
       jumpHandler.forEachContinue((HContinue instruction,
                                    LocalsHandler locals) {
         instruction.block.addSuccessor(conditionBlock);
-        continueLocals.add(locals);
+        continueHandlers.add(locals);
       });
 
       if (!isAbortingBody) {
         bodyExitBlock.addSuccessor(conditionBlock);
       }
 
-      if (!continueLocals.isEmpty) {
-        if (!isAbortingBody) continueLocals.add(localsHandler);
+      if (!continueHandlers.isEmpty) {
+        if (!isAbortingBody) continueHandlers.add(localsHandler);
         localsHandler =
-            savedLocals.mergeMultiple(continueLocals, conditionBlock);
+            savedLocals.mergeMultiple(continueHandlers, conditionBlock);
         SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
         List<LabelElement> labels = jumpHandler.labels();
         HSubGraphBlockInformation bodyInfo =
             new HSubGraphBlockInformation(bodyGraph);
         HLabeledBlockInformation info;
         if (!labels.isEmpty) {
           info = new HLabeledBlockInformation(bodyInfo, labels,
                                               isContinue: true);
         } else {
           info = new HLabeledBlockInformation.implicit(bodyInfo, target,
                                                        isContinue: true);
         }
         bodyEntryBlock.setBlockFlow(info, conditionBlock);
       }
       open(conditionBlock);
 
       visit(node.condition);
       assert(!isAborted());
       HInstruction conditionInstruction = popBoolified();
-      conditionEndBlock = close(
+      HBasicBlock conditionEndBlock = close(
           new HLoopBranch(conditionInstruction, HLoopBranch.DO_WHILE_LOOP));
 
       HBasicBlock avoidCriticalEdge = addNewBlock();
       conditionEndBlock.addSuccessor(avoidCriticalEdge);
       open(avoidCriticalEdge);
       close(new HGoto());
       avoidCriticalEdge.addSuccessor(loopEntryBlock); // The back-edge.
 
       conditionExpression =
           new SubExpression(conditionBlock, conditionEndBlock);
-    }
 
-    endLoop(loopEntryBlock, conditionEndBlock, jumpHandler, localsHandler);
-    if (!isAbortingBody || hasContinues) {
+      endLoop(loopEntryBlock, conditionEndBlock, jumpHandler, localsHandler);
+
       loopEntryBlock.postProcessLoopHeader();
       SubGraph bodyGraph = new SubGraph(loopEntryBlock, bodyExitBlock);
       HLoopBlockInformation loopBlockInfo =
           new HLoopBlockInformation(
               HLoopBlockInformation.DO_WHILE_LOOP,
               null,
               wrapExpressionGraph(conditionExpression),
               wrapStatementGraph(bodyGraph),
               null,
               loopEntryBlock.loopInformation.target,
               loopEntryBlock.loopInformation.labels,
               sourceFileLocationForBeginToken(node),
               sourceFileLocationForEndToken(node));
       loopEntryBlock.setBlockFlow(loopBlockInfo, current);
       loopInfo.loopBlockInformation = loopBlockInfo;
     } else {
-      // If the loop has no back edge, we remove the loop information
-      // on the header.
+      // Since the loop has no back edge, we remove the loop information on the
+      // header.
       loopEntryBlock.loopInformation = null;
 
-      // If the body of the loop has any break, we attach a
-      // synthesized label to the body.
       if (jumpHandler.hasAnyBreak()) {
+        // Null branchBlock because the body of the do-while loop always aborts,
+        // so we never get to the condition.
+        endLoop(loopEntryBlock, null, jumpHandler, localsHandler);
+
+        // Since the body of the loop has a break, we attach a synthesized label
+        // to the body.
         SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
         TargetElement target = elements[node];
         LabelElement label = target.addLabel(null, 'loop');
         label.setBreakTarget();
         HLabeledBlockInformation info = new HLabeledBlockInformation(
             new HSubGraphBlockInformation(bodyGraph), <LabelElement>[label]);
         loopEntryBlock.setBlockFlow(info, current);
         jumpHandler.forEachBreak((HBreak breakInstruction, _) {
           HBasicBlock block = breakInstruction.block;
           block.addAtExit(new HBreak.toLabel(label));
@@ skipping 1882 matching lines @@
     }
     LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler);
     assert(targetElement.isBreakTarget);
     JumpHandler handler = new JumpHandler(this, targetElement);
     // Introduce a new basic block.
     HBasicBlock entryBlock = openNewBlock();
     visit(body);
     SubGraph bodyGraph = new SubGraph(entryBlock, lastOpenedBlock);
 
     HBasicBlock joinBlock = graph.addNewBlock();
-    List<LocalsHandler> breakLocals = <LocalsHandler>[];
+    List<LocalsHandler> breakHandlers = <LocalsHandler>[];
     handler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(joinBlock);
-      breakLocals.add(locals);
+      breakHandlers.add(locals);
     });
-    bool hasBreak = breakLocals.length > 0;
+    bool hasBreak = breakHandlers.length > 0;
     if (!isAborted()) {
       goto(current, joinBlock);
-      breakLocals.add(localsHandler);
+      breakHandlers.add(localsHandler);
     }
     open(joinBlock);
-    localsHandler = beforeLocals.mergeMultiple(breakLocals, joinBlock);
+    localsHandler = beforeLocals.mergeMultiple(breakHandlers, joinBlock);
 
     if (hasBreak) {
       // There was at least one reachable break, so the label is needed.
       entryBlock.setBlockFlow(
           new HLabeledBlockInformation(new HSubGraphBlockInformation(bodyGraph),
                                        handler.labels()),
           joinBlock);
     }
     handler.close();
   }
@@ skipping 42 matching lines @@
 
     Link<Node> cases = node.cases.nodes;
     JumpHandler jumpHandler = createJumpHandler(node);
 
     buildSwitchCases(cases, expression);
 
     HBasicBlock lastBlock = lastOpenedBlock;
 
     // Create merge block for break targets.
     HBasicBlock joinBlock = new HBasicBlock();
-    List<LocalsHandler> caseLocals = <LocalsHandler>[];
+    List<LocalsHandler> caseHandlers = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(joinBlock);
-      caseLocals.add(locals);
+      caseHandlers.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);
+      caseHandlers.add(localsHandler);
       goto(current, joinBlock);
     }
-    if (caseLocals.length != 0) {
+    if (caseHandlers.length != 0) {
       graph.addBlock(joinBlock);
       open(joinBlock);
-      if (caseLocals.length == 1) {
-        localsHandler = caseLocals[0];
+      if (caseHandlers.length == 1) {
+        localsHandler = caseHandlers[0];
       } else {
-        localsHandler = savedLocals.mergeMultiple(caseLocals, joinBlock);
+        localsHandler = savedLocals.mergeMultiple(caseHandlers, joinBlock);
       }
     } else {
       // The joinblock is not used.
       joinBlock = null;
     }
     startBlock.setBlockFlow(
         new HLabeledBlockInformation.implicit(
             new HSubGraphBlockInformation(new SubGraph(startBlock, lastBlock)),
             elements[node]),
         joinBlock);
@@ skipping 100 matching lines @@
         HInstruction error = pop();
         close(new HThrow(error));
       }
       statements.add(
           new HSubGraphBlockInformation(new SubGraph(block, lastOpenedBlock)));
     }
 
     // Add a join-block if necessary.
     // We create [joinBlock] early, and then go through the cases that might
     // want to jump to it. In each case, if we add [joinBlock] as a successor
-    // of another block, we also add an element to [caseLocals] that is used
+    // of another block, we also add an element to [caseHandlers] that is used
     // to create the phis in [joinBlock].
-    // If we never jump to the join block, [caseLocals] will stay empty, and
+    // If we never jump to the join block, [caseHandlers] will stay empty, and
     // the join block is never added to the graph.
     HBasicBlock joinBlock = new HBasicBlock();
-    List<LocalsHandler> caseLocals = <LocalsHandler>[];
+    List<LocalsHandler> caseHandlers = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(joinBlock);
-      caseLocals.add(locals);
+      caseHandlers.add(locals);
     });
     if (!isAborted()) {
       current.close(new HGoto());
       lastOpenedBlock.addSuccessor(joinBlock);
-      caseLocals.add(localsHandler);
+      caseHandlers.add(localsHandler);
     }
     if (!hasDefault) {
       // 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).
       expressionEnd.addSuccessor(joinBlock);
-      caseLocals.add(savedLocals);
+      caseHandlers.add(savedLocals);
     }
-    assert(caseLocals.length == joinBlock.predecessors.length);
-    if (caseLocals.length != 0) {
+    assert(caseHandlers.length == joinBlock.predecessors.length);
+    if (caseHandlers.length != 0) {
       graph.addBlock(joinBlock);
       open(joinBlock);
-      if (caseLocals.length == 1) {
-        localsHandler = caseLocals[0];
+      if (caseHandlers.length == 1) {
+        localsHandler = caseHandlers[0];
       } else {
-        localsHandler = savedLocals.mergeMultiple(caseLocals, joinBlock);
+        localsHandler = savedLocals.mergeMultiple(caseHandlers, joinBlock);
       }
     } else {
       // The joinblock is not used.
       joinBlock = null;
     }
 
     HSubExpressionBlockInformation expressionInfo =
         new HSubExpressionBlockInformation(new SubExpression(expressionStart,
                                                              expressionEnd));
     expressionStart.setBlockFlow(
@@ skipping 532 matching lines @@
     }
     node.visitChildren(this);
     seenReturn = true;
   }
 
   void visitTryStatement(Node node) {
     if (!registerNode()) return;
     tooDifficult = true;
   }
 
   void visitThrow(Node node) {

[ngeoffray, 2013/04/07 09:48:50]

Why is that restriction not removed? Is that not what inlined_throw_test checks?

     if (!registerNode()) return;
     tooDifficult = true;
   }
 }
 
 class InliningState {
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
@@ skipping 243 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }