new TokenType and Keyword API

pkg/front_end/lib/src/scanner/token.dart

 // Copyright (c) 2016, 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.
 
 /**
  * Defines the tokens that are produced by the scanner, used by the parser, and
  * referenced from the [AST structure](ast.dart).
  */
 import 'dart:collection';
 
@@ skipping 361 matching lines @@
 
   /**
    * A flag indicating whether the keyword can be used as an identifier
    * in some situations.
    */
   final bool isPseudo;
 
   /**
    * The lexeme for the keyword.
    */
-  final String syntax;
+  final String lexeme;
 
   /**
    * Initialize a newly created keyword.
    */
-  const Keyword(this.syntax,
+  const Keyword(this.lexeme,
       {this.isBuiltIn: false,
       this.isPseudo: false,
       this.info: TokenType.KEYWORD});
 
   bool get isBuiltInOrPseudo => isBuiltIn || isPseudo;
 
   /**
    * A flag indicating whether the keyword is "built-in" identifier.
    * This method exists for backward compatibility and will be removed.
    * Use [isBuiltIn] instead.
    */
   @deprecated
   bool get isPseudoKeyword => isBuiltIn; // TODO (danrubel): remove this
 
   /**
    * The name of the keyword type.
    */
-  String get name => syntax.toUpperCase();
+  String get name => lexeme.toUpperCase();
+
+  /**
+   * The lexeme for the keyword.
+   *
+   * Deprecated - use [lexeme] instead.
+   */
+  @deprecated
+  String get syntax => lexeme;
 
   @override
   String toString() => name;
 
   /**
    * Create a table mapping the lexemes of keywords to the corresponding keyword
    * and return the table that was created.
    */
   static Map<String, Keyword> _createKeywordMap() {
     LinkedHashMap<String, Keyword> result =
         new LinkedHashMap<String, Keyword>();
     for (Keyword keyword in values) {
-      result[keyword.syntax] = keyword;
+      result[keyword.lexeme] = keyword;
     }
     return result;
   }
 }
 
 /**
  * A token representing a keyword in the language.
  */
 class KeywordToken extends SimpleToken {
   @override
   final Keyword keyword;
 
   /**
    * Initialize a newly created token to represent the given [keyword] at the
    * given [offset].
    */
   KeywordToken(this.keyword, int offset) : super(TokenType.KEYWORD, offset);
 
   @override
-  String get lexeme => keyword.syntax;
+  String get lexeme => keyword.lexeme;
 
   @override
   Token copy() => new KeywordToken(keyword, offset);
 
   @override
   // Changed return type from Keyword to Object because
   // fasta considers pseudo-keywords to be keywords rather than identifiers
   Object value() => keyword;
 }
 
@@ skipping 1021 matching lines @@
   bool get isEqualityOperator =>
       this == TokenType.BANG_EQ || this == TokenType.EQ_EQ;
 
   /**
    * Return `true` if this type of token represents an increment operator.
    */
   bool get isIncrementOperator =>
       this == TokenType.PLUS_PLUS || this == TokenType.MINUS_MINUS;
 
   /**
+   * Return `true` if this type of token is a keyword.
+   */
+  bool get isKeyword => kind == KEYWORD_TOKEN;
+
+  /**
    * Return `true` if this type of token represents a multiplicative operator.
    */
   bool get isMultiplicativeOperator => precedence == MULTIPLICATIVE_PRECEDENCE;
 
   /**
    * Return `true` if this type of token represents a relational operator.
    */
   bool get isRelationalOperator =>
       this == TokenType.LT ||
       this == TokenType.LT_EQ ||
@@ skipping 52 matching lines @@
 
   void set precedingComments(CommentToken comment) {
     _precedingComment = comment;
     _setCommentParent(_precedingComment);
   }
 
   @override
   Token copy() =>
       new TokenWithComment(type, offset, copyComments(precedingComments));
 }