enhance analyzer to parse uppercase and built-in/pseudo keywords

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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.
 
 library analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 140 matching lines @@
       return true;
     }
     return needsSpace;
   }
 }
 
 /**
  * A parser used to parse tokens into an AST structure.
  */
 class Parser {
-  static String ASYNC = "async";
+  static String ASYNC = Keyword.ASYNC.syntax;
 
-  static String _AWAIT = "await";
+  static String _AWAIT = Keyword.AWAIT.syntax;
 
-  static String _HIDE = "hide";
+  static String _HIDE = Keyword.HIDE.syntax;
 
-  static String _OF = "of";
+  static String _SHOW = Keyword.SHOW.syntax;
 
-  static String _ON = "on";
+  static String SYNC = Keyword.SYNC.syntax;
 
-  static String _NATIVE = "native";
-
-  static String _SHOW = "show";
-
-  static String SYNC = "sync";
-
-  static String _YIELD = "yield";
+  static String _YIELD = Keyword.YIELD.syntax;
 
   /**
    * The source being parsed.
    */
   final Source _source;
 
   /**
    * The error listener that will be informed of any errors that are found
    * during the parse.
    */
@@ skipping 994 matching lines @@
       }
     }
     if (withClause != null && extendsClause == null) {
       _reportErrorForToken(
           ParserErrorCode.WITH_WITHOUT_EXTENDS, withClause.withKeyword);
     }
     //
     // Look for and skip over the extra-lingual 'native' specification.
     //
     NativeClause nativeClause = null;
-    if (_matchesString(_NATIVE) && _tokenMatches(_peek(), TokenType.STRING)) {
+    if (_matchesKeyword(Keyword.NATIVE) &&
+        _tokenMatches(_peek(), TokenType.STRING)) {
       nativeClause = _parseNativeClause();
     }
     //
     // Parse the body of the class.
     //
     Token leftBracket = null;
     List<ClassMember> members = null;
     Token rightBracket = null;
     if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
       leftBracket = getAndAdvance();
@@ skipping 376 matching lines @@
 
   /**
    * Parse a single combinator. Return the combinator that was parsed, or `null`
    * if no combinator is found.
    *
    *     combinator ::=
    *         'show' identifier (',' identifier)*
    *       | 'hide' identifier (',' identifier)*
    */
   Combinator parseCombinator() {
-    if (_matchesString(_SHOW)) {
+    if (_matchesKeyword(Keyword.SHOW)) {
       return astFactory.showCombinator(getAndAdvance(), parseIdentifierList());
-    } else if (_matchesString(_HIDE)) {
+    } else if (_matchesKeyword(Keyword.HIDE)) {
       return astFactory.hideCombinator(getAndAdvance(), parseIdentifierList());
     }
     return null;
   }
 
   /**
    * Parse a list of combinators in a directive. Return the combinators that
    * were parsed, or `null` if there are no combinators.
    *
    *     combinator ::=
@@ skipping 308 matching lines @@
                   ParserErrorCode.MULTIPLE_LIBRARY_DIRECTIVES);
             } else {
               if (directives.length > 0) {
                 _reportErrorForCurrentToken(
                     ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST);
               }
               libraryDirectiveFound = true;
             }
             return parseLibraryDirective(commentAndMetadata);
           } else if (keyword == Keyword.PART) {
-            if (_tokenMatchesString(_peek(), _OF)) {
+            if (_tokenMatchesKeyword(_peek(), Keyword.OF)) {
               partOfDirectiveFound = true;
               return _parsePartOfDirective(commentAndMetadata);
             } else {
               partDirectiveFound = true;
               return _parsePartDirective(commentAndMetadata);
             }
           } else {
             // Internal error: this method should not have been invoked if the
             // current token was something other than one of the above.
             throw new StateError(
@@ skipping 1022 matching lines @@
    *
    *     forInitializerStatement ::=
    *         localVariableDeclaration ';'
    *       | expression? ';'
    */
   Statement parseForStatement() {
     bool wasInLoop = _inLoop;
     _inLoop = true;
     try {
       Token awaitKeyword = null;
-      if (_matchesString(_AWAIT)) {
+      if (_matchesKeyword(Keyword.AWAIT)) {
         awaitKeyword = getAndAdvance();
       }
       Token forKeyword = _expectKeyword(Keyword.FOR);
       Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
       VariableDeclarationList variableList = null;
       Expression initialization = null;
       if (!_matches(TokenType.SEMICOLON)) {
         CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
         if (_matchesIdentifier() &&
             (_tokenMatchesKeyword(_peek(), Keyword.IN) ||
@@ skipping 142 matching lines @@
       if (type == TokenType.SEMICOLON) {
         if (!mayBeEmpty) {
           _reportErrorForCurrentToken(emptyErrorCode);
         }
         return astFactory.emptyFunctionBody(getAndAdvance());
       }
       Token keyword = null;
       Token star = null;
       bool foundAsync = false;
       bool foundSync = false;
-      if (type == TokenType.IDENTIFIER) {
+      if (type == TokenType.KEYWORD) {
         String lexeme = _currentToken.lexeme;
         if (lexeme == ASYNC) {
           foundAsync = true;
           keyword = getAndAdvance();
           if (_matches(TokenType.STAR)) {
             star = getAndAdvance();
             _inGenerator = true;
           }
           type = _currentToken.type;
           _inAsync = true;
@@ skipping 40 matching lines @@
             _reportErrorForToken(
                 ParserErrorCode.MISSING_STAR_AFTER_SYNC, keyword);
           }
         }
         if (!_parseFunctionBodies) {
           _skipBlock();
           return astFactory
               .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON));
         }
         return astFactory.blockFunctionBody(keyword, star, parseBlock());
-      } else if (_matchesString(_NATIVE)) {
+      } else if (_matchesKeyword(Keyword.NATIVE)) {
         Token nativeToken = getAndAdvance();
         StringLiteral stringLiteral = null;
         if (_matches(TokenType.STRING)) {
           stringLiteral = _parseStringLiteralUnchecked();
         }
         return astFactory.nativeFunctionBody(
             nativeToken, stringLiteral, _expect(TokenType.SEMICOLON));
       } else {
         // Invalid function body
         _reportErrorForCurrentToken(emptyErrorCode);
@@ skipping 133 matching lines @@
    *     optionalPositionalParameterTypes ::=
    *         '[' normalParameterTypes ','? ']'
    *     namedParameterTypes ::=
    *         '{' typedIdentifier (',' typedIdentifier)* ','? '}'
    *     typedIdentifier ::=
    *         type identifier
    */
   GenericFunctionType parseGenericFunctionTypeAfterReturnType(
       TypeAnnotation returnType) {
     Token functionKeyword = null;
-    if (_matchesString('Function')) {
+    if (_matchesKeyword(Keyword.FUNCTION)) {
       functionKeyword = getAndAdvance();
     } else if (_matchesIdentifier()) {
       _reportErrorForCurrentToken(ParserErrorCode.NAMED_FUNCTION_TYPE);
     } else {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_FUNCTION_KEYWORD);
     }
     TypeParameterList typeParameters = null;
     if (_matches(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
@@ skipping 188 matching lines @@
     if (_matchesKeyword(Keyword.DEFERRED)) {
       deferredToken = getAndAdvance();
     }
     if (_matchesKeyword(Keyword.AS)) {
       asToken = getAndAdvance();
       prefix = parseSimpleIdentifier(isDeclaration: true);
     } else if (deferredToken != null) {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT);
     } else if (!_matches(TokenType.SEMICOLON) &&
-        !_matchesString(_SHOW) &&
-        !_matchesString(_HIDE)) {
+        !_matchesKeyword(Keyword.SHOW) &&
+        !_matchesKeyword(Keyword.HIDE)) {
       Token nextToken = _peek();
       if (_tokenMatchesKeyword(nextToken, Keyword.AS) ||
-          _tokenMatchesString(nextToken, _SHOW) ||
-          _tokenMatchesString(nextToken, _HIDE)) {
+          _tokenMatchesKeyword(nextToken, Keyword.SHOW) ||
+          _tokenMatchesKeyword(nextToken, Keyword.HIDE)) {
         _reportErrorForCurrentToken(
             ParserErrorCode.UNEXPECTED_TOKEN, [_currentToken]);
         _advance();
         if (_matchesKeyword(Keyword.AS)) {
           asToken = getAndAdvance();
           prefix = parseSimpleIdentifier(isDeclaration: true);
         }
       }
     }
     List<Combinator> combinators = parseCombinators();
@@ skipping 416 matching lines @@
     TokenType type = _currentToken.type;
     if (type == TokenType.OPEN_CURLY_BRACKET) {
       if (_tokenMatches(_peek(), TokenType.STRING)) {
         Token afterString = skipStringLiteral(_currentToken.next);
         if (afterString != null && afterString.type == TokenType.COLON) {
           return astFactory.expressionStatement(
               parseExpression2(), _expect(TokenType.SEMICOLON));
         }
       }
       return parseBlock();
-    } else if (type == TokenType.KEYWORD && !_currentToken.keyword.isBuiltIn) {
+    } else if (type == TokenType.KEYWORD &&
+        !_currentToken.keyword.isBuiltInOrPseudo) {
       Keyword keyword = _currentToken.keyword;
       // TODO(jwren) compute some metrics to figure out a better order for this
       // if-then sequence to optimize performance
       if (keyword == Keyword.ASSERT) {
         return parseAssertStatement();
       } else if (keyword == Keyword.BREAK) {
         return parseBreakStatement();
       } else if (keyword == Keyword.CONTINUE) {
         return parseContinueStatement();
       } else if (keyword == Keyword.DO) {
@@ skipping 95 matching lines @@
         return astFactory.expressionStatement(
             parseExpression2(), _expect(TokenType.SEMICOLON));
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT);
         return astFactory
             .emptyStatement(_createSyntheticToken(TokenType.SEMICOLON));
       }
-    } else if (_inGenerator && _matchesString(_YIELD)) {
+    } else if (_inGenerator && _matchesKeyword(Keyword.YIELD)) {
       return parseYieldStatement();
-    } else if (_inAsync && _matchesString(_AWAIT)) {
+    } else if (_inAsync && _matchesKeyword(Keyword.AWAIT)) {
       if (_tokenMatchesKeyword(_peek(), Keyword.FOR)) {
         return parseForStatement();
       }
       return astFactory.expressionStatement(
           parseExpression2(), _expect(TokenType.SEMICOLON));
-    } else if (_matchesString(_AWAIT) &&
+    } else if (_matchesKeyword(Keyword.AWAIT) &&
         _tokenMatchesKeyword(_peek(), Keyword.FOR)) {
       Token awaitToken = _currentToken;
       Statement statement = parseForStatement();
       if (statement is! ForStatement) {
         _reportErrorForToken(
             CompileTimeErrorCode.ASYNC_FOR_IN_WRONG_CONTEXT, awaitToken);
       }
       return statement;
     } else if (type == TokenType.SEMICOLON) {
       return parseEmptyStatement();
@@ skipping 172 matching lines @@
    *
    * This method assumes that the current token matches `Keyword.PART`.
    *
    *     partDirective ::=
    *         metadata 'part' stringLiteral ';'
    *
    *     partOfDirective ::=
    *         metadata 'part' 'of' identifier ';'
    */
   Directive parsePartOrPartOfDirective(CommentAndMetadata commentAndMetadata) {
-    if (_tokenMatchesString(_peek(), _OF)) {
+    if (_tokenMatchesKeyword(_peek(), Keyword.OF)) {
       return _parsePartOfDirective(commentAndMetadata);
     }
     return _parsePartDirective(commentAndMetadata);
   }
 
   /**
    * Parse a postfix expression. Return the postfix expression that was parsed.
    *
    *     postfixExpression ::=
    *         assignableExpression postfixOperator
@@ skipping 651 matching lines @@
    *         'catch' '(' identifier (',' identifier)? ')'
    *
    *     finallyPart ::=
    *         'finally' block
    */
   Statement parseTryStatement() {
     Token tryKeyword = getAndAdvance();
     Block body = _parseBlockChecked();
     List<CatchClause> catchClauses = <CatchClause>[];
     Block finallyClause = null;
-    while (_matchesString(_ON) || _matchesKeyword(Keyword.CATCH)) {
+    while (_matchesKeyword(Keyword.ON) || _matchesKeyword(Keyword.CATCH)) {
       Token onKeyword = null;
       TypeName exceptionType = null;
-      if (_matchesString(_ON)) {
+      if (_matchesKeyword(Keyword.ON)) {
         onKeyword = getAndAdvance();
         exceptionType = parseTypeAnnotation(false);
       }
       Token catchKeyword = null;
       Token leftParenthesis = null;
       SimpleIdentifier exceptionParameter = null;
       Token comma = null;
       SimpleIdentifier stackTraceParameter = null;
       Token rightParenthesis = null;
       if (_matchesKeyword(Keyword.CATCH)) {
@@ skipping 239 matching lines @@
         _reportErrorForCurrentToken(
             ParserErrorCode.INVALID_OPERATOR_FOR_SUPER, [operator.lexeme]);
         return astFactory.prefixExpression(
             operator, astFactory.superExpression(getAndAdvance()));
       }
       return astFactory.prefixExpression(
           operator, _parseAssignableExpressionNotStartingWithSuper(false));
     } else if (type == TokenType.PLUS) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
       return createSyntheticIdentifier();
-    } else if (_inAsync && _matchesString(_AWAIT)) {
+    } else if (_inAsync && _matchesKeyword(Keyword.AWAIT)) {
       return parseAwaitExpression();
     }
     return parsePostfixExpression();
   }
 
   /**
    * Parse a variable declaration. Return the variable declaration that was
    * parsed.
    *
    *     variableDeclaration ::=
@@ skipping 432 matching lines @@
     } else {
       buffer.write(Character.toChars(codePoint));
     }
   }
 
   /**
    * Return `true` if we are positioned at the keyword 'Function' in a generic
    * function type alias.
    */
   bool _atGenericFunctionTypeAfterReturnType(Token startToken) {
-    if (_tokenMatchesString(startToken, 'Function')) {
+    if (_tokenMatchesKeyword(startToken, Keyword.FUNCTION)) {
       Token next = startToken.next;
       if (next != null &&
           (_tokenMatches(next, TokenType.OPEN_PAREN) ||
               _tokenMatches(next, TokenType.LT))) {
         return true;
       }
     }
     return false;
   }
 
@@ skipping 547 matching lines @@
    */
   bool _matchesIdentifier() => _tokenMatchesIdentifier(_currentToken);
 
   /**
    * Return `true` if the current token matches the given [keyword].
    */
   bool _matchesKeyword(Keyword keyword) =>
       _tokenMatchesKeyword(_currentToken, keyword);
 
   /**
-   * Return `true` if the current token matches the given [identifier].
-   */
-  bool _matchesString(String identifier) =>
-      _currentToken.type == TokenType.IDENTIFIER &&
-      _currentToken.lexeme == identifier;
-
-  /**
    * Report an error with the given [errorCode] if the given [typeName] has been
    * marked as nullable.
    */
   void _mustNotBeNullable(TypeName typeName, ParserErrorCode errorCode) {
     if (typeName.question != null) {
       _reportErrorForToken(errorCode, typeName.question);
     }
   }
 
   /**
@@ skipping 1704 matching lines @@
   /**
    * Return `true` if the given [token] matches the given [keyword].
    */
   bool _tokenMatchesKeyword(Token token, Keyword keyword) =>
       token.keyword == keyword;
 
   /**
    * Return `true` if the given [token] matches a pseudo keyword.
    */
   bool _tokenMatchesPseudoKeyword(Token token) =>
-      token.keyword?.isBuiltIn ?? false;
-
-  /**
-   * Return `true` if the given [token] matches the given [identifier].
-   */
-  bool _tokenMatchesString(Token token, String identifier) =>
-      token.type == TokenType.IDENTIFIER && token.lexeme == identifier;
+      token.keyword?.isBuiltInOrPseudo ?? false;
 
   /**
    * Translate the characters at the given [index] in the given [lexeme],
    * appending the translated character to the given [buffer]. The index is
    * assumed to be valid.
    */
   int _translateCharacter(StringBuffer buffer, String lexeme, int index) {
     int currentChar = lexeme.codeUnitAt(index);
     if (currentChar != 0x5C) {
       buffer.writeCharCode(currentChar);
@@ skipping 484 matching lines @@
     }
     if (modifiers.finalKeyword != null) {
       _reportErrorForToken(
           ParserErrorCode.FINAL_TYPEDEF, modifiers.finalKeyword);
     }
     if (modifiers.varKeyword != null) {
       _reportErrorForToken(ParserErrorCode.VAR_TYPEDEF, modifiers.varKeyword);
     }
   }
 }