Const variable declarations accepted in the parser.

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 132 matching lines @@
       ++parameterCount;
     } while (optional(',', token));
     listener.endOptionalFormalParameters(parameterCount, begin, token);
     return expect(']', token);
   }
 
   Token parseTypeOpt(Token token) {
     String value = token.stringValue;
     if (value === 'var') return parseType(token);
     if (value !== 'this') {
-      Token peek = peekAfterType(token);
+      Token peek = peekAfterExpectedType(token);
       if (isIdentifier(peek) || optional('this', peek)) {
         return parseType(token);
       }
     }
     listener.handleNoType(token);
     return token;
   }
 
   bool isIdentifier(Token token) {
     final kind = token.kind;
@@ skipping 180 matching lines @@
     handleNoStuff(token);
     return token;
   }
 
   Token parseTopLevelMember(Token token) {
     Token start = token;
     listener.beginTopLevelMember(token);
     token = parseModifiers(token);
     Token getOrSet = findGetOrSet(token);
     if (token === getOrSet) token = token.next;
-    Token peek = peekAfterType(token);
+    Token peek = peekAfterExpectedType(token);
     if (isIdentifier(peek)) {
       // Skip type.
       token = peek;
     }
     if (token === getOrSet) token = token.next;
     token = parseIdentifier(token);
     bool isField;
     while (true) {
       // Loop to allow the listener to rewrite the token stream for
       // error handling.
@@ skipping 91 matching lines @@
     } else {
       listener.recoverableError("unexpected", token: token);
       return parseExpression(token);
     }
   }
 
   Token expectSemicolon(Token token) {
     return expect(';', token);
   }
 
+  bool isModifier(Token token) {
+    final String value = token.stringValue;
+    return ('final' === value) ||
+           ('var' === value) ||
+           ('const' === value) ||
+           ('abstract' === value) ||
+           ('static' === value) ||
+           ('external' === value);
+  }
+
   Token parseModifier(Token token) {
-    assert(('final' === token.stringValue) ||
-           ('var' === token.stringValue) ||
-           ('const' === token.stringValue) ||
-           ('abstract' === token.stringValue) ||
-           ('static' === token.stringValue) ||
-           ('external' === token.stringValue));
+    assert(isModifier(token));
     listener.handleModifier(token);
     return token.next;
   }
 
   Token parseModifiers(Token token) {
     int count = 0;
     while (token.kind === KEYWORD_TOKEN) {
-      final String value = token.stringValue;
-      if (('final' !== value) &&
-          ('var' !== value) &&
-          ('const' !== value) &&
-          ('abstract' !== value) &&
-          ('static' !== value) &&
-          ('external' !== value))
+      if (!isModifier(token))
         break;
       token = parseModifier(token);
       count++;
     }
     listener.handleModifiers(count);
     return token;
   }
 
   Token peekAfterType(Token token) {
     // TODO(ahe): Also handle var?
-    if ('void' !== token.stringValue && !isIdentifier(token)) {
-      listener.unexpected(token);
-    }
     // We are looking at "identifier ...".
     Token peek = token.next;
     if (peek.kind === PERIOD_TOKEN) {
       if (isIdentifier(peek.next)) {
         // Look past a library prefix.
         peek = peek.next.next;
       }
     }
     // We are looking at "qualified ...".
     if (peek.kind === LT_TOKEN) {
       // Possibly generic type.
       // We are looking at "qualified '<'".
       BeginGroupToken beginGroupToken = peek;
       Token gtToken = beginGroupToken.endGroup;
       if (gtToken !== null) {
         // We are looking at "qualified '<' ... '>' ...".
         return gtToken.next;
       }
     }
     return peek;
   }
 
+  /**
+   * Returns the token after the type which is expected to begin at [token].
+   * If [token] is not the start of a type, [Listener.unexpectedType] is called.
+   */
+  Token peekAfterExpectedType(Token token) {
+    if ('void' !== token.stringValue && !isIdentifier(token)) {
+      return listener.expectedType(token);
+    }
+    return peekAfterType(token);
+  }
+
   Token parseClassBody(Token token) {
     Token begin = token;
     listener.beginClassBody(token);
     if (!optional('{', token)) {
       token = listener.expectedClassBody(token);
     }
     token = token.next;
     int count = 0;
     while (notEofOrValue('}', token)) {
       token = parseMember(token);
       ++count;
     }
     listener.endClassBody(count, begin, token);
     return token;
   }
 
   bool isGetOrSet(Token token) {
     final String value = token.stringValue;
     return (value === 'get') || (value === 'set');
   }
 
   Token findGetOrSet(Token token) {
     if (isGetOrSet(token)) {
       if (optional('<', token.next)) {
         // For example: get<T> ...
-        final Token peek = peekAfterType(token);
+        final Token peek = peekAfterExpectedType(token);
         if (isGetOrSet(peek) && isIdentifier(peek.next)) {
           // For example: get<T> get identifier
           return peek;
         }
       } else {
         // For example: get ...
         if (isGetOrSet(token.next) && isIdentifier(token.next.next)) {
           // For example: get get identifier
           return token.next;
         } else {
           // For example: get identifier
           return token;
         }
       }
     } else if (token.stringValue !== 'operator') {
-      final Token peek = peekAfterType(token);
+      final Token peek = peekAfterExpectedType(token);
       if (isGetOrSet(peek) && isIdentifier(peek.next)) {
         // type? get identifier
         return peek;
       }
     }
     return null;
   }
 
   Token parseMember(Token token) {
     String value = token.stringValue;
     if (value === 'factory' ||
         (value === 'external' && optional('factory', token.next))) {
       return parseFactoryMethod(token);
     }
     Token start = token;
     listener.beginMember(token);
     token = parseModifiers(token);
     Token getOrSet = findGetOrSet(token);
     if (token === getOrSet) token = token.next;
-    Token peek = peekAfterType(token);
+    Token peek = peekAfterExpectedType(token);
     if (isIdentifier(peek) && token.stringValue !== 'operator') {
       // Skip type.
       token = peek;
     }
     if (token === getOrSet) token = token.next;
     if (optional('operator', token)) {
       token = parseOperatorName(token);
     } else {
       token = parseIdentifier(token);
     }
@@ skipping 190 matching lines @@
     } else if (value === 'try') {
       return parseTryStatement(token);
     } else if (value === 'switch') {
       return parseSwitchStatement(token);
     } else if (value === 'break') {
       return parseBreakStatement(token);
     } else if (value === 'continue') {
       return parseContinueStatement(token);
     } else if (value === ';') {
       return parseEmptyStatement(token);
+    } else if (value === 'const') {
+      return parseExpressionStatementOrConstDeclaration(token);
     } else if (isIdentifier(token)) {
       return parseExpressionStatementOrDeclaration(token);
     } else {
       return parseExpressionStatement(token);
     }
   }
 
   Token parseReturnStatement(Token token) {
     Token begin = token;
     listener.beginReturnStatement(begin);
@@ skipping 11 matching lines @@
   Token peekIdentifierAfterType(Token token) {
     Token peek = peekAfterType(token);
     if (peek !== null && isIdentifier(peek)) {
       // We are looking at "type identifier".
       return peek;
     } else {
       return null;
     }
   }
 
+  Token peekIdentifierAfterOptionalType(Token token) {
+    Token peek = peekIdentifierAfterType(token);
+    if (peek !== null) {
+      // We are looking at "type identifier".
+      return peek;
+    } else if (isIdentifier(token)) {
+      // We are looking at "identifier".
+      return token;
+    } else {
+      return null;
+    }
+  }
+
   Token parseExpressionStatementOrDeclaration(Token token) {
     assert(isIdentifier(token) || token.stringValue === 'void');
     Token identifier = peekIdentifierAfterType(token);
     if (identifier !== null) {
       assert(isIdentifier(identifier));
       Token afterId = identifier.next;
       int afterIdKind = afterId.kind;
       if (afterIdKind === EQ_TOKEN ||
           afterIdKind === SEMICOLON_TOKEN ||
           afterIdKind === COMMA_TOKEN) {
@@ skipping 18 matching lines @@
         BeginGroupToken begin = token.next;
         String afterParens = begin.endGroup.next.stringValue;
         if (afterParens === '{' || afterParens === '=>') {
           return parseFunctionDeclaration(token);
         }
       }
     }
     return parseExpressionStatement(token);
   }
 
+  Token parseExpressionStatementOrConstDeclaration(Token token) {
+    assert(token.stringValue === 'const');
+    if (isModifier(token.next)) {
+      return parseVariablesDeclaration(token);
+    }
+    Token identifier = peekIdentifierAfterOptionalType(token.next);
+    if (identifier !== null) {
+      assert(isIdentifier(identifier));
+      Token afterId = identifier.next;
+      int afterIdKind = afterId.kind;
+      if (afterIdKind === EQ_TOKEN ||
+          afterIdKind === SEMICOLON_TOKEN ||
+          afterIdKind === COMMA_TOKEN) {
+        // We are looking at "const type identifier" followed by '=', ';', or
+        // ','.
+        return parseVariablesDeclaration(token);
+      }
+      // Fall-through to expression statement.
+    }
+    return parseExpressionStatement(token);
+  }
+
   Token parseLabel(Token token) {
     token = parseIdentifier(token);
     Token colon = token;
     token = expect(':', token);
     listener.handleLabel(colon);
     return token;
   }
 
   Token parseLabeledStatement(Token token) {
     int labelCount = 0;
@@ skipping 333 matching lines @@
     token = parseExpression(token);
     Token colon = token;
     token = expect(':', token);
     token = parseExpression(token);
     listener.endLiteralMapEntry(colon, token);
     return token;
   }
 
   Token parseSendOrFunctionLiteral(Token token) {
     if (!mayParseFunctionExpressions) return parseSend(token);
-    Token peek = peekAfterType(token);
+    Token peek = peekAfterExpectedType(token);
     if (peek.kind === IDENTIFIER_TOKEN && isFunctionDeclaration(peek.next)) {
       return parseFunctionExpression(token);
     } else if (isFunctionDeclaration(token.next)) {
       return parseFunctionExpression(token);
     } else {
       return parseSend(token);
     }
   }
 
   bool isFunctionDeclaration(Token token) {
@@ skipping 508 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }