Accept more labels per switch case.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 2932 matching lines @@
             new HSubGraphBlockInformation(new SubGraph(startBlock, lastBlock)),
             elements[node]),
         joinBlock);
     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() {
       visit(node.statements);
       if (!isAborted()) {
         compiler.reportWarning(node, 'Missing break at end of switch case');
         Element element =
             compiler.findHelper(const SourceString("getFallThroughError"));
         push(new HStatic(element));
         HInstruction error = new HInvokeStatic(
              Selector.INVOCATION_0, <HInstruction>[pop()]);
         add(error);
         close(new HThrow(error));
       }
     }
 
-    Link<Node> expressions = node.expressions.nodes;
-    if (expressions.isEmpty()) {
+    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);
       // 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> remainingExpressions) {
+    void buildTests(Link<Node> remainingCases) {
       // Build comparison for one case expression.
       void left() {
         Element equalsHelper = interceptors.getEqualsInterceptor();
         HInstruction target = new HStatic(equalsHelper);
         add(target);
-        visit(remainingExpressions.head);
+        CaseMatch match = remainingCases.head;
+        visit(match.expression);
         push(new HEquals(target, pop(), expression));
       }
 
       // If this is the last expression, just return it.
-      if (remainingExpressions.tail.isEmpty()) {
+      Link<Node> tail = skipLabels(remainingCases.tail);
+      if (tail.isEmpty()) {
         left();
         return;
       }
 
       void right() {
-        buildTests(remainingExpressions.tail);
+        buildTests(tail);
       }
       handleLogicalAndOr(left, right, isAnd: false);
     }
 
     if (node.isDefaultCase) {
-      buildTests(expressions);
-      // Throw away the test result. We always execute the default case.
-      pop();
+      // 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(() { buildTests(labelsAndCases); }, (){}, null);
       visit(node.statements);
     } else {
       if (cases.tail.isEmpty()) {
-        handleIf(() { buildTests(expressions); },
+        handleIf(() { buildTests(labelsAndCases); },
                  () { visit(node.statements); },
                  null);
       } else {
-        handleIf(() { buildTests(expressions); },
+        handleIf(() { buildTests(labelsAndCases); },
                  () { visitStatementsAndAbort(); },
                  () { buildSwitchCases(cases.tail, expression); });
       }
     }
   }
 
   visitSwitchCase(SwitchCase node) {
     unreachable();
   }
 
+  visitCaseMatch(CaseMatch node) {
+    unreachable();
+  }
+
   visitTryStatement(TryStatement node) {
     work.allowSpeculativeOptimization = false;
     HBasicBlock enterBlock = openNewBlock();
     HTry tryInstruction = new HTry();
     List<HBasicBlock> blocks = <HBasicBlock>[];
     blocks.add(close(tryInstruction));
 
     HBasicBlock tryBody = graph.addNewBlock();
     enterBlock.addSuccessor(tryBody);
     open(tryBody);
@@ skipping 276 matching lines @@
                                    <HInstruction>[target, input],
                                    HType.STRING));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }