cleanup fasta token classes

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 43 matching lines @@
         codeYieldAsIdentifier,
         codeYieldNotGenerator;
 
 import '../scanner.dart' show ErrorToken, Token;
 
 import '../scanner/recover.dart' show closeBraceFor, skipToEof;
 
 import '../../scanner/token.dart'
     show
         ASSIGNMENT_PRECEDENCE,
+        BeginToken,
         CASCADE_PRECEDENCE,
         EQUALITY_PRECEDENCE,
         POSTFIX_PRECEDENCE,
         RELATIONAL_PRECEDENCE,
         TokenType;
 
-import '../scanner/token.dart'
-    show BeginGroupToken, SymbolToken, isUserDefinableOperator;
+import '../scanner/token.dart' show isUserDefinableOperator;
 
 import '../scanner/token_constants.dart'
     show
         COMMA_TOKEN,
         DOUBLE_TOKEN,
         EOF_TOKEN,
         EQ_TOKEN,
         FUNCTION_TOKEN,
         GT_TOKEN,
         GT_GT_TOKEN,
@@ skipping 561 matching lines @@
     listener.beginOptionalFormalParameters(token);
     if (!optional('(', token)) {
       if (optional(';', token)) {
         reportRecoverableErrorCode(token, codeExpectedOpenParens);
         return token;
       }
       return reportUnrecoverableErrorCodeWithString(
               token, codeExpectedButGot, "(")
           .next;
     }
-    BeginGroupToken beginGroupToken = token;
+    BeginToken beginGroupToken = token;
     Token endToken = beginGroupToken.endGroup;
     listener.endFormalParameters(0, token, endToken, kind);
     return endToken.next;
   }
 
   /// Parses the formal parameter list of a function.
   ///
   /// If `kind == MemberKind.GeneralizedFunctionType`, then names may be
   /// omitted (except for named arguments). Otherwise, types may be omitted.
   Token parseFormalParameters(Token token, MemberKind kind) {
@@ skipping 171 matching lines @@
   bool isValidMethodTypeArguments(Token token) {
     return tryParseMethodTypeArguments(token) != null;
   }
 
   /// Returns token after match if [token] matches '<' type (',' type)* '>' '(',
   /// and otherwise returns null. Does not produce listener events. With respect
   /// to the final '(', please see the description of
   /// [isValidMethodTypeArguments].
   Token tryParseMethodTypeArguments(Token token) {
     if (!identical(token.kind, LT_TOKEN)) return null;
-    BeginGroupToken beginToken = token;
+    BeginToken beginToken = token;
     Token endToken = beginToken.endGroup;
     if (endToken == null || !identical(endToken.next.kind, OPEN_PAREN_TOKEN)) {
       return null;
     }
     token = tryParseType(token.next);
     while (token != null && identical(token.kind, COMMA_TOKEN)) {
       token = tryParseType(token.next);
     }
     if (token == null || !identical(token.kind, GT_TOKEN)) return null;
     return token.next;
@@ skipping 34 matching lines @@
     token = tryParseType(token.next);
     while (token != null && identical(token.kind, COMMA_TOKEN)) {
       token = tryParseType(token.next);
     }
     if (token == null) return null;
     if (identical(token.kind, GT_TOKEN)) return token.next;
     if (!identical(token.kind, GT_GT_TOKEN)) return null;
     // [token] is '>>' of which the final '>' that we are parsing is the first
     // character. In order to keep the parsing process on track we must return
     // a synthetic '>' corresponding to the second character of that '>>'.
-    Token syntheticToken = new SymbolToken(TokenType.GT, token.charOffset + 1);
+    Token syntheticToken = new Token(TokenType.GT, token.charOffset + 1);
     syntheticToken.next = token.next;
     return syntheticToken;
   }
 
   Token parseQualified(Token token, IdentifierContext context,
       IdentifierContext continuationContext) {
     token = parseIdentifier(token, context);
     while (optional('.', token)) {
       token = parseQualifiedRest(token, continuationContext);
     }
@@ skipping 14 matching lines @@
     Token period = token;
     token = parseIdentifier(token.next, context);
     listener.handleQualified(period);
     return token;
   }
 
   Token skipBlock(Token token) {
     if (!optional('{', token)) {
       return reportUnrecoverableErrorCode(token, codeExpectedBlockToSkip).next;
     }
-    BeginGroupToken beginGroupToken = token;
+    BeginToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
     if (endGroup == null || !identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
       return reportUnmatchedToken(beginGroupToken).next;
     }
     return beginGroupToken.endGroup;
   }
 
   Token parseEnum(Token token) {
     listener.beginEnum(token);
     Token enumKeyword = token;
@@ skipping 266 matching lines @@
     if (optional('<', token)) {
       Token begin = token;
       beginStuff(begin);
       int count = 0;
       do {
         token = stuffParser(token.next);
         ++count;
       } while (optional(',', token));
       Token next = token.next;
       if (identical(token.stringValue, '>>')) {
-        token = new SymbolToken(TokenType.GT, token.charOffset);
-        token.next = new SymbolToken(TokenType.GT, token.charOffset + 1);
+        token = new Token(TokenType.GT, token.charOffset);
+        token.next = new Token(TokenType.GT, token.charOffset + 1);
         token.next.next = next;
       }
       endStuff(count, begin, token);
       return expect('>', token);
     }
     handleNoStuff(token);
     return token;
   }
 
   Token parseTopLevelMember(Token token) {
@@ skipping 224 matching lines @@
           Token type = token;
           // type ...
           if (optional('.', token.next)) {
             // type '.' ...
             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 (token.next is BeginToken) {
+              BeginToken beginGroup = token.next;
               if (beginGroup.endGroup == null) {
                 token = reportUnmatchedToken(beginGroup).next;
               } else {
                 token = beginGroup.endGroup;
               }
             }
           }
           // If the next token after a type has a type substitution comment
           // /*=T*/, then the previous type tokens and the reference to them
           // from the link should be replaced.
           {
             Token newType = listener.replaceTokenWithGenericCommentTypeAssign(
                 type, token.next);
             if (!identical(newType, type)) {
               identifiers = identifiers.tail;
               token = newType;
               continue;
             }
           }
         }
         token = token.next;
       }
       while (isGeneralizedFunctionType(token)) {
         token = token.next;
         if (optional('<', token)) {
-          if (token is BeginGroupToken) {
-            BeginGroupToken beginGroup = token;
+          if (token is BeginToken) {
+            BeginToken beginGroup = token;
             if (beginGroup.endGroup == null) {
               token = reportUnmatchedToken(beginGroup).next;
             } else {
               token = beginGroup.endGroup.next;
             }
           }
         }
         if (!optional('(', token)) {
           if (optional(';', token)) {
             reportRecoverableErrorCode(token, codeExpectedOpenParens);
           }
           token = expect("(", token);
         }
-        if (token is BeginGroupToken) {
-          BeginGroupToken beginGroup = token;
+        if (token is BeginToken) {
+          BeginToken beginGroup = token;
           if (beginGroup.endGroup == null) {
             token = reportUnmatchedToken(beginGroup).next;
           } else {
             token = beginGroup.endGroup.next;
           }
         }
       }
     }
     return listener.handleMemberName(const Link<Token>());
   }
@@ skipping 243 matching lines @@
     if (identical(peek.kind, PERIOD_TOKEN)) {
       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;
+      BeginToken beginGroupToken = peek;
       Token gtToken = beginGroupToken.endGroup;
       if (gtToken != null) {
         // We are looking at "qualified '<' ... '>' ...".
         peek = gtToken.next;
       }
     }
     return peek;
   }
 
   /// Returns the first token after the function type starting at [token].
@@ skipping 14 matching lines @@
   /// pointed to the first `(`, then the returned token points to the second
   /// `Function` token.
   Token peekAfterFunctionType(Token token) {
     // Possible inputs are:
     //    ( ... )
     //    < ... >( ... )
 
     Token peek = token;
     // If there is a generic argument to the function, skip over that one first.
     if (identical(peek.kind, LT_TOKEN)) {
-      BeginGroupToken beginGroupToken = peek;
+      BeginToken beginGroupToken = peek;
       Token closeToken = beginGroupToken.endGroup;
       if (closeToken != null) {
         peek = closeToken.next;
       }
     }
 
     // Now we just need to skip over the formals.
     expect('(', peek);
 
-    BeginGroupToken beginGroupToken = peek;
+    BeginToken beginGroupToken = peek;
     Token closeToken = beginGroupToken.endGroup;
     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) {
       return null;
     }
     return peekAfterType(token);
   }
 
   Token skipClassBody(Token token) {
     if (!optional('{', token)) {
       return reportUnrecoverableErrorCodeWithToken(
               token, codeExpectedClassBodyToSkip)
           .next;
     }
-    BeginGroupToken beginGroupToken = token;
+    BeginToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
     if (endGroup == null || !identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
       return reportUnmatchedToken(beginGroupToken).next;
     }
     return endGroup;
   }
 
   Token parseClassBody(Token token) {
     Token begin = token;
     listener.beginClassBody(token);
@@ skipping 638 matching lines @@
 
       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 "type identifier" followed by '=', ';', ','.
         return parseVariablesDeclaration(token);
       } else if (identical(afterIdKind, OPEN_PAREN_TOKEN)) {
         // We are looking at "type identifier '('".
-        BeginGroupToken beginParen = afterId;
+        BeginToken beginParen = afterId;
         Token endParen = beginParen.endGroup;
         // TODO(eernst): Check for NPE as described in issue 26252.
         Token afterParens = endParen.next;
         if (optional('{', afterParens) ||
             optional('=>', afterParens) ||
             optional('async', afterParens) ||
             optional('sync', afterParens)) {
           // We are looking at "type identifier '(' ... ')'" followed
           // by '{', '=>', 'async', or 'sync'.
           return parseFunctionDeclaration(token);
         }
       } else if (identical(afterIdKind, LT_TOKEN)) {
         // We are looking at "type identifier '<'".
-        BeginGroupToken beginAngle = afterId;
+        BeginToken beginAngle = afterId;
         Token endAngle = beginAngle.endGroup;
         if (endAngle != null &&
             identical(endAngle.next.kind, OPEN_PAREN_TOKEN)) {
-          BeginGroupToken beginParen = endAngle.next;
+          BeginToken beginParen = endAngle.next;
           Token endParen = beginParen.endGroup;
           if (endParen != null) {
             Token afterParens = endParen.next;
             if (optional('{', afterParens) ||
                 optional('=>', afterParens) ||
                 optional('async', afterParens) ||
                 optional('sync', afterParens)) {
               // We are looking at "type identifier '<' ... '>' '(' ... ')'"
               // followed by '{', '=>', 'async', or 'sync'.
               return parseFunctionDeclaration(token);
             }
           }
         }
       }
       // Fall-through to expression statement.
     } else {
       if (optional(':', token.next)) {
         return parseLabeledStatement(token);
       } else if (optional('(', token.next)) {
-        BeginGroupToken begin = token.next;
+        BeginToken begin = token.next;
         // TODO(eernst): Check for NPE as described in issue 26252.
         String afterParens = begin.endGroup.next.stringValue;
         if (identical(afterParens, '{') ||
             identical(afterParens, '=>') ||
             identical(afterParens, 'async') ||
             identical(afterParens, 'sync')) {
           return parseFunctionDeclaration(token);
         }
       } else if (optional('<', token.next)) {
-        BeginGroupToken beginAngle = token.next;
+        BeginToken beginAngle = token.next;
         Token endAngle = beginAngle.endGroup;
         if (endAngle != null &&
             identical(endAngle.next.kind, OPEN_PAREN_TOKEN)) {
-          BeginGroupToken beginParen = endAngle.next;
+          BeginToken beginParen = endAngle.next;
           Token endParen = beginParen.endGroup;
           if (endParen != null) {
             String afterParens = endParen.next.stringValue;
             if (identical(afterParens, '{') ||
                 identical(afterParens, '=>') ||
                 identical(afterParens, 'async') ||
                 identical(afterParens, 'sync')) {
               return parseFunctionDeclaration(token);
             }
           }
@@ skipping 76 matching lines @@
           token = token.next;
           nextValue = token.next.stringValue;
         }
         if (identical(nextValue, '{')) {
           // Handle cases like this:
           // class Foo {
           //   var map;
           //   Foo() : map = {};
           //   Foo.x() : map = true ? {} : {};
           // }
-          BeginGroupToken begin = token.next;
+          BeginToken begin = token.next;
           token = (begin.endGroup != null) ? begin.endGroup : token;
           token = token.next;
           continue;
         }
         if (identical(nextValue, '<')) {
           // Handle cases like this:
           // class Foo {
           //   var map;
           //   Foo() : map = <String, Foo>{};
           //   Foo.x() : map = true ? <String, Foo>{} : <String, Foo>{};
           // }
-          BeginGroupToken begin = token.next;
+          BeginToken begin = token.next;
           token = (begin.endGroup != null) ? begin.endGroup : token;
           token = token.next;
           if (identical(token.stringValue, '{')) {
             begin = token;
             token = (begin.endGroup != null) ? begin.endGroup : token;
             token = token.next;
           }
           continue;
         }
       }
       if (!mayParseFunctionExpressions && identical(value, '{')) {
         break;
       }
-      if (token is BeginGroupToken) {
-        BeginGroupToken begin = token;
+      if (token is BeginToken) {
+        BeginToken begin = token;
         token = (begin.endGroup != null) ? begin.endGroup : token;
       } else if (token is ErrorToken) {
         reportErrorToken(token, false).next;
       }
       token = token.next;
     }
     return token;
   }
 
   Token parseRecoverExpression(Token token) => parseExpression(token);
@@ skipping 246 matching lines @@
   }
 
   Token expressionExpected(Token token) {
     token = reportUnrecoverableErrorCodeWithToken(token, codeExpectedExpression)
         .next;
     listener.handleInvalidExpression(token);
     return token;
   }
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
-    BeginGroupToken beginGroup = token;
+    BeginToken beginGroup = token;
     // TODO(eernst): Check for NPE as described in issue 26252.
     Token nextToken = beginGroup.endGroup.next;
     int kind = nextToken.kind;
     if (mayParseFunctionExpressions &&
         (identical(kind, FUNCTION_TOKEN) ||
             identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
             (identical(kind, KEYWORD_TOKEN) &&
                 (optional('async', nextToken) ||
                     optional('sync', nextToken))))) {
       listener.handleNoTypeVariables(token);
       return parseUnnamedFunction(token);
     } else {
       bool old = mayParseFunctionExpressions;
       mayParseFunctionExpressions = true;
       token = parseParenthesizedExpression(token);
       mayParseFunctionExpressions = old;
       return token;
     }
   }
 
   Token parseParenthesizedExpression(Token token) {
-    // We expect [begin] to be of type [BeginGroupToken], but we don't know for
+    // We expect [begin] to be of type [BeginToken], but we don't know for
     // sure until after calling expect.
     dynamic begin = token;
     token = expect('(', token);
-    // [begin] is now known to have type [BeginGroupToken].
+    // [begin] is now known to have type [BeginToken].
     token = parseExpression(token);
     if (!identical(begin.endGroup, token)) {
       reportUnexpectedToken(token).next;
       token = begin.endGroup;
     }
     listener.handleParenthesizedExpression(begin);
     return expect(')', token);
   }
 
   Token parseThisExpression(Token token, IdentifierContext context) {
@@ skipping 74 matching lines @@
     listener.handleLiteralMap(count, beginToken, constKeyword, token);
     return expect('}', token);
   }
 
   /// formalParameterList functionBody.
   ///
   /// This is a suffix parser because it is assumed that type arguments have
   /// been parsed, or `listener.handleNoTypeArguments(..)` has been executed.
   Token parseLiteralFunctionSuffix(Token token) {
     assert(optional('(', token));
-    BeginGroupToken beginGroup = token;
+    BeginToken beginGroup = token;
     if (beginGroup.endGroup != null) {
       Token nextToken = beginGroup.endGroup.next;
       int kind = nextToken.kind;
       if (identical(kind, FUNCTION_TOKEN) ||
           identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
           (identical(kind, KEYWORD_TOKEN) &&
               (optional('async', nextToken) || optional('sync', nextToken)))) {
         return parseUnnamedFunction(token);
       }
       // Fall through.
     }
     return reportUnexpectedToken(token).next;
   }
 
   /// genericListLiteral | genericMapLiteral | genericFunctionLiteral.
   ///
   /// Where
   ///   genericListLiteral ::= typeArguments '[' (expressionList ','?)? ']'
   ///   genericMapLiteral ::=
   ///       typeArguments '{' (mapLiteralEntry (',' mapLiteralEntry)* ','?)? '}'
   ///   genericFunctionLiteral ::=
   ///       typeParameters formalParameterList functionBody
   /// Provide token for [constKeyword] if preceded by 'const', null if not.
   Token parseLiteralListOrMapOrFunction(Token token, Token constKeyword) {
     assert(optional('<', token));
-    BeginGroupToken begin = token;
+    BeginToken begin = token;
     if (constKeyword == null &&
         begin.endGroup != null &&
         identical(begin.endGroup.next.kind, OPEN_PAREN_TOKEN)) {
       token = parseTypeVariablesOpt(token);
       return parseLiteralFunctionSuffix(token);
     } else {
       token = parseTypeArgumentsOpt(token);
       if (optional('{', token)) {
         return parseLiteralMapSuffix(token, constKeyword);
       } else if ((optional('[', token)) || (optional('[]', token))) {
@@ skipping 25 matching lines @@
       return parseFunctionExpression(token);
     } else if (isFunctionDeclaration(token.next)) {
       return parseFunctionExpression(token);
     } else {
       return parseSend(token, context);
     }
   }
 
   bool isFunctionDeclaration(Token token) {
     if (optional('<', token)) {
-      BeginGroupToken begin = token;
+      BeginToken begin = token;
       if (begin.endGroup == null) return false;
       token = begin.endGroup.next;
     }
     if (optional('(', token)) {
-      BeginGroupToken begin = token;
+      BeginToken begin = token;
       // TODO(eernst): Check for NPE as described in issue 26252.
       String afterParens = begin.endGroup.next.stringValue;
       if (identical(afterParens, '{') ||
           identical(afterParens, '=>') ||
           identical(afterParens, 'async') ||
           identical(afterParens, 'sync')) {
         return true;
       }
     }
     return false;
@@ skipping 152 matching lines @@
       listener.handleNoTypeArguments(token);
     }
     token = parseArgumentsOpt(token);
     listener.endSend(beginToken, token);
     return token;
   }
 
   Token skipArgumentsOpt(Token token) {
     listener.handleNoArguments(token);
     if (optional('(', token)) {
-      BeginGroupToken begin = token;
+      BeginToken begin = token;
       return begin.endGroup.next;
     } else {
       return token;
     }
   }
 
   Token parseArgumentsOpt(Token token) {
     if (!optional('(', token)) {
       listener.handleNoArguments(token);
       return token;
@@ skipping 534 matching lines @@
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, message);
       return null;
     } else {
       Token next = listener.handleUnrecoverableError(token, message);
       return next ?? skipToEof(token);
     }
   }
 
-  Token reportUnmatchedToken(BeginGroupToken token) {
+  Token reportUnmatchedToken(BeginToken token) {
     return reportUnrecoverableError(
         token,
         () => codeUnmatchedToken.format(
             uri, token.charOffset, closeBraceFor(token.lexeme), token));
   }
 
   Token reportUnexpectedToken(Token token) {
     return reportUnrecoverableError(
         token, () => codeUnexpectedToken.format(uri, token.charOffset, token));
   }
@@ skipping 24 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);