Accept more labels per switch case.

lib/compiler/implementation/tree/nodes.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 Visitor<R> {
   R visitBlock(Block node);
   R visitBreakStatement(BreakStatement node);
   R visitCascade(Cascade node);
   R visitCascadeReceiver(CascadeReceiver node);
+  R visitCaseMatch(CaseMatch node);
   R visitCatchBlock(CatchBlock node);
   R visitClassNode(ClassNode node);
   R visitConditional(Conditional node);
   R visitContinueStatement(ContinueStatement node);
   R visitDoWhile(DoWhile node);
   R visitEmptyStatement(EmptyStatement node);
   R visitExpressionStatement(ExpressionStatement node);
   R visitFor(For node);
   R visitForIn(ForIn node);
   R visitFunctionDeclaration(FunctionDeclaration node);
   R visitFunctionExpression(FunctionExpression node);
   R visitIdentifier(Identifier node);
   R visitIf(If node);
   R visitLabel(Label node);
   R visitLabeledStatement(LabeledStatement node);
   R visitLiteralBool(LiteralBool node);
   R visitLiteralDouble(LiteralDouble node);
   R visitLiteralInt(LiteralInt node);
   R visitLiteralList(LiteralList node);
   R visitLiteralMap(LiteralMap node);
   R visitLiteralMapEntry(LiteralMapEntry node);
   R visitLiteralNull(LiteralNull node);
   R visitLiteralString(LiteralString node);
-  R visitStringJuxtaposition(StringJuxtaposition node);
   R visitModifiers(Modifiers node);
   R visitNamedArgument(NamedArgument node);
   R visitNewExpression(NewExpression node);
   R visitNodeList(NodeList node);
   R visitOperator(Operator node);
   R visitParenthesizedExpression(ParenthesizedExpression node);
   R visitReturn(Return node);
   R visitScriptTag(ScriptTag node);
   R visitSend(Send node);
   R visitSendSet(SendSet node);
   R visitStringInterpolation(StringInterpolation node);
   R visitStringInterpolationPart(StringInterpolationPart node);
+  R visitStringJuxtaposition(StringJuxtaposition node);
   R visitSwitchCase(SwitchCase node);
   R visitSwitchStatement(SwitchStatement node);
   R visitThrow(Throw node);
   R visitTryStatement(TryStatement node);
   R visitTypeAnnotation(TypeAnnotation node);
   R visitTypedef(Typedef node);
   R visitTypeVariable(TypeVariable node);
   R visitVariableDefinitions(VariableDefinitions node);
   R visitWhile(While node);
 }
@@ skipping 50 matching lines @@
   }
 
   abstract Token getBeginToken();
 
   abstract Token getEndToken();
 
   Block asBlock() => null;
   BreakStatement asBreakStatement() => null;
   Cascade asCascade() => null;
   CascadeReceiver asCascadeReceiver() => null;
+  CaseMatch asCaseMatch() => null;
   CatchBlock asCatchBlock() => null;
   ClassNode asClassNode() => null;
   Conditional asConditional() => null;
   ContinueStatement asContinueStatement() => null;
   DoWhile asDoWhile() => null;
   EmptyStatement asEmptyStatement() => null;
   Expression asExpression() => null;
   ExpressionStatement asExpressionStatement() => null;
   For asFor() => null;
   ForIn asForIn() => null;
@@ skipping 1188 matching lines @@
   visitChildren(Visitor visitor) {
     parenthesizedExpression.accept(visitor);
     cases.accept(visitor);
   }
 
   Token getBeginToken() => switchKeyword;
 
   Token getEndToken() => cases.getEndToken();
 }
 
+class CaseMatch extends Node {
+  final Token caseKeyword;
+  final Expression expression;
+  final Token colonToken;
+  CaseMatch(this.caseKeyword, this.expression, this.colonToken);
+
+  CaseMatch asCaseMatch() => this;
+  Token getBeginToken() => caseKeyword;
+  Token getEndToken() => pattern.getEndToken().next();
+  accept(Visitor visitor) => visitor.visitCaseMatch(this);
+  visitChildren(Visitor visitor) => expression.accept(visitor);
+}
+
 class SwitchCase extends Node {
   // Represents the grammar:
-  //   label? ('case' expression ':')* ('default' ':')? statement*
-  // Each expression is collected in [expressions].
-  // The 'case' keywords can be obtained using [caseKeywords()].
+  //   (label | 'case' expression ':')* ('default' ':')? statement*
+  // The labels are collected in [labels].
+  // Each case patterns are collected in [cases].
+  // The default keyword, if present, is collected in [defaultKeyword].
   // Any actual switch case must have at least one 'case' or 'default'
   // clause.
-  final Label label;
-  final NodeList expressions;
+  // Notice: The labels and cases can occur interleaved in the source.
+  // They are separated here, since the order is irrelevant to the meaning
+  // of the switch.
+
+  /** List of [Identifier] of labels. */
+  final NodeList labels;
+  /** List of [CaseMatch] structures. */
+  final NodeList cases;
+  /** A "default" keyword token, if applicable. */
   final Token defaultKeyword;
+  /** List of statements, the body of the case. */
   final NodeList statements;
 
   final Token startToken;
 
-  SwitchCase(this.label, this.expressions, this.defaultKeyword,
+  SwitchCase(this.labels, this.cases, this.defaultKeyword,
              this.statements, this.startToken);
 
   SwitchCase asSwitchCase() => this;
 
   bool get isDefaultCase() => defaultKeyword !== null;
 
+  bool isValidContinueTarget() => true;
+
   accept(Visitor visitor) => visitor.visitSwitchCase(this);
 
   visitChildren(Visitor visitor) {
-    if (label !== null) label.accept(visitor);
-    expressions.accept(visitor);
+    labels.accept(visitor);
+    cases.accept(visitor);
     statements.accept(visitor);
   }
 
   Token getBeginToken() {
     return startToken;
   }
 
   Token getEndToken() {
     if (statements.nodes.isEmpty()) {
       // All cases must have at least one expression or be the default.
       if (defaultKeyword !== null) {
         // The colon after 'default'.
         return defaultKeyword.next;
       }
-      // The colon after the expression.
-      return expressions.getEndToken().next;
+      // The colon after the last expression.
+      return cases.getEndToken();
     } else {
       return statements.getEndToken();
     }
   }
-
-  Link<Token> caseKeywords() {
-    Token token = startToken;
-    if (label !== null) {
-      // Skip past the label: <Identifier> ':'.
-      token = token.next.next;
-    }
-    LinkBuilder<Token> builder = new LinkBuilder<Token>();
-    Link<Expression> link = expressions.nodes;
-    while (token.stringValue === 'case') {
-      assert(token.next === link.head.getBeginToken());
-      builder.addLast(token);
-      Token colon = link.head.getEndToken().next;
-      token = colon.next;
-      link = link.tail;
-    }
-    return builder.toLink();
-  }
 }
 
 class GotoStatement extends Statement {
-  final Identifier target;
+  final Label target;
   final Token keywordToken;
   final Token semicolonToken;
 
   GotoStatement(this.target, this.keywordToken, this.semicolonToken);
 
   visitChildren(Visitor visitor) {
     if (target !== null) target.accept(visitor);
   }
 
   Token getBeginToken() => keywordToken;
 
   Token getEndToken() => semicolonToken;
 
   // TODO(ahe): make class abstract instead of adding an abstract method.
   abstract accept(Visitor visitor);
 }
 
 class BreakStatement extends GotoStatement {
-  BreakStatement(Identifier target, Token keywordToken, Token semicolonToken)
+  BreakStatement(Label target, Token keywordToken, Token semicolonToken)
     : super(target, keywordToken, semicolonToken);
 
   BreakStatement asBreakStatement() => this;
 
   accept(Visitor visitor) => visitor.visitBreakStatement(this);
 }
 
 class ContinueStatement extends GotoStatement {
-  ContinueStatement(Identifier target, Token keywordToken, Token semicolonToken)
+  ContinueStatement(Label target, Token keywordToken, Token semicolonToken)
     : super(target, keywordToken, semicolonToken);
 
   ContinueStatement asContinueStatement() => this;
 
   accept(Visitor visitor) => visitor.visitContinueStatement(this);
 }
 
 class ForIn extends Loop {
   final Node declaredIdentifier;
   final Expression expression;
@@ skipping 272 matching lines @@
  * argument).
  *
  * TODO(ahe): This method is controversial, the team needs to discuss
  * if top-level methods are acceptable and what naming conventions to
  * use.
  */
 initializerDo(Node node, f(Node node)) {
   SendSet send = node.asSendSet();
   if (send !== null) return f(send.arguments.head);
 }