Accept more labels per switch case.

lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 1195 matching lines @@
       String labelName = node.target.source.slowToString();
       LabelElement label = statementScope.lookupLabel(labelName);
       if (label === null) {
         error(node.target, MessageKind.UNBOUND_LABEL, [labelName]);
         return;
       }
       target = label.target;
       if (!target.statement.isValidContinueTarget()) {
         error(node.target, MessageKind.INVALID_CONTINUE, [labelName]);
       }
+      // TODO(lrn): Handle continues to switch cases.
+      if (target.statement is SwitchCase) {
+        unimplemented(node, "continue to switch case");
+      }
       label.setContinueTarget();
       mapping[node.target] = label;
     }
     mapping[node] = target;
   }
 
   visitForIn(ForIn node) {
     visit(node.expression);
     Scope scope = new BlockScope(context);
     Node declaration = node.declaredIdentifier;
     visitIn(declaration, scope);
     visitLoopBodyIn(node, node.body, scope);
 
     // TODO(lrn): Also allow a single identifier.
     if ((declaration is !Send || declaration.asSend().selector is !Identifier)
         && (declaration is !VariableDefinitions ||
         !declaration.asVariableDefinitions().definitions.nodes.tail.isEmpty()))
     {
       // The variable declaration is either not an identifier, not a
       // declaration, or it's declaring more than one variable.
       error(node.declaredIdentifier, MessageKind.INVALID_FOR_IN, []);
     }
   }
 
+  visitLabel(Label node) {
+    // Labels are handled by their containing statements/cases.
+  }
+
   visitLabeledStatement(LabeledStatement node) {
     String labelName = node.label.slowToString();
     LabelElement existingElement = statementScope.lookupLabel(labelName);
     if (existingElement !== null) {
       warning(node.label, MessageKind.DUPLICATE_LABEL, [labelName]);
       warning(existingElement.label, MessageKind.EXISTING_LABEL, [labelName]);
     }
     Node body = node.getBody();
     TargetElement targetElement = getOrCreateTargetElement(body);
 
@@ skipping 26 matching lines @@
   }
 
   visitSwitchStatement(SwitchStatement node) {
     node.expression.accept(this);
 
     TargetElement breakElement = getOrCreateTargetElement(node);
     Map<String, LabelElement> continueLabels = <LabelElement>{};
     Link<Node> cases = node.cases.nodes;
     while (!cases.isEmpty()) {
       SwitchCase switchCase = cases.head;
-      if (switchCase.label !== null) {
-        Label label = switchCase.label;
+      for (Node labelOrCase in switchCase.labelsAndCases) {
+        if (labelOrCase is! Label) continue;
+        Label label = labelOrCase;
         String labelName = label.slowToString();
 
         LabelElement existingElement = continueLabels[labelName];
         if (existingElement !== null) {
           // It's an error if the same label occurs twice in the same switch.
           warning(label, MessageKind.DUPLICATE_LABEL, [labelName]);
           error(existingElement.label, MessageKind.EXISTING_LABEL, [labelName]);
         } else {
           // It's only a warning if it shadows another label.
           existingElement = statementScope.lookupLabel(labelName);
@@ skipping 10 matching lines @@
                               enclosingElement);
         mapping[switchCase] = targetElement;
 
         LabelElement labelElement =
             new LabelElement(label, labelName,
                              targetElement, enclosingElement);
         mapping[label] = labelElement;
         continueLabels[labelName] = labelElement;
       }
       cases = cases.tail;
+      // Test that only the last case, if any, is a default case.
       if (switchCase.defaultKeyword !== null && !cases.isEmpty()) {
         error(switchCase, MessageKind.INVALID_CASE_DEFAULT);
       }
     }
+
     statementScope.enterSwitch(breakElement, continueLabels);
     node.cases.accept(this);
     statementScope.exitSwitch();
 
-    // Clean-up unused labels
+    // Clean-up unused labels.
     continueLabels.forEach((String key, LabelElement label) {
-      TargetElement targetElement = label.target;
-      SwitchCase switchCase = targetElement.statement;
       if (!label.isContinueTarget) {
+        TargetElement targetElement = label.target;
+        SwitchCase switchCase = targetElement.statement;
         mapping.remove(switchCase);
         mapping.remove(label.label);
       }
     });
   }
 
   visitSwitchCase(SwitchCase node) {
-    // The label was handled in [visitSwitchStatement(SwitchStatement)].
-    node.expressions.accept(this);
+    node.labelsAndCases.accept(this);
     visitIn(node.statements, new BlockScope(context));
   }
 
+  visitCaseMatch(CaseMatch node) {
+    visit(node.expression);
+  }
+
   visitTryStatement(TryStatement node) {
     visit(node.tryBlock);
     if (node.catchBlocks.isEmpty() && node.finallyBlock == null) {
       // TODO(ngeoffray): The precise location is
       // node.getEndtoken.next. Adjust when issue #1581 is fixed.
       error(node, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
   }
@@ skipping 573 matching lines @@
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
 }