Implement continue for switch.

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 515 matching lines @@
   void enterLoopBody(Node node) {
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     // If there are no declared boxed loop variables then we did not create the
     // box before the initializer and we have to create the box now.
     if (!scopeData.hasBoxedLoopVariables()) {
       enterScope(node, null);
     }
   }
 
-  void enterLoopUpdates(Loop node) {
+  void enterLoopUpdates(Node node) {
     // If there are declared boxed loop variables then the updates might have
     // access to the box and we must switch to a new box before executing the
     // 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);
     }
@@ skipping 182 matching lines @@
     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);
+      // Switch case continue statements must be handled by the
+      // [SwitchCaseJumpHandler].
+      assert(label.target.statement is! SwitchCase);
     }
     LocalsHandler locals = new LocalsHandler.from(builder.localsHandler);
     builder.close(continueInstruction);
     jumps.add(new JumpHandlerEntry(continueInstruction, locals));
   }
 
   void forEachBreak(Function action) {
     for (JumpHandlerEntry entry in jumps) {
       if (entry.isBreak()) action(entry.jumpInstruction, entry.locals);
     }
@@ skipping 27 matching lines @@
   List<LabelElement> labels() {
     List<LabelElement> result = null;
     for (LabelElement element in target.labels) {
       if (result == null) result = <LabelElement>[];
       result.add(element);
     }
     return (result == null) ? const <LabelElement>[] : result;
   }
 }
 
+/// Special [JumpHandler] implementation used to handle continue statements
+/// targeting switch cases.
+class SwitchCaseJumpHandler extends TargetJumpHandler {
+  /// Map from switch case targets to indices used to encode the flow of the
+  /// switch case loop.
+  final Map<TargetElement, int> targetIndexMap = new Map<TargetElement, int>();
+
+  SwitchCaseJumpHandler(SsaBuilder builder,
+                        TargetElement target,
+                        SwitchStatement node)
+      : super(builder, target) {
+    // The switch case indices must match those computed in
+    // [SsaBuilder.visitSwitchStatement].
+    int switchIndex = 1;

[ngeoffray, 2013/05/14 07:08:51]

Explain why you start with 1.

[Johnni Winther, 2013/05/17 07:03:04]

Done.

+    for (SwitchCase switchCase in node.cases) {
+      for (Node labelOrCase in switchCase.labelsAndCases) {
+        Node label = labelOrCase.asLabel();
+        if (label != null) {
+          LabelElement labelElement = builder.elements[label];
+          if (labelElement != null) {
+            if (labelElement.isContinueTarget) {

[ngeoffray, 2013/05/14 07:08:51]

I prever avoiding nested if and do if (labelElement != null &&
labelElement.isContinueTarget).

[Johnni Winther, 2013/05/17 07:03:04]

Done.

+              TargetElement continueTarget = labelElement.target;
+              targetIndexMap[continueTarget] = switchIndex;
+              assert(builder.jumpTargets[continueTarget] == null);
+              builder.jumpTargets[continueTarget] = this;
+            }
+          }
+        }
+      }
+      switchIndex++;
+    }
+  }
+
+  void generateBreak([LabelElement label]) {
+    if (label == null) {
+      // Creates a special break instruction for the synthetic loop generated
+      // for a switch statement with continue statements. See
+      // [SsaBuilder.visitSwitchStatement] for detail.
+
+      HInstruction breakInstruction =
+          new HBreak(target, breakSwitchContinueLoop: true);
+      LocalsHandler locals = new LocalsHandler.from(builder.localsHandler);
+      builder.close(breakInstruction);
+      jumps.add(new JumpHandlerEntry(breakInstruction, locals));
+    } else {
+      super.generateBreak(label);
+    }
+  }
+
+  void generateContinue([LabelElement label]) {
+    if (label != null && targetIndexMap.containsKey(label.target)) {

[ngeoffray, 2013/05/14 07:08:51]

It would read nicer with a helper method whose name explains what it means: if
(isContinueToSwithCase(label)) {...

[Johnni Winther, 2013/05/17 07:03:04]

Done.

+      // Creates the special instructions 'label = i; continue l;' used in
+      // switch statements with continue statements. See
+      // [SsaBuilder.visitSwitchStatement] for detail.
+
+      assert(label != null);
+      HInstruction value = builder.graph.addConstantInt(
+          targetIndexMap[label.target],
+          builder.constantSystem);
+      builder.localsHandler.updateLocal(target, value);
+
+      assert(label.target.labels.contains(label));
+      HInstruction continueInstruction = new HContinue(target);
+      LocalsHandler locals = new LocalsHandler.from(builder.localsHandler);
+      builder.close(continueInstruction);
+      jumps.add(new JumpHandlerEntry(continueInstruction, locals));
+    } else {
+      super.generateContinue(label);
+    }
+  }
+
+  void close() {
+    // The mapping from TargetElement to JumpHandler is no longer needed.
+    for (TargetElement target in targetIndexMap.keys) {
+      builder.jumpTargets.remove(target);
+    }
+    super.close();
+  }
+}
+
 class SsaBuilder extends ResolvedVisitor implements Visitor {
   final SsaBuilderTask builder;
   final JavaScriptBackend backend;
   final CodegenWorkItem work;
   final ConstantSystem constantSystem;
   HGraph graph;
   LocalsHandler localsHandler;
   HInstruction rethrowableException;
   Map<Element, HInstruction> parameters;
   final RuntimeTypes rti;
@@ skipping 1085 matching lines @@
 
   /**
    * 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.
    */
   JumpHandler beginLoopHeader(Node node) {
     assert(!isAborted());
     HBasicBlock previousBlock = close(new HGoto());
 
-    JumpHandler jumpHandler = createJumpHandler(node);
+    JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: true);
     HBasicBlock loopEntry = graph.addNewLoopHeaderBlock(
         jumpHandler.target,
         jumpHandler.labels());
     previousBlock.addSuccessor(loopEntry);
     open(loopEntry);
 
     localsHandler.beginLoopHeader(loopEntry);
     return jumpHandler;
   }
 
@@ skipping 2218 matching lines @@
       LabelElement label = elements[node.target];
       assert(label != null);
       handler.generateContinue(label);
     }
   }
 
   /**
    * 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.
+   *
+   * [isLoopJump] is [:true:] when the jump handler is for a loop. This is used
+   * to distinguish the synthetized loop created for a switch statement with
+   * continue statements from simple switch statements.
    */
-  JumpHandler createJumpHandler(Statement node) {
+  JumpHandler createJumpHandler(Statement node, {bool isLoopJump}) {
     TargetElement element = elements[node];
     if (element == null || !identical(element.statement, node)) {
       // No breaks or continues to this node.
       return new NullJumpHandler(compiler);
     }
+    if (isLoopJump && node is SwitchStatement) {
+      // Create a special jump handler for loops created for switch statements
+      // with continue statements.
+      return new SwitchCaseJumpHandler(this, element, node);
+    }
     return new JumpHandler(this, element);
   }
 
   visitForIn(ForIn node) {
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator;
     //   while ($iter.moveNext()) {
     //     E <declaredIdentifier> = $iter.current;
     //     <body>
     //   }
@@ skipping 119 matching lines @@
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
-    if (tryBuildConstantSwitch(node)) return;
+    // The switch case indices must match those computed in
+    // [SwitchCaseJumpHandler].
+    bool hasContinue = false;
+    Map<SwitchCase, int> caseIndex = new Map<SwitchCase, int>();
+    int switchIndex = 1;
+    bool hasDefault = false;
+    for (SwitchCase switchCase in node.cases) {
+      for (Node labelOrCase in switchCase.labelsAndCases) {
+        Node label = labelOrCase.asLabel();
+        if (label != null) {
+          LabelElement labelElement = elements[label];
+          if (labelElement != null && labelElement.isContinueTarget) {
+            hasContinue = true;
+          }
+        }
+      }
+      if (switchCase.isDefaultCase) {
+        hasDefault = true;
+      }
+      caseIndex[switchCase] = switchIndex;
+      switchIndex++;
+    }
+    if (!hasContinue) {
+      // If the switch statement has no switch cases targeted by continue
+      // statements we encode the switch statement directly.
+      void buildSwitchCase(SwitchCase node) {
+        visit(node.statements);
+      }
+      buildSwitchStatement(node, buildSwitchCase);
+    } else {
+      // If the switch statement has switch cases targeted by continue
+      // statements we create the following encoding:
+      //
+      //   switch (e) {
+      //     l_1: case e0: s_1; break;
+      //     l_2: case e1: s_2; continue l_i;
+      //     ...
+      //     l_n: default: s_n; continue l_j;
+      //   }
+      //
+      // is encoded as
+      //
+      //   var target;
+      //   switch (e) {
+      //     case e1: target = 1; break;
+      //     case e2: target = 2; break;
+      //     ...
+      //     default: target = n; break;
+      //   }
+      //   l: while (true) {
+      //    switch (target) {
+      //       case 1: s_1; break l;
+      //       case 2: s_2; target = i; continue l;
+      //       ...
+      //       case n: s_n; target = j; continue l;
+      //     }
+      //   }
 
+      TargetElement switchTarget = elements[node];
+      HInstruction initialValue = graph.addConstantNull(constantSystem);
+      localsHandler.updateLocal(switchTarget, initialValue);
+      void buildSwitchCase(SwitchCase switchCase) {
+        // Generate 'target = i; break;' for switch case i.
+        int index = caseIndex[switchCase];
+        HInstruction value = graph.addConstantInt(index, constantSystem);
+        localsHandler.updateLocal(switchTarget, value);
+        jumpTargets[switchTarget].generateBreak();
+      }
+      buildSwitchStatement(node, buildSwitchCase);
+
+      HInstruction buildCondition() =>
+          graph.addConstantBool(true, constantSystem);
+
+      void buildSwitch() {
+        HInstruction buildExpression() {
+          return localsHandler.readLocal(switchTarget);
+        }
+        Iterable<Constant> getConstants(SwitchCase switchCase) {
+          return <Constant>[constantSystem.createInt(caseIndex[switchCase])];
+        }
+        void buildSwitchCase(SwitchCase switchCase) {
+          visit(switchCase.statements);
+          if (!isAborted()) {
+            // Ensure that we break the loop if the case falls through. (This
+            // is only possible for the last case.)
+            jumpTargets[switchTarget].generateBreak();
+          }
+        }
+        // Pass a [NullJumpHandler] because the target for the contained break
+        // is not the generated switch statement but instead the loop generated
+        // in the call to [handleLoop] below.
+        handleSwitch(
+            new NullJumpHandler(compiler),
+            buildExpression, node, getConstants,
+            (_) => false, // No case is default.
+            buildSwitchCase);
+      }
+
+      void buildLoop() {
+        handleLoop(node,
+            () {},
+            buildCondition,
+            () {},
+            buildSwitch);
+      }
+
+      if (hasDefault) {
+        buildLoop();
+      } else {
+        // If the switch statement has no default case, surround the loop with
+        // a test of the target.
+        void buildCondition() {
+          push(createForeign('#', HType.BOOLEAN,
+                             [localsHandler.readLocal(switchTarget)]));
+        }
+        handleIf(node, buildCondition, buildLoop, () => {});
+      }
+    }
+  }
+
+  buildSwitchStatement(SwitchStatement node,
+                       void buildSwitchCase(SwitchCase switchCase)) {
+    if (tryBuildConstantSwitch(node, buildSwitchCase)) return;
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     HBasicBlock startBlock = openNewBlock();
     visit(node.expression);
     HInstruction expression = pop();
     if (node.cases.isEmpty) {
       return;
     }
 
     Link<Node> cases = node.cases.nodes;
-    JumpHandler jumpHandler = createJumpHandler(node);
+    JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false);
 
-    buildSwitchCases(cases, expression);
+    buildSwitchCases(jumpHandler, cases, expression, buildSwitchCase);
 
     HBasicBlock lastBlock = lastOpenedBlock;
 
     // Create merge block for break targets.
     HBasicBlock joinBlock = new HBasicBlock();
     List<LocalsHandler> caseHandlers = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(joinBlock);
       caseHandlers.add(locals);
     });
@@ skipping 17 matching lines @@
       joinBlock = null;
     }
     startBlock.setBlockFlow(
         new HLabeledBlockInformation.implicit(
             new HSubGraphBlockInformation(new SubGraph(startBlock, lastBlock)),
             elements[node]),
         joinBlock);
     jumpHandler.close();
   }
 
-  bool tryBuildConstantSwitch(SwitchStatement node) {
+  bool tryBuildConstantSwitch(SwitchStatement node,
+                              void buildSwitchCase(SwitchCase switchCase)) {
     Map<CaseMatch, Constant> constants = new Map<CaseMatch, Constant>();
     // First check whether all case expressions are compile-time constants,
     // and all have the same type that doesn't override operator==.
     // TODO(lrn): Move the constant resolution to the resolver, so
     // we can report an error before reaching the backend.
     DartType firstConstantType = null;
     bool failure = false;
     for (SwitchCase switchCase in node.cases) {
       for (Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is CaseMatch) {
@@ skipping 17 matching lines @@
           } else {
             DartType constantType =
                 constant.computeType(compiler);
             if (constantType != firstConstantType) {
               compiler.reportWarning(match.expression,
                   MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL.error());
               failure = true;
             }
           }
           constants[labelOrCase] = constant;
-        } else {
-          compiler.reportWarning(node, "Unsupported: Labels on cases");
-          failure = true;
         }
       }
     }
     if (failure) {
       return false;
     }
 
+    JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false);
+    HInstruction buildExpression() {
+      visit(node.expression);
+      return pop();
+    }
+    Iterable<Constant> getConstants(SwitchCase switchCase) {
+      List<Constant> constantList = <Constant>[];
+      for (Node labelOrCase in switchCase.labelsAndCases) {
+        if (labelOrCase is CaseMatch) {
+          constantList.add(constants[labelOrCase]);
+        }
+      }
+      return constantList;
+    }
+    handleSwitch(jumpHandler, buildExpression, node,
+                 getConstants,
+                 (SwitchCase switchCase) => switchCase.isDefaultCase,
+                 buildSwitchCase);
+    jumpHandler.close();
+    return true;
+  }
+
+  /**
+   * Creates a switch statement [node].

[ngeoffray, 2013/05/14 07:08:51]

Do you mean a [HSwitch] ?

[Johnni Winther, 2013/05/17 07:03:04]

A 'for' was missing. Now it doesn't apply.

+   *
+   * [jumpHandler] is the [JumpHandler] for the created switch statement.
+   * [buildExpression] creates the switch expression.
+   * [getConstants] returns the set of constants for a switch case.
+   * [buildSwitchCase] creates the statements for the switch case.
+   */
+  void handleSwitch(JumpHandler jumpHandler,
+                    HInstruction buildExpression(),
+                    SwitchStatement node,
+                    Iterable<Constant> getConstants(SwitchCase switchCase),
+                    bool isDefaultCase(SwitchCase switchCase),
+                    void buildSwitchCase(SwitchCase switchCase)) {
+    Map<CaseMatch, Constant> constants = new Map<CaseMatch, Constant>();
+
     // TODO(ngeoffray): Handle switch-instruction in bailout code.
     work.allowSpeculativeOptimization = false;
     // Then build a switch structure.
     HBasicBlock expressionStart = openNewBlock();
-    visit(node.expression);
-    HInstruction expression = pop();
+    HInstruction expression = buildExpression();
     if (node.cases.isEmpty) {
-      return true;
+      return;
     }
     HBasicBlock expressionEnd = current;
 
     HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]);
     HBasicBlock expressionBlock = close(switchInstruction);
-    JumpHandler jumpHandler = createJumpHandler(node);
     LocalsHandler savedLocals = localsHandler;
 
     List<List<Constant>> matchExpressions = <List<Constant>>[];
     List<HStatementInformation> statements = <HStatementInformation>[];
     bool hasDefault = false;
     Element getFallThroughErrorElement = backend.getFallThroughError();
     HasNextIterator<Node> caseIterator =
         new HasNextIterator<Node>(node.cases.iterator);
     while (caseIterator.hasNext) {
       SwitchCase switchCase = caseIterator.next();
       List<Constant> caseConstants = <Constant>[];
       HBasicBlock block = graph.addNewBlock();
-      for (Node labelOrCase in switchCase.labelsAndCases) {
-        if (labelOrCase is CaseMatch) {
-          Constant constant = constants[labelOrCase];
-          caseConstants.add(constant);
-          HConstant hConstant = graph.addConstant(constant);
-          switchInstruction.inputs.add(hConstant);
-          hConstant.usedBy.add(switchInstruction);
-          expressionBlock.addSuccessor(block);
-        }
+      for (Constant constant in getConstants(switchCase)) {
+        caseConstants.add(constant);
+        HConstant hConstant = graph.addConstant(constant);
+        switchInstruction.inputs.add(hConstant);
+        hConstant.usedBy.add(switchInstruction);
+        expressionBlock.addSuccessor(block);
       }
       matchExpressions.add(caseConstants);
 
-      if (switchCase.isDefaultCase) {
+      if (isDefaultCase(switchCase)) {
         // An HSwitch has n inputs and n+1 successors, the last being the
         // default case.
         expressionBlock.addSuccessor(block);
         hasDefault = true;
       }
       open(block);
       localsHandler = new LocalsHandler.from(savedLocals);
-      visit(switchCase.statements);
+      buildSwitchCase(switchCase);
       if (!isAborted() && caseIterator.hasNext) {
         pushInvokeHelper0(getFallThroughErrorElement, HType.UNKNOWN);
         HInstruction error = pop();
         closeAndGotoExit(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 [caseHandlers] that is used
     // to create the phis in [joinBlock].
     // 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> caseHandlers = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(joinBlock);
       caseHandlers.add(locals);
     });
+    jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {

[ngeoffray, 2013/05/14 07:08:51]

If that's a simple switch, those continues should be to something out of the
switch right?

[Johnni Winther, 2013/05/17 07:03:04]

It should not happen: If simple, no continue should target [jumpHandler]. If
complex, the jump handler should have no targets.

Inserted an assertion instead.

+      instruction.block.addSuccessor(joinBlock);
+      caseHandlers.add(locals);
+    });
     if (!isAborted()) {
       current.close(new HGoto());
       lastOpenedBlock.addSuccessor(joinBlock);
       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);
@@ skipping 19 matching lines @@
     expressionStart.setBlockFlow(
         new HSwitchBlockInformation(expressionInfo,
                                     matchExpressions,
                                     statements,
                                     hasDefault,
                                     jumpHandler.target,
                                     jumpHandler.labels()),
         joinBlock);
 
     jumpHandler.close();
-    return true;
   }
 
   bool nonPrimitiveTypeOverridesEquals(Constant constant) {
     // Function values override equals. Even static ones, since
     // they inherit from [Function].
     if (constant.isFunction()) return true;
 
     // [Map] and [List] do not override equals.
     // If constant is primitive, just return false. We know
     // about the equals methods of num/String classes.
@@ skipping 19 matching lines @@
   }
 
   Element lookupOperator(ClassElement classElement, SourceString operatorName) {
     SourceString dartMethodName =
         Elements.constructOperatorName(operatorName, false);
     return classElement.lookupMember(dartMethodName);
   }
 
 
   // Recursively build an if/else structure to match the cases.
-  void buildSwitchCases(Link<Node> cases, HInstruction expression,
+  void buildSwitchCases(JumpHandler jumpHandler,
+                        Link<Node> cases, HInstruction expression,
+                        void buildSwitchCase(SwitchCase switchCase),
                         [int encounteredCaseTypes = 0]) {
     final int NO_TYPE = 0;
     final int INT_TYPE = 1;
     final int STRING_TYPE = 2;
     final int CONFLICT_TYPE = 3;
     int combine(int type1, int type2) => type1 | type2;
 
     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() {
-      visit(node.statements);
+      buildSwitchCase(node);
       if (!isAborted()) {
         compiler.reportWarning(node, 'Missing break at end of switch case');
         Element element =
             compiler.findHelper(const SourceString("getFallThroughError"));
         pushInvokeHelper0(element, HType.UNKNOWN);
         HInstruction error = pop();
         closeAndGotoExit(new HThrow(error));
       }
     }
 
     Link<Node> skipLabels(Link<Node> labelsAndCases) {
       while (!labelsAndCases.isEmpty && labelsAndCases.head is Label) {
         labelsAndCases = labelsAndCases.tail;
       }
       return labelsAndCases;
     }
 
     Link<Node> labelsAndCases = skipLabels(node.labelsAndCases.nodes);
     if (labelsAndCases.isEmpty) {
       // Default case with no expressions.
       if (!node.isDefaultCase) {
         compiler.internalError("Case with no expression and not default",
                                node: node);
       }
-      visit(node.statements);
+      buildSwitchCase(node);
       // This must be the final case (otherwise "default" would be invalid),
       // so we don't need to check for fallthrough.
       return;
     }
 
     // Recursively build the test conditions. Leaves the result on the
     // expression stack.
     void buildTests(Link<Node> remainingCases) {
       // Build comparison for one case expression.
       void left() {
@@ skipping 27 matching lines @@
     }
 
     if (node.isDefaultCase) {
       // Default case must be last.
       assert(cases.tail.isEmpty);
       // Perform the tests until one of them match, but then always execute the
       // statements.
       // TODO(lrn): Stop performing tests when all expressions are compile-time
       // constant strings or integers.
       handleIf(node, () { buildTests(labelsAndCases); }, (){}, null);
-      visit(node.statements);
+      buildSwitchCase(node);
     } else {
       if (cases.tail.isEmpty) {
         handleIf(node,
                  () { buildTests(labelsAndCases); },
-                 () { visit(node.statements); },
+                 () { buildSwitchCase(node); },
                  null);
       } else {
         handleIf(node,
                  () { buildTests(labelsAndCases); },
                  () { visitStatementsAndAbort(); },
-                 () { buildSwitchCases(cases.tail, expression,
+                 () { buildSwitchCases(jumpHandler, cases.tail, expression,
+                                       buildSwitchCase,
                                        encounteredCaseTypes); });
       }
     }
   }
 
   visitSwitchCase(SwitchCase node) {
     compiler.internalError('SsaBuilder.visitSwitchCase');
   }
 
   visitCaseMatch(CaseMatch node) {
@@ skipping 649 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;
   }
 }