flatten Keyword into TokenType

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 = Keyword.ASYNC.syntax;
+  static String ASYNC = Keyword.ASYNC.lexeme;
 
-  static String _AWAIT = Keyword.AWAIT.syntax;
+  static String _AWAIT = Keyword.AWAIT.lexeme;
 
-  static String _HIDE = Keyword.HIDE.syntax;
+  static String _HIDE = Keyword.HIDE.lexeme;
 
-  static String _SHOW = Keyword.SHOW.syntax;
+  static String _SHOW = Keyword.SHOW.lexeme;
 
-  static String SYNC = Keyword.SYNC.syntax;
+  static String SYNC = Keyword.SYNC.lexeme;
 
-  static String _YIELD = Keyword.YIELD.syntax;
+  static String _YIELD = Keyword.YIELD.lexeme;
 
   static const int _MAX_TREE_DEPTH = 300;
 
   /**
    * The source being parsed.
    */
   final Source _source;
 
   /**
    * The error listener that will be informed of any errors that are found
@@ skipping 202 matching lines @@
       index = _translateCharacter(buffer, lexeme, index);
     }
     return buffer.toString();
   }
 
   /**
    * Return a synthetic identifier.
    */
   SimpleIdentifier createSyntheticIdentifier({bool isDeclaration: false}) {
     Token syntheticToken;
-    if (_currentToken.type == TokenType.KEYWORD) {
+    if (_currentToken.type.isKeyword) {
       // Consider current keyword token as an identifier.
       // It is not always true, e.g. "^is T" where "^" is place the place for
       // synthetic identifier. By creating SyntheticStringToken we can
       // distinguish a real identifier from synthetic. In the code completion
       // behavior will depend on a cursor position - before or on "is".
       syntheticToken = _injectToken(new SyntheticStringToken(
           TokenType.IDENTIFIER, _currentToken.lexeme, _currentToken.offset));
     } else {
       syntheticToken = _createSyntheticToken(TokenType.IDENTIFIER);
     }
@@ skipping 173 matching lines @@
     }
     // It is OK to parse as a variable declaration in these cases:
     //     String v }
     //     String v if (true) print('OK');
     //     String v { print(42); }
     // ...but not in these cases:
     //     get getterName {
     //     String get getterName
     if (allowAdditionalTokens) {
       if (type == TokenType.CLOSE_CURLY_BRACKET ||
-          type == TokenType.KEYWORD ||
+          type.isKeyword ||
           type == TokenType.IDENTIFIER ||
           type == TokenType.OPEN_CURLY_BRACKET) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Return `true` if the current token appears to be the beginning of a switch
@@ skipping 2561 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.KEYWORD) {
+      if (type.isKeyword) {
         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 845 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.isBuiltInOrPseudo) {
+    } else if (type.isKeyword && !_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 1956 matching lines @@
    * after advancing to the next token. Otherwise report an error and return the
    * current token without advancing.
    */
   Token _expectKeyword(Keyword keyword) {
     if (_matchesKeyword(keyword)) {
       return getAndAdvance();
     }
     // Remove uses of this method in favor of matches?
     // Pass in the error code to use to report the error?
     _reportErrorForCurrentToken(
-        ParserErrorCode.EXPECTED_TOKEN, [keyword.syntax]);
+        ParserErrorCode.EXPECTED_TOKEN, [keyword.lexeme]);
     return _currentToken;
   }
 
   /**
    * Search the given list of [ranges] for a range that contains the given
    * [index]. Return the range that was found, or `null` if none of the ranges
    * contain the index.
    */
   List<int> _findRange(List<List<int>> ranges, int index) {
     int rangeCount = ranges.length;
@@ skipping 537 matching lines @@
       Token classKeyword,
       SimpleIdentifier className,
       TypeParameterList typeParameters) {
     Token equals = _expect(TokenType.EQ);
     TypeName superclass = parseTypeName(false);
     WithClause withClause = null;
     if (_matchesKeyword(Keyword.WITH)) {
       withClause = parseWithClause();
     } else {
       _reportErrorForCurrentToken(
-          ParserErrorCode.EXPECTED_TOKEN, [Keyword.WITH.syntax]);
+          ParserErrorCode.EXPECTED_TOKEN, [Keyword.WITH.lexeme]);
     }
     ImplementsClause implementsClause = null;
     if (_matchesKeyword(Keyword.IMPLEMENTS)) {
       implementsClause = parseImplementsClause();
     }
     Token semicolon;
     if (_matches(TokenType.SEMICOLON)) {
       semicolon = getAndAdvance();
     } else {
       if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
@@ skipping 977 matching lines @@
   }
 
   /**
    * Parse a string literal representing a URI. Return the string literal that
    * was parsed.
    */
   StringLiteral _parseUri() {
     // TODO(brianwilkerson) Should this function also return true for valid
     // top-level keywords?
     bool isKeywordAfterUri(Token token) =>
-        token.lexeme == Keyword.AS.syntax ||
+        token.lexeme == Keyword.AS.lexeme ||
         token.lexeme == _HIDE ||
         token.lexeme == _SHOW;
     TokenType type = _currentToken.type;
     if (type != TokenType.STRING &&
         type != TokenType.SEMICOLON &&
         !isKeywordAfterUri(_currentToken)) {
       // Attempt to recover in the case where the URI was not enclosed in
       // quotes.
       Token token = _currentToken;
       bool isValidInUri(Token token) {
@@ skipping 494 matching lines @@
    * include built-in identifiers (pseudo-keywords).
    */
   bool _tokenMatchesIdentifier(Token token) =>
       _tokenMatches(token, TokenType.IDENTIFIER) ||
       _tokenMatchesPseudoKeyword(token);
 
   /**
    * Return `true` if the given [token] is either an identifier or a keyword.
    */
   bool _tokenMatchesIdentifierOrKeyword(Token token) =>
-      _tokenMatches(token, TokenType.IDENTIFIER) ||
-      _tokenMatches(token, TokenType.KEYWORD);
+      _tokenMatches(token, TokenType.IDENTIFIER) || token.type.isKeyword;
 
   /**
    * 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.
    */
@@ skipping 503 matching lines @@
     }
   }
 }
 
 /**
  * Instances of this class are thrown when the parser detects that AST has
  * too many nested expressions to be parsed safely and avoid possibility of
  * [StackOverflowError] in the parser or during later analysis.
  */
 class _TooDeepTreeError {}