Improve handling of built-in identifiers.

dart/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 189 matching lines @@
     } else {
       return expect(']', token);
     }
   }
 
   Token parseTypeOpt(Token token) {
     String value = token.stringValue;
     if (value === 'var') return parseType(token);
     if (value !== 'this') {
       Token peek = peekAfterExpectedType(token);
-      if (isIdentifier(peek) || optional('this', peek)) {
+      if (peek.isIdentifier() || optional('this', peek)) {
         return parseType(token);
       }
     }
     listener.handleNoType(token);
     return token;
   }
 
-  bool isIdentifier(Token token) => token.isIdentifier();
+  bool isValidTypeReference(Token token) {
+    final kind = token.kind;
+    if (kind === IDENTIFIER_TOKEN) return true;
+    if (kind === KEYWORD_TOKEN) {
+      Keyword keyword = token.value;
+      String value = keyword.stringValue;
+      return (keyword.isPseudo) || (value === 'Dynamic') || (value === 'void');

[ngeoffray, 2012/09/10 16:20:54]

No need for parens in keyword.isPseudo

+    }
+    return false;
+  }
 
   Token parseDefaultClauseOpt(Token token) {
     if (isDefaultKeyword(token)) {
       // TODO(ahe): Remove support for 'factory' in this position.
       Token defaultKeyword = token;
       listener.beginDefaultClause(defaultKeyword);
       token = parseIdentifier(token.next);
       token = parseQualifiedRestOpt(token);
       token = parseTypeVariablesOpt(token);
       listener.endDefaultClause(defaultKeyword);
@@ skipping 67 matching lines @@
   Token parseStringPart(Token token) {
     if (token.kind === STRING_TOKEN) {
       listener.handleStringPart(token);
       return token.next;
     } else {
       return listener.expected('string', token);
     }
   }
 
   Token parseIdentifier(Token token) {
-    if (isIdentifier(token)) {
+    if (token.isIdentifier()) {
       listener.handleIdentifier(token);
     } else {
       listener.expectedIdentifier(token);
     }
     return token.next;
   }
 
   Token expect(String string, Token token) {
     if (string !== token.stringValue) {
       return listener.expected(string, token);
@@ skipping 17 matching lines @@
    * Returns true if the stringValue of the [token] is [value].
    */
   bool optional(String value, Token token) => value === token.stringValue;
 
   bool notEofOrValue(String value, Token token) {
     return token.kind !== EOF_TOKEN && value !== token.stringValue;
   }
 
   Token parseType(Token token) {
     Token begin = token;
-    if (isIdentifier(token)) {
+    if (isValidTypeReference(token)) {
       token = parseIdentifier(token);
       token = parseQualifiedRestOpt(token);
     } else {
       token = listener.expectedType(token);
     }
     token = parseTypeArgumentsOpt(token);
     listener.endType(begin, token);
     return token;
   }
 
@@ skipping 41 matching lines @@
     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 = peekAfterExpectedType(token);
-    if (isIdentifier(peek)) {
+    if (peek.isIdentifier()) {
       // 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.
       final String value = token.stringValue;
@@ skipping 123 matching lines @@
     }
     listener.handleModifiers(count);
     return token;
   }
 
   Token peekAfterType(Token token) {
     // TODO(ahe): Also handle var?
     // We are looking at "identifier ...".
     Token peek = token.next;
     if (peek.kind === PERIOD_TOKEN) {
-      if (isIdentifier(peek.next)) {
+      if (peek.next.isIdentifier()) {
         // 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)) {
+    if ('void' !== token.stringValue && !token.isIdentifier()) {
       return listener.expectedType(token);
     }
     return peekAfterType(token);
   }
 
   Token parseClassBody(Token token) {
     Token begin = token;
     listener.beginClassBody(token);
     if (!optional('{', token)) {
       token = listener.expectedClassBody(token);
@@ skipping 11 matching lines @@
   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 = peekAfterExpectedType(token);
-        if (isGetOrSet(peek) && isIdentifier(peek.next)) {
+        if (isGetOrSet(peek) && peek.next.isIdentifier()) {
           // For example: get<T> get identifier
           return peek;
         }
       } else {
         // For example: get ...
-        if (isGetOrSet(token.next) && isIdentifier(token.next.next)) {
+        if (isGetOrSet(token.next) && token.next.next.isIdentifier()) {
           // For example: get get identifier
           return token.next;
         } else {
           // For example: get identifier
           return token;
         }
       }
     } else if (token.stringValue !== 'operator') {
       final Token peek = peekAfterExpectedType(token);
-      if (isGetOrSet(peek) && isIdentifier(peek.next)) {
+      if (isGetOrSet(peek) && peek.next.isIdentifier()) {
         // type? get identifier
         return peek;
       }
     }
     return null;
   }
 
   Token parseMember(Token token) {
     token = parseMetadataStar(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 = peekAfterExpectedType(token);
-    if (isIdentifier(peek) && token.stringValue !== 'operator') {
+    if (peek.isIdentifier() && token.stringValue !== 'operator') {
       // Skip type.
       token = peek;
     }
     if (token === getOrSet) token = token.next;
     if (optional('operator', token)) {
       token = parseOperatorName(token);
     } else {
       token = parseIdentifier(token);
     }
     bool isField;
@@ skipping 204 matching lines @@
     } 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)) {
+    } else if (token.isIdentifier()) {
       return parseExpressionStatementOrDeclaration(token);
     } else {
       return parseExpressionStatement(token);
     }
   }
 
   Token parseReturnStatement(Token token) {
     Token begin = token;
     listener.beginReturnStatement(begin);
     assert('return' === token.stringValue);
     token = token.next;
     if (optional(';', token)) {
       listener.endReturnStatement(false, begin, token);
     } else {
       token = parseExpression(token);
       listener.endReturnStatement(true, begin, token);
     }
     return expectSemicolon(token);
   }
 
   Token peekIdentifierAfterType(Token token) {
     Token peek = peekAfterType(token);
-    if (peek !== null && isIdentifier(peek)) {
+    if (peek !== null && peek.isIdentifier()) {
       // 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)) {
+    } else if (token.isIdentifier()) {
       // We are looking at "identifier".
       return token;
     } else {
       return null;
     }
   }
 
   Token parseExpressionStatementOrDeclaration(Token token) {
-    assert(isIdentifier(token) || token.stringValue === 'void');
+    assert(token.isIdentifier() || token.stringValue === 'void');
     Token identifier = peekIdentifierAfterType(token);
     if (identifier !== null) {
-      assert(isIdentifier(identifier));
+      assert(identifier.isIdentifier());
       Token afterId = identifier.next;
       int afterIdKind = afterId.kind;
       if (afterIdKind === EQ_TOKEN ||
           afterIdKind === SEMICOLON_TOKEN ||
           afterIdKind === COMMA_TOKEN) {
         // We are looking at "type identifier" followed by '=', ';', ','.
         return parseVariablesDeclaration(token);
       } else if (afterIdKind === OPEN_PAREN_TOKEN) {
         // We are looking at "type identifier '('".
         BeginGroupToken beginParen = afterId;
@@ skipping 20 matching lines @@
     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));
+      assert(identifier.isIdentifier());
       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;
     do {
       token = parseLabel(token);
       labelCount++;
-    } while (isIdentifier(token) && optional(':', token.next));
+    } while (token.isIdentifier() && optional(':', token.next));
     listener.beginLabeledStatement(token, labelCount);
     token = parseStatement(token);
     listener.endLabeledStatement(labelCount);
     return token;
   }
 
   Token parseExpressionStatement(Token token) {
     listener.beginExpressionStatement(token);
     token = parseExpression(token);
     listener.endExpressionStatement(token);
@@ skipping 79 matching lines @@
     return token;
   }
 
   Token parseCascadeExpression(Token token) {
     listener.beginCascade(token);
     assert(optional('..', token));
     Token cascadeOperator = token;
     token = token.next;
     if (optional('[', token)) {
       token = parseArgumentOrIndexStar(token);
-    } else if (isIdentifier(token)) {
+    } else if (token.isIdentifier()) {
       token = parseSend(token);
       listener.handleBinaryExpression(cascadeOperator);
     } else {
       return listener.unexpected(token);
     }
     Token mark;
     do {
       mark = token;
       if (optional('.', token)) {
         Token period = token;
@@ skipping 95 matching lines @@
       } else if (value === 'this') {
         return parseThisExpression(token);
       } else if (value === 'super') {
         return parseSuperExpression(token);
       } else if (value === 'new') {
         return parseNewExpression(token);
       } else if (value === 'const') {
         return parseConstExpression(token);
       } else if (value === 'void') {
         return parseFunctionExpression(token);
-      } else if (isIdentifier(token)) {
+      } else if (token.isIdentifier()) {
         return parseSendOrFunctionLiteral(token);
       } else {
         return listener.expectedExpression(token);
       }
     } else if (kind === OPEN_PAREN_TOKEN) {
       return parseParenthesizedExpressionOrFunctionLiteral(token);
     } else if ((kind === LT_TOKEN) ||
                (kind === OPEN_SQUARE_BRACKET_TOKEN) ||
                (kind === OPEN_CURLY_BRACKET_TOKEN) ||
                token.stringValue === '[]') {
@@ skipping 380 matching lines @@
   Token parseVariablesDeclarationOrExpressionOpt(Token token) {
     final String value = token.stringValue;
     if (value === ';') {
       listener.handleNoExpression(token);
       return token;
     } else if ((value === 'var') || (value === 'final')) {
       return parseVariablesDeclarationNoSemicolon(token);
     }
     Token identifier = peekIdentifierAfterType(token);
     if (identifier !== null) {
-      assert(isIdentifier(identifier));
+      assert(identifier.isIdentifier());
       Token afterId = identifier.next;
       int afterIdKind = afterId.kind;
       if (afterIdKind === EQ_TOKEN || afterIdKind === SEMICOLON_TOKEN ||
           afterIdKind === COMMA_TOKEN || optional('in', afterId)) {
         return parseVariablesDeclarationNoSemicolon(token);
       }
     }
     return parseExpression(token);
   }
 
@@ skipping 144 matching lines @@
     expect('}', token);
     return 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 token) {
-    while (isIdentifier(token) && optional(':', token.next)) {
+    while (token.isIdentifier() && optional(':', token.next)) {
       token = token.next.next;
     }
     return token;
   }
 
   /**
    * Parse a group of labels, cases and possibly a default keyword and
    * the statements that they select.
    */
   Token parseSwitchCase(Token token) {
@@ skipping 51 matching lines @@
     listener.handleSwitchCase(labelCount, 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)) {
+    if (token.isIdentifier()) {
       token = parseIdentifier(token);
       hasTarget = true;
     }
     listener.handleBreakStatement(hasTarget, breakKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseContinueStatement(Token token) {
     assert(optional('continue', token));
     Token continueKeyword = token;
     token = token.next;
     bool hasTarget = false;
-    if (isIdentifier(token)) {
+    if (token.isIdentifier()) {
       token = parseIdentifier(token);
       hasTarget = true;
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }