Add closeBraceTokenFor and use it instead of BeginToken.

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 Code, Message, Template;
 
 import '../fasta_codes.dart' as fasta;
 
@@ skipping 53 matching lines @@
 
 import 'identifier_context.dart' show IdentifierContext;
 
 import 'listener.dart' show Listener;
 
 import 'member_kind.dart' show MemberKind;
 
 import 'type_continuation.dart'
     show TypeContinuation, typeContiunationFromFormalParameterKind;
 
-import 'util.dart' show optional;
+import 'util.dart' show closeBraceTokenFor, optional;
 
 /// An event generating parser of Dart programs. This parser expects all tokens
 /// in a linked list (aka a token stream).
 ///
 /// The class [Scanner] is used to generate a token stream. See the file
 /// [scanner.dart](../scanner.dart).
 ///
 /// Subclasses of the class [Listener] are used to listen to events.
 ///
 /// Most methods of this class belong in one of three major categories: parse
@@ skipping 467 matching lines @@
     listener.beginOptionalFormalParameters(token);
     if (!optional('(', token)) {
       if (optional(';', token)) {
         reportRecoverableError(token, fasta.messageExpectedOpenParens);
         return token;
       }
       return reportUnrecoverableError(
               token, fasta.templateExpectedButGot.withArguments("("))
           .next;
     }
-    BeginToken beginGroupToken = token;
-    Token endToken = beginGroupToken.endGroup;
-    listener.endFormalParameters(0, token, endToken, kind);
-    return endToken.next;
+    Token closeBrace = closeBraceTokenFor(token);
+    listener.endFormalParameters(0, token, closeBrace, kind);
+    return closeBrace.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) {
     Token begin = token;
     listener.beginFormalParameters(begin, kind);
     expect('(', token);
@@ skipping 84 matching lines @@
   /// possible other constructs will pass (e.g., 'a < C, D > 3').
   bool isValidMethodTypeArguments(Token token) {
     Token Function(Token token) tryParseType;
 
     /// 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;
-      BeginToken beginToken = token;
-      Token endToken = beginToken.endGroup;
+      Token endToken = closeBraceTokenFor(token);
       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 74 matching lines @@
     token = parseIdentifier(token.next, context);
     listener.handleQualified(period);
     return token;
   }
 
   Token skipBlock(Token token) {
     if (!optional('{', token)) {
       return reportUnrecoverableError(token, fasta.messageExpectedBlockToSkip)
           .next;
     }
-    BeginToken beginGroupToken = token;
-    Token endGroup = beginGroupToken.endGroup;
-    if (endGroup == null || !identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
-      return reportUnmatchedToken(beginGroupToken).next;
+    Token closeBrace = closeBraceTokenFor(token);
+    if (closeBrace == null ||
+        !identical(closeBrace.kind, $CLOSE_CURLY_BRACKET)) {
+      return reportUnmatchedToken(token).next;
     }
-    return beginGroupToken.endGroup;
+    return closeBrace;
   }
 
   Token parseEnum(Token token) {
     listener.beginEnum(token);
     Token enumKeyword = token;
     token = parseIdentifier(token.next, IdentifierContext.enumDeclaration);
     token = expect('{', token);
     int count = 0;
     if (!optional('}', token)) {
       token = parseIdentifier(token, IdentifierContext.enumValueDeclaration);
@@ skipping 174 matching lines @@
   }
 
   /// Parse a type, if it is appropriate to do so.
   ///
   /// If this method can parse a type, it will return the next (non-null) token
   /// after the type. Otherwise, it returns null.
   Token parseType(Token token,
       [TypeContinuation continuation = TypeContinuation.Required,
       IdentifierContext continuationContext,
       MemberKind memberKind]) {
-    /// Returns the close brace, bracket, or parenthesis of [left]. For '<', it
-    /// may return null.
-    Token getClose(BeginToken left) => left.endToken;
-
     /// True if we've seen the `var` keyword.
     bool hasVar = false;
 
     /// Where the type begins.
     Token begin;
 
     /// Non-null if 'void' is the first token.
     Token voidToken;
 
     /// True if the tokens at [begin] looks like a type.
     bool looksLikeType = false;
 
     /// True if a type that could be a return type for a generalized function
     /// type was seen during analysis.
     bool hasReturnType = false;
 
     /// The identifier context to use for parsing the type.
     IdentifierContext context = IdentifierContext.typeReference;
 
     /// Non-null if type arguments were seen during analysis.
-    BeginToken typeArguments;
+    Token typeArguments;
 
     /// The number of function types seen during analysis.
     int functionTypes = 0;
 
     /// The start of type variables of function types seen during
     /// analysis. Notice that the tokens in this list might be either `'<'` or
     /// `'('` as not all function types have type parameters. Also, it is safe
-    /// to assume that [getClose] will return non-null for all these tokens.
+    /// to assume that [closeBraceTokenFor] will return non-null for all these tokens.
     Link<Token> typeVariableStarters = const Link<Token>();
 
     {
       // Analyse the next tokens to see if they could be a type.
 
       if (continuation ==
           TypeContinuation.ExpressionStatementOrConstDeclaration) {
         // This is a special case. The first token is `const` and we need to
         // analyze the tokens following the const keyword.
         assert(optional("const", token));
@@ skipping 15 matching lines @@
           !isGeneralizedFunctionType(token)) {
         // We're looking at an identifier that could be a type (or `dynamic`).
         looksLikeType = true;
         token = token.next;
         if (optional(".", token) && isValidTypeReference(token.next)) {
           // We're looking at `prefix '.' identifier`.
           context = IdentifierContext.prefixedTypeReference;
           token = token.next.next;
         }
         if (optional("<", token)) {
-          Token close = getClose(token);
+          Token close = closeBraceTokenFor(token);
           if (close != null &&
               (optional(">", close) || optional(">>", close))) {
             // We found some type arguments.
             typeArguments = token;
             token = close.next;
           }
         }
       }
 
       // If what we have seen so far looks like a type, that could be a return
       // type for a generalized function type.
       hasReturnType = looksLikeType;
 
       while (optional("Function", token)) {
         Token typeVariableStart = token.next;
         if (optional("<", token.next)) {
-          Token close = getClose(token.next);
+          Token close = closeBraceTokenFor(token.next);
           if (close != null && optional(">", close)) {
             token = close;
           } else {
             break; // Not a function type.
           }
         }
         if (optional("(", token.next)) {
           // This is a function type.
-          Token close = getClose(token.next);
+          Token close = closeBraceTokenFor(token.next);
           assert(optional(")", close));
           looksLikeType = true;
           functionTypes++;
           typeVariableStarters =
               typeVariableStarters.prepend(typeVariableStart);
           token = close.next;
         } else {
           break; // Not a funtion type.
         }
       }
@@ skipping 37 matching lines @@
           return parseType(newBegin);
         }
       }
 
       for (int i = 0; i < functionTypes; i++) {
         assert(optional('Function', token));
         Token functionToken = token;
         token = token.next;
         if (optional("<", token)) {
           // Skip type parameters, they were parsed above.
-          token = getClose(token).next;
+          token = closeBraceTokenFor(token).next;
         }
         token =
             parseFormalParameters(token, MemberKind.GeneralizedFunctionType);
         listener.endFunctionType(functionToken, token);
       }
 
       if (hasVar) {
         reportRecoverableError(begin, fasta.messageTypeAfterVar);
       }
 
@@ skipping 64 matching lines @@
           int afterIdKind = afterId.kind;
           if (looksLikeVariableDeclarationEnd(afterIdKind)) {
             // We are looking at `type identifier` followed by
             // `(',' | '=' | ';')`.
 
             // TODO(ahe): Generate type events and call
             // parseVariablesDeclarationRest instead.
             return parseVariablesDeclaration(begin);
           } else if (OPEN_PAREN_TOKEN == afterIdKind) {
             // We are looking at `type identifier '('`.
-            if (looksLikeFunctionBody(getClose(afterId).next)) {
+            if (looksLikeFunctionBody(closeBraceTokenFor(afterId).next)) {
               // We are looking at `type identifier '(' ... ')'` followed
               // `( '{' | '=>' | 'async' | 'sync' )`.
               return parseLocalFunctionDeclaration(begin);
             }
           } else if (identical(afterIdKind, LT_TOKEN)) {
             // We are looking at `type identifier '<'`.
-            Token afterTypeVariables = getClose(afterId)?.next;
+            Token afterTypeVariables = closeBraceTokenFor(afterId)?.next;
             if (afterTypeVariables != null &&
                 optional("(", afterTypeVariables)) {
-              if (looksLikeFunctionBody(getClose(afterTypeVariables).next)) {
+              if (looksLikeFunctionBody(
+                  closeBraceTokenFor(afterTypeVariables).next)) {
                 // We are looking at "type identifier '<' ... '>' '(' ... ')'"
                 // followed by '{', '=>', 'async', or 'sync'.
                 return parseLocalFunctionDeclaration(begin);
               }
             }
           }
           // Fall-through to expression statement.
         } else {
           token = begin;
           if (optional(':', token.next)) {
             return parseLabeledStatement(token);
           } else if (optional('(', token.next)) {
-            if (looksLikeFunctionBody(getClose(token.next).next)) {
+            if (looksLikeFunctionBody(closeBraceTokenFor(token.next).next)) {
               return parseLocalFunctionDeclaration(token);
             }
           } else if (optional('<', token.next)) {
-            Token afterTypeVariables = getClose(token.next)?.next;
+            Token afterTypeVariables = closeBraceTokenFor(token.next)?.next;
             if (afterTypeVariables != null &&
                 optional("(", afterTypeVariables)) {
-              if (looksLikeFunctionBody(getClose(afterTypeVariables).next)) {
+              if (looksLikeFunctionBody(
+                  closeBraceTokenFor(afterTypeVariables).next)) {
                 return parseLocalFunctionDeclaration(token);
               }
             }
             // Fall through to expression statement.
           }
         }
         return parseExpressionStatement(begin);
 
       case TypeContinuation.ExpressionStatementOrConstDeclaration:
         Token identifier;
@@ skipping 92 matching lines @@
         }
         if (isNamedParameter && nameToken.lexeme.startsWith("_")) {
           // TODO(ahe): Move this to after commiting the type.
           reportRecoverableError(nameToken, fasta.messagePrivateNamedParameter);
         }
 
         token = listener.injectGenericCommentTypeList(token);
 
         Token inlineFunctionTypeStart;
         if (optional("<", token)) {
-          Token closer = getClose(token);
+          Token closer = closeBraceTokenFor(token);
           if (closer != null) {
             if (optional("(", closer.next)) {
               inlineFunctionTypeStart = token;
               token = token.next;
             }
           }
         } else if (optional("(", token)) {
           inlineFunctionTypeStart = token;
-          token = getClose(token).next;
+          token = closeBraceTokenFor(token).next;
         }
 
         if (inlineFunctionTypeStart != null) {
           token = parseTypeVariablesOpt(inlineFunctionTypeStart);
           listener.beginFunctionTypedFormalParameter(inlineFunctionTypeStart);
           if (!untyped) {
             if (voidToken != null) {
               listener.handleVoidKeyword(voidToken);
             } else {
               Token saved = token;
@@ skipping 355 matching lines @@
           // 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 BeginToken) {
-              BeginToken beginGroup = token.next;
-              if (beginGroup.endGroup == null) {
-                token = reportUnmatchedToken(beginGroup).next;
+              token = token.next;
+              Token closeBrace = closeBraceTokenFor(token);
+              if (closeBrace == null) {
+                token = reportUnmatchedToken(token).next;
               } else {
-                token = beginGroup.endGroup;
+                token = closeBrace;
               }
             }
           }
           // 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 BeginToken) {
-            BeginToken beginGroup = token;
-            if (beginGroup.endGroup == null) {
-              token = reportUnmatchedToken(beginGroup).next;
+            Token closeBrace = closeBraceTokenFor(token);
+            if (closeBrace == null) {
+              token = reportUnmatchedToken(token).next;
             } else {
-              token = beginGroup.endGroup.next;
+              token = closeBrace.next;
             }
           }
         }
         if (!optional('(', token)) {
           if (optional(';', token)) {
             reportRecoverableError(token, fasta.messageExpectedOpenParens);
           }
           token = expect("(", token);
         }
         if (token is BeginToken) {
-          BeginToken beginGroup = token;
-          if (beginGroup.endGroup == null) {
-            token = reportUnmatchedToken(beginGroup).next;
+          Token closeBrace = closeBraceTokenFor(token);
+          if (closeBrace == null) {
+            token = reportUnmatchedToken(token).next;
           } else {
-            token = beginGroup.endGroup.next;
+            token = closeBrace.next;
           }
         }
       }
     }
     return listener.handleMemberName(const Link<Token>());
   }
 
   Token parseFieldInitializerOpt(
       Token token, Token name, Token varFinalOrConst, bool isTopLevel) {
     if (optional('=', token)) {
@@ skipping 246 matching lines @@
     token = parseType(token, typeContinuation, null, memberKind);
     return token;
   }
 
   Token skipClassBody(Token token) {
     if (!optional('{', token)) {
       return reportUnrecoverableErrorWithToken(
               token, fasta.templateExpectedClassBodyToSkip)
           .next;
     }
-    BeginToken beginGroupToken = token;
-    Token endGroup = beginGroupToken.endGroup;
-    if (endGroup == null || !identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
-      return reportUnmatchedToken(beginGroupToken).next;
+    Token closeBrace = closeBraceTokenFor(token);
+    if (closeBrace == null ||
+        !identical(closeBrace.kind, $CLOSE_CURLY_BRACKET)) {
+      return reportUnmatchedToken(token).next;
     }
-    return endGroup;
+    return closeBrace;
   }
 
   Token parseClassBody(Token token) {
     Token begin = token;
     listener.beginClassBody(token);
     if (!optional('{', token)) {
       token = reportUnrecoverableErrorWithToken(
               token, fasta.templateExpectedClassBody)
           .next;
     }
@@ skipping 665 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 ? {} : {};
           // }
-          BeginToken begin = token.next;
-          token = (begin.endGroup != null) ? begin.endGroup : token;
+          token = closeBraceTokenFor(token) ?? 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>{};
           // }
-          BeginToken begin = token.next;
-          token = (begin.endGroup != null) ? begin.endGroup : token;
+          token = closeBraceTokenFor(token.next) ?? token;
           token = token.next;
           if (identical(token.stringValue, '{')) {
-            begin = token;
-            token = (begin.endGroup != null) ? begin.endGroup : token;
+            token = closeBraceTokenFor(token) ?? token;
             token = token.next;
           }
           continue;
         }
       }
       if (!mayParseFunctionExpressions && identical(value, '{')) {
         break;
       }
       if (token is BeginToken) {
-        BeginToken begin = token;
-        token = (begin.endGroup != null) ? begin.endGroup : token;
+        token = closeBraceTokenFor(token) ?? token;
       } else if (token is ErrorToken) {
         reportErrorToken(token, false).next;
       }
       token = token.next;
     }
     return token;
   }
 
   Token parseRecoverExpression(Token token, Message message) {
     return parseExpression(token);
@@ skipping 246 matching lines @@
 
   Token expressionExpected(Token token) {
     token = reportUnrecoverableErrorWithToken(
             token, fasta.templateExpectedExpression)
         .next;
     listener.handleInvalidExpression(token);
     return token;
   }
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
-    BeginToken beginGroup = token;
-    Token nextToken = beginGroup.endGroup.next;
+    Token nextToken = closeBraceTokenFor(token).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 parseFunctionExpression(token);
     } else {
@@ skipping 100 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));
-    BeginToken beginGroup = token;
-    if (beginGroup.endGroup != null) {
-      Token nextToken = beginGroup.endGroup.next;
+    Token closeBrace = closeBraceTokenFor(token);
+    if (closeBrace != null) {
+      Token nextToken = closeBrace.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 parseFunctionExpression(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));
-    BeginToken begin = token;
+    Token closeBrace = closeBraceTokenFor(token);
     if (constKeyword == null &&
-        begin.endGroup != null &&
-        identical(begin.endGroup.next.kind, OPEN_PAREN_TOKEN)) {
+        closeBrace != null &&
+        identical(closeBrace.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))) {
         return parseLiteralListSuffix(token, constKeyword);
       }
       return reportUnexpectedToken(token).next;
@@ skipping 14 matching lines @@
   Token parseSendOrFunctionLiteral(Token token, IdentifierContext context) {
     if (!mayParseFunctionExpressions) {
       return parseSend(token, context);
     } else {
       return parseType(token, TypeContinuation.SendOrFunctionLiteral, context);
     }
   }
 
   bool isFunctionDeclaration(Token token) {
     if (optional('<', token)) {
-      BeginToken begin = token;
-      if (begin.endGroup == null) return false;
-      token = begin.endGroup.next;
+      Token closeBrace = closeBraceTokenFor(token);
+      if (closeBrace == null) return false;
+      token = closeBrace.next;
     }
     if (optional('(', token)) {
-      BeginToken begin = token;
-      String afterParens = begin.endGroup.next.stringValue;
+      String afterParens = closeBraceTokenFor(token).next.stringValue;
       if (identical(afterParens, '{') ||
           identical(afterParens, '=>') ||
           identical(afterParens, 'async') ||
           identical(afterParens, 'sync')) {
         return true;
       }
     }
     return false;
   }
 
@@ skipping 149 matching lines @@
       listener.handleNoTypeArguments(token);
     }
     token = parseArgumentsOpt(token);
     listener.handleSend(beginToken, token);
     return token;
   }
 
   Token skipArgumentsOpt(Token token) {
     listener.handleNoArguments(token);
     if (optional('(', token)) {
-      BeginToken begin = token;
-      return begin.endGroup.next;
+      return closeBraceTokenFor(token).next;
     } else {
       return token;
     }
   }
 
   Token parseArgumentsOpt(Token token) {
     if (!optional('(', token)) {
       listener.handleNoArguments(token);
       return token;
     } else {
@@ skipping 609 matching lines @@
   }
 
   Token reportUnexpectedToken(Token token) {
     return reportUnrecoverableErrorWithToken(
         token, fasta.templateUnexpectedToken);
   }
 }
 
 // TODO(ahe): Remove when analyzer supports generalized function syntax.
 typedef _MessageWithArgument<T> = Message Function(T);