Accept more labels per switch case.

lib/compiler/implementation/scanner/parser.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.
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list (aka a token stream).
  *
  * The class [Scanner] is used to generate a token stream. See the
  * file scanner.dart.
@@ skipping 833 matching lines @@
 
   Token parseLabel(Token token) {
     token = parseIdentifier(token);
     Token colon = token;
     token = expect(':', token);
     listener.handleLabel(colon);
     return token;
   }
 
   Token parseLabeledStatement(Token token) {
-    listener.beginLabeledStatement(token);
-    token = parseLabel(token);
+    int labelCount = 0;
+    do {
+      token = parseLabel(token);
+      labelCount++;
+    } while (isIdentifier(token) && optional(':', token.next));
+    listener.beginLabeledStatement(token, labelCount);
     token = parseStatement(token);
-    listener.endLabeledStatement();
+    listener.endLabeledStatement(labelCount);
     return token;
   }
 
   Token parseExpressionStatement(Token token) {
     listener.beginExpressionStatement(token);
     token = parseExpression(token);
     listener.endExpressionStatement(token);
     return expectSemicolon(token);
   }
 
@@ skipping 679 matching lines @@
     assert(optional('switch', token));
     Token switchKeyword = token;
     listener.beginSwitchStatement(switchKeyword);
     token = parseParenthesizedExpression(token.next);
     token = parseSwitchBlock(token);
     listener.endSwitchStatement(switchKeyword, token);
     return token.next;
   }
 
   Token parseSwitchBlock(Token token) {
+    /**
+     * Peek after the following labels (if any). The following token
+     * is used to determine if the labels belong to a statement or a
+     * switch case.
+     */
+    Token peekPastLabels(Token peek) {
+      Token pre = peek;
+      while (isIdentifier(peek) && optional(':', peek.next)) {
+        peek = peek.next.next;
+      }
+      return peek;
+    }
+
+    // When entering or leaving [parseSwitchCase], peek points to the first
+    // token that isn't a label.
+    Token peek;
+
+    /**
+     * Parse a group of labels, cases and possibly a default keyword and
+     * the statements that they select.
+     */
+    Token parseSwitchCase(Token token) {
+      Token begin = token;
+      Token defaultKeyword = null;
+      int expressionCount = 0;
+      int labelCount = 0;
+
+      while (true) {
+        // Loop until we find something that can't be part of a switch case.
+        String value = peek.stringValue;
+        if (value === 'default') {
+          while (token !== peek) {
+            token = parseLabel(token);
+            labelCount++;
+          }
+          defaultKeyword = token;
+          token = expect(':', token.next);
+          peek = token;
+          break;
+        } else if (value === 'case') {
+          while (token !== peek) {
+            token = parseLabel(token);
+            labelCount++;
+          }
+          Token caseKeyword = token;
+          token = parseExpression(token.next);
+          Token colonToken = token;
+          token = expect(':', token);
+          listener.handleCaseMatch(caseKeyword, colonToken);
+          expressionCount++;
+          peek = peekPastLabels(token);
+        } else {
+          break;
+        }
+      }
+      // Finally zero or more statements.
+      int statementCount = 0;
+      while (token.kind !== EOF_TOKEN) {

[ahe, 2012/05/14 09:31:24]

I dont' think the parser reports errors for this:

main() {
  switch (1) {
  case 1:
    foo();
// EOF

[Lasse Reichstein Nielsen, 2012/05/14 10:34:58]

It generates an "unbalanced '{'" error.

+        String value = peek.stringValue;
+        if (value === 'case' || value === 'default' ||

[ahe, 2012/05/14 09:31:24]

Please add parentheses around these expressions. I cannot read short-circuit
boolean expressions without them.

[Lasse Reichstein Nielsen, 2012/05/14 10:34:58]

Done.
Maybe putting them on separate lines is better?
I find it harder to read with too many parentheses.

[ahe, 2012/05/14 10:44:09]

Seriously: I do not understand what it means. This is not about readability, I
do not understand the code without parentheses.

+            (value === '}' && token === peek)) {
+          // A label just before "}" will be handled as a statement error.
+          break;
+        } else {
+          token = parseStatement(token);
+        }
+        statementCount++;
+        peek = peekPastLabels(token);
+      }
+      listener.handleSwitchCase(labelCount, expressionCount, defaultKeyword,

[ahe, 2012/05/14 09:31:24]

Should labelCount and expressionCount be added together?

[Lasse Reichstein Nielsen, 2012/05/14 10:34:58]

I prefer letting the listener decide that.

+                                statementCount, begin, token);
+      return token;
+    }
+
     Token begin = token;
     listener.beginSwitchBlock(begin);
     token = expect('{', token);
     int caseCount = 0;
+    peek = peekPastLabels(token);
     while (token.kind !== EOF_TOKEN) {
       if (optional('}', token)) {
         break;
       }
       token = parseSwitchCase(token);
       ++caseCount;
     }
     listener.endSwitchBlock(caseCount, begin, token);
     expect('}', token);
     return token;
   }
 
-  Token parseSwitchCase(Token token) {
-    Token begin = token;
-    Token defaultKeyword = null;
-    Token label = null;
-    // First an optional label.
-    if (isIdentifier(token)) {
-      label = token;
-      token = parseLabel(token);
-    }
-    // Then one or more case expressions, the last of which may be
-    // 'default' instead.
-    int expressionCount = 0;
-    {
-      String value = token.stringValue;
-      do {
-        if (value === 'default') {
-          defaultKeyword = token;
-          token = expect(':', token.next);
-          break;
-        }
-        token = expect('case', token);
-        token = parseExpression(token);
-        token = expect(':', token);
-        expressionCount++;
-        value = token.stringValue;
-      } while (value === 'case' || value === 'default');
-    }
-    // Finally zero or more statements.
-    int statementCount = 0;
-    while (token.kind !== EOF_TOKEN) {
-      String value;
-      if (isIdentifier(token) && optional(':', token.next)) {
-        // Skip label.
-        value = token.next.next.stringValue;
-      } else {
-        value = token.stringValue;
-      }
-      if (value === 'case' || value === 'default' || value === '}') {
-        break;
-      } else {
-        token = parseStatement(token);
-        ++statementCount;
-      }
-    }
-    listener.handleSwitchCase(label, expressionCount, defaultKeyword,
-                              statementCount, begin, token);
-    return token;
-  }
 
   Token parseBreakStatement(Token token) {
     assert(optional('break', token));
     Token breakKeyword = token;
     token = token.next;
     bool hasTarget = false;
     if (isIdentifier(token)) {
       token = parseIdentifier(token);
       hasTarget = true;
     }
@@ skipping 12 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }