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) {

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

I would prefer if this function's argument was named "token" as this is
generally the convention in the parser.

I think it would be cleaner if this wasn't a nested function, for several
reasons:

* You can follow the "token" convention without hiding anything.

* This function could be useful for an editor.

* Porting this to Java is annoying. Brian from the Editor team is currently
doing so and one of the reasons is that I have claimed the parser uses no
"fancy" features—fancy meaning "not in Java" ;-)

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

It's now a top-level function. I'll rename "peek" to "token".

+      Token pre = peek;

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

Unused variable?

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

Done.

+      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;

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

It is confusing that peekPastLabels has "peek" parameter and this temporary
exists.

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

It was actually deliberate. Alas, parameter is now "token".

+
+    /**
+     * Parse a group of labels, cases and possibly a default keyword and
+     * the statements that they select.
+     */
+    Token parseSwitchCase(Token token) {

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

This method is definitely something that I think a user of the parser would like
access to. So it is a problem that it is not a pure function (state in peek). I
would like to examine if it is possible to avoid that.

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

It's avoided, but at the cost of potentially peeking past the same labels twice.
It's expected that labels on cases are rare, and multiple labels even more so,
so it's probably not worth this overengineering to avoid it.

+      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) {
+        String value = peek.stringValue;
+        if (value === 'case' || value === 'default' ||
+            (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,
+                                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);
   }
 }