change fasta.Token.isIdentifier() from method to getter

pkg/front_end/lib/src/fasta/parser/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.
 
 library fasta.parser.parser;
 
 import '../fasta_codes.dart'
     show
         FastaCode,
         FastaMessage,
@@ skipping 485 matching lines @@
     listener.endPart(partKeyword, semicolon);
     return token;
   }
 
   Token parsePartOf(Token token) {
     listener.beginPartOf(token);
     assert(optional('part', token));
     assert(optional('of', token.next));
     Token partKeyword = token;
     token = token.next.next;
-    bool hasName = token.isIdentifier();
+    bool hasName = token.isIdentifier;
     if (hasName) {
       token = parseQualified(token, IdentifierContext.partName,
           IdentifierContext.partNameContinuation);
     } else {
       token = parseLiteralStringOrRecoverExpression(token);
     }
     Token semicolon = token;
     token = expect(';', token);
     listener.endPartOf(partKeyword, semicolon, hasName);
     return token;
@@ skipping 146 matching lines @@
       {bool inFunctionType: false}) {
     token = parseMetadataStar(token, forParameter: true);
     listener.beginFormalParameter(token);
 
     // Skip over `covariant` token, if the next token is an identifier or
     // modifier.
     // This enables the case where `covariant` is the name of the parameter:
     //    void foo(covariant);
     Token covariantKeyword;
     if (identical(token.stringValue, 'covariant') &&
-        (token.next.isIdentifier() || isModifier(token.next))) {
+        (token.next.isIdentifier || isModifier(token.next))) {
       covariantKeyword = token;
       token = token.next;
     }
     token = parseModifiers(token);
     bool isNamedParameter = kind == FormalParameterType.NAMED;
 
     Token thisKeyword = null;
     Token nameToken;
     if (inFunctionType && isNamedParameter) {
       token = parseType(token);
       token =
           parseIdentifier(token, IdentifierContext.formalParameterDeclaration);
     } else if (inFunctionType) {
       token = parseType(token);
-      if (token.isIdentifier()) {
+      if (token.isIdentifier) {
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       } else {
         listener.handleNoName(token);
       }
     } else {
       token = parseReturnTypeOpt(token);
       if (optional('this', token)) {
         thisKeyword = token;
         token = expect('.', token.next);
@@ skipping 87 matching lines @@
     }
   }
 
   Token parseTypeOpt(Token token) {
     if (isGeneralizedFunctionType(token)) {
       // Function type without return type.
       return parseType(token);
     }
     token = listener.injectGenericCommentTypeAssign(token);
     Token peek = peekAfterIfType(token);
-    if (peek != null && (peek.isIdentifier() || optional('this', peek))) {
+    if (peek != null && (peek.isIdentifier || optional('this', peek))) {
       return parseType(token);
     }
     listener.handleNoType(token);
     return token;
   }
 
   bool isValidTypeReference(Token token) {
     final kind = token.kind;
     if (identical(kind, IDENTIFIER_TOKEN)) return true;
     if (identical(kind, KEYWORD_TOKEN)) {
@@ skipping 224 matching lines @@
   Token parseStringPart(Token token) {
     if (token.kind != STRING_TOKEN) {
       token =
           reportUnrecoverableErrorCodeWithToken(token, codeExpectedString).next;
     }
     listener.handleStringPart(token);
     return token.next;
   }
 
   Token parseIdentifier(Token token, IdentifierContext context) {
-    if (!token.isIdentifier()) {
+    if (!token.isIdentifier) {
       token =
           reportUnrecoverableErrorCodeWithToken(token, codeExpectedIdentifier)
               .next;
     } else if (token.isBuiltInIdentifier &&
         !context.isBuiltInIdentifierAllowed) {
       if (context.inDeclaration) {
         reportRecoverableErrorCodeWithToken(
             token, codeBuiltInIdentifierInDeclaration);
       } else if (!optional("dynamic", token)) {
         reportRecoverableErrorCodeWithToken(token, codeBuiltInIdentifierAsType);
@@ skipping 494 matching lines @@
         hasName = true;
       }
       identifiers = identifiers.prepend(token);
 
       if (!isGeneralizedFunctionType(token)) {
         // Read a potential return type.
         if (isValidTypeReference(token)) {
           // type ...
           if (optional('.', token.next)) {
             // type '.' ...
-            if (token.next.next.isIdentifier()) {
+            if (token.next.next.isIdentifier) {
               // type '.' identifier
               token = token.next.next;
             }
           }
           if (optional('<', token.next)) {
             if (token.next is BeginGroupToken) {
               BeginGroupToken beginGroup = token.next;
               if (beginGroup.endGroup == null) {
                 token = reportUnmatchedToken(beginGroup).next;
               } else {
@@ skipping 166 matching lines @@
     }
     return peek;
   }
 
   /// Returns the first token after the nominal type starting at [token].
   ///
   /// This method assumes that [token] is an identifier (or void).
   Token peekAfterNominalType(Token token) {
     Token peek = token.next;
     if (identical(peek.kind, PERIOD_TOKEN)) {
-      if (peek.next.isIdentifier()) {
+      if (peek.next.isIdentifier) {
         // Look past a library prefix.
         peek = peek.next.next;
       }
     }
     // We are looking at "qualified ...".
     if (identical(peek.kind, LT_TOKEN)) {
       // Possibly generic type.
       // We are looking at "qualified '<'".
       BeginGroupToken beginGroupToken = peek;
       Token gtToken = beginGroupToken.endGroup;
@@ skipping 45 matching lines @@
     if (closeToken != null) {
       peek = closeToken.next;
     }
 
     return peek;
   }
 
   /// If [token] is the start of a type, returns the token after that type.
   /// If [token] is not the start of a type, null is returned.
   Token peekAfterIfType(Token token) {
-    if (!optional('void', token) && !token.isIdentifier()) {
+    if (!optional('void', token) && !token.isIdentifier) {
       return null;
     }
     return peekAfterType(token);
   }
 
   Token skipClassBody(Token token) {
     if (!optional('{', token)) {
       return reportUnrecoverableErrorCodeWithToken(
               token, codeExpectedClassBodyToSkip)
           .next;
@@ skipping 574 matching lines @@
         case AsyncModifier.AsyncStar:
           return parseYieldStatement(token);
 
         case AsyncModifier.Async:
           reportRecoverableErrorCode(token, codeYieldNotGenerator);
           return parseYieldStatement(token);
       }
       throw "Internal error: Unknown asyncState: '$asyncState'.";
     } else if (identical(value, 'const')) {
       return parseExpressionStatementOrConstDeclaration(token);
-    } else if (token.isIdentifier()) {
+    } else if (token.isIdentifier) {
       return parseExpressionStatementOrDeclaration(token);
     } else {
       return parseExpressionStatement(token);
     }
   }
 
   Token parseYieldStatement(Token token) {
     Token begin = token;
     listener.beginYieldStatement(begin);
     assert(identical('yield', token.stringValue));
@@ skipping 20 matching lines @@
       if (inGenerator) {
         reportRecoverableErrorCode(begin.next, codeGeneratorReturnsValue);
       }
       listener.endReturnStatement(true, begin, token);
     }
     return expectSemicolon(token);
   }
 
   Token peekIdentifierAfterType(Token token) {
     Token peek = peekAfterType(token);
-    if (peek != null && peek.isIdentifier()) {
+    if (peek != null && peek.isIdentifier) {
       // We are looking at "type identifier".
       return peek;
     } else {
       return null;
     }
   }
 
   Token peekIdentifierAfterOptionalType(Token token) {
     Token peek = peekAfterIfType(token);
-    if (peek != null && peek.isIdentifier()) {
+    if (peek != null && peek.isIdentifier) {
       // We are looking at "type identifier".
       return peek;
-    } else if (token.isIdentifier()) {
+    } else if (token.isIdentifier) {
       // We are looking at "identifier".
       return token;
     } else {
       return null;
     }
   }
 
   Token parseExpressionStatementOrDeclaration(Token token) {
     if (!inPlainSync && optional("await", token)) {
       return parseExpressionStatement(token);
     }
-    assert(token.isIdentifier() || identical(token.stringValue, 'void'));
+    assert(token.isIdentifier || identical(token.stringValue, 'void'));
     Token identifier = peekIdentifierAfterType(token);
     if (identifier != null) {
-      assert(identifier.isIdentifier());
+      assert(identifier.isIdentifier);
 
       // If the identifier token has a type substitution comment /*=T*/,
       // then the set of tokens type tokens should be replaced with the
       // tokens parsed from the comment.
       token =
           listener.replaceTokenWithGenericCommentTypeAssign(token, identifier);
 
       Token afterId = identifier.next;
       int afterIdKind = afterId.kind;
       if (identical(afterIdKind, EQ_TOKEN) ||
@@ skipping 74 matching lines @@
   }
 
   Token parseExpressionStatementOrConstDeclaration(Token token) {
     assert(identical(token.stringValue, 'const'));
     if (isModifier(token.next)) {
       return parseVariablesDeclaration(token);
     }
     listener.injectGenericCommentTypeAssign(token.next);
     Token identifier = peekIdentifierAfterOptionalType(token.next);
     if (identifier != null) {
-      assert(identifier.isIdentifier());
+      assert(identifier.isIdentifier);
       Token afterId = identifier.next;
       int afterIdKind = afterId.kind;
       if (identical(afterIdKind, EQ_TOKEN) ||
           identical(afterIdKind, SEMICOLON_TOKEN) ||
           identical(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, IdentifierContext.labelDeclaration);
     Token colon = token;
     token = expect(':', token);
     listener.handleLabel(colon);
     return token;
   }
 
   Token parseLabeledStatement(Token token) {
     int labelCount = 0;
     do {
       token = parseLabel(token);
       labelCount++;
-    } while (token.isIdentifier() && 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 170 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 (token.isIdentifier()) {
+    } else if (token.isIdentifier) {
       token = parseSend(token, IdentifierContext.expressionContinuation);
       listener.handleBinaryExpression(cascadeOperator);
     } else {
       return reportUnexpectedToken(token).next;
     }
     Token mark;
     do {
       mark = token;
       if (optional('.', token)) {
         Token period = token;
@@ skipping 96 matching lines @@
         return parseSuperExpression(token, context);
       } else if (identical(value, "new")) {
         return parseNewExpression(token);
       } else if (identical(value, "const")) {
         return parseConstExpression(token);
       } else if (identical(value, "void")) {
         return parseFunctionExpression(token);
       } else if (!inPlainSync &&
           (identical(value, "yield") || identical(value, "async"))) {
         return expressionExpected(token);
-      } else if (token.isIdentifier()) {
+      } else if (token.isIdentifier) {
         return parseSendOrFunctionLiteral(token, context);
       } else {
         return expressionExpected(token);
       }
     } else if (kind == OPEN_PAREN_TOKEN) {
       return parseParenthesizedExpressionOrFunctionLiteral(token);
     } else if (kind == OPEN_SQUARE_BRACKET_TOKEN || optional('[]', token)) {
       listener.handleNoTypeArguments(token);
       return parseLiteralListSuffix(token, null);
     } else if (kind == OPEN_CURLY_BRACKET_TOKEN) {
@@ skipping 552 matching lines @@
   Token parseVariablesDeclarationOrExpressionOpt(Token token) {
     final String value = token.stringValue;
     if (identical(value, ';')) {
       listener.handleNoExpression(token);
       return token;
     } else if (isOneOf4(token, '@', 'var', 'final', 'const')) {
       return parseVariablesDeclarationNoSemicolon(token);
     }
     Token identifier = peekIdentifierAfterType(token);
     if (identifier != null) {
-      assert(identifier.isIdentifier());
+      assert(identifier.isIdentifier);
       if (isOneOf4(identifier.next, '=', ';', ',', 'in')) {
         return parseVariablesDeclarationNoSemicolon(token);
       }
     }
     return parseExpression(token);
   }
 
   Token parseForRest(Token forToken, Token leftParenthesis, Token token) {
     Token leftSeparator = token;
     token = expectSemicolon(token);
@@ skipping 182 matching lines @@
     }
     listener.endSwitchBlock(caseCount, begin, token);
     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 (token.isIdentifier() && 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) {
     Token begin = token;
     Token defaultKeyword = null;
@@ skipping 52 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 (token.isIdentifier()) {
+    if (token.isIdentifier) {
       token = parseIdentifier(token, IdentifierContext.labelReference);
       hasTarget = true;
     }
     listener.handleBreakStatement(hasTarget, breakKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseAssertStatement(Token token) {
     Token assertKeyword = token;
     Token commaToken = null;
@@ skipping 14 matching lines @@
     listener.handleAssertStatement(
         assertKeyword, leftParenthesis, commaToken, rightParenthesis, token);
     return expectSemicolon(token);
   }
 
   Token parseContinueStatement(Token token) {
     assert(optional('continue', token));
     Token continueKeyword = token;
     token = token.next;
     bool hasTarget = false;
-    if (token.isIdentifier()) {
+    if (token.isIdentifier) {
       token = parseIdentifier(token, IdentifierContext.labelReference);
       hasTarget = true;
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
@@ skipping 93 matching lines @@
     return reportUnrecoverableError(
         token, () => code.format(uri, token.charOffset, string));
   }
 }
 
 typedef FastaMessage NoArgument(Uri uri, int charOffset);
 
 typedef FastaMessage TokenArgument(Uri uri, int charOffset, Token token);
 
 typedef FastaMessage StringArgument(Uri uri, int charOffset, String string);