Pull the 'keyword' property into Token.

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 4250 matching lines @@
   /**
    * Return `true` if the current token appears to be the beginning of a switch
    * member.
    */
   bool _isSwitchMember() {
     Token token = _currentToken;
     while (_tokenMatches(token, TokenType.IDENTIFIER) &&
         _tokenMatches(token.next, TokenType.COLON)) {
       token = token.next.next;
     }
-    if (token.type == TokenType.KEYWORD) {
-      Keyword keyword = (token as KeywordToken).keyword;
-      return keyword == Keyword.CASE || keyword == Keyword.DEFAULT;
-    }
-    return false;
+    Keyword keyword = token.keyword;
+    return keyword == Keyword.CASE || keyword == Keyword.DEFAULT;
   }
 
   /**
    * Return `true` if the [startToken] appears to be the first token of a type
    * name that is followed by a variable or field formal parameter.
    */
   bool _isTypedIdentifier(Token startToken) {
     Token token = _skipReturnType(startToken);
     if (token == null) {
       return false;
@@ skipping 2009 matching lines @@
    *
    *     functionDeclarationStatement ::=
    *         functionSignature functionBody
    */
   Statement _parseFunctionDeclarationStatementAfterReturnType(
       CommentAndMetadata commentAndMetadata, TypeName returnType) {
     FunctionDeclaration declaration =
         _parseFunctionDeclaration(commentAndMetadata, null, returnType);
     Token propertyKeyword = declaration.propertyKeyword;
     if (propertyKeyword != null) {
-      if ((propertyKeyword as KeywordToken).keyword == Keyword.GET) {
+      if (propertyKeyword.keyword == Keyword.GET) {
         _reportErrorForToken(
             ParserErrorCode.GETTER_IN_FUNCTION, propertyKeyword);
       } else {
         _reportErrorForToken(
             ParserErrorCode.SETTER_IN_FUNCTION, propertyKeyword);
       }
     }
     return new FunctionDeclarationStatement(declaration);
   }
 
@@ skipping 714 matching lines @@
     if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
       if (_tokenMatches(_peek(), TokenType.STRING)) {
         Token afterString = _skipStringLiteral(_currentToken.next);
         if (afterString != null && afterString.type == TokenType.COLON) {
           return new ExpressionStatement(
               parseExpression2(), _expect(TokenType.SEMICOLON));
         }
       }
       return parseBlock();
     } else if (_matches(TokenType.KEYWORD) &&
-        !(_currentToken as KeywordToken).keyword.isPseudoKeyword) {
-      Keyword keyword = (_currentToken as KeywordToken).keyword;
+        !_currentToken.keyword.isPseudoKeyword) {
+      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) {
         return _parseDoStatement();
@@ skipping 1792 matching lines @@
    * include built-in identifiers (pseudo-keywords).
    */
   bool _tokenMatchesIdentifier(Token token) =>
       _tokenMatches(token, TokenType.IDENTIFIER) ||
       _tokenMatchesPseudoKeyword(token);
 
   /**
    * Return `true` if the given [token] matches the given [keyword].
    */
   bool _tokenMatchesKeyword(Token token, Keyword keyword) =>
-      token.type == TokenType.KEYWORD &&
-      (token as KeywordToken).keyword == keyword;
+      token.keyword == keyword;
 
   /**
    * Return `true` if the given [token] matches a pseudo keyword.
    */
   bool _tokenMatchesPseudoKeyword(Token token) =>
-      _tokenMatches(token, TokenType.KEYWORD) &&
-      (token as KeywordToken).keyword.isPseudoKeyword;
+      token.keyword?.isPseudoKeyword ?? false;
 
   /**
    * Return `true` if the given [token] matches the given [identifier].
    */
   bool _tokenMatchesString(Token token, String identifier) =>
       token.type == TokenType.IDENTIFIER && token.lexeme == identifier;
 
   /**
    * Translate the characters at the given [index] in the given [lexeme],
    * appending the translated character to the given [buffer]. The index is
@@ skipping 1104 matching lines @@
    */
   const ParserErrorCode(String name, String message, [String correction])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
 
   @override
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }