Parse type variables of local functions before return type.

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 1158 matching lines @@
         }
         continue optional;
 
       case TypeContinuation.ExpressionStatementOrDeclaration:
         assert(begin.isIdentifier || identical(begin.stringValue, 'void'));
         if (!inPlainSync && optional("await", begin)) {
           return parseExpressionStatement(begin);
         }
 
         if (looksLikeType && token.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 afterId = token.next;
 
-          begin =
-              listener.replaceTokenWithGenericCommentTypeAssign(begin, token);

[ahe, 2017/07/21 16:02:19]

This has already been called when we analyze the tokens above.

-
           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(closeBraceTokenFor(afterId).next)) {
               // We are looking at `type identifier '(' ... ')'` followed
               // `( '{' | '=>' | 'async' | 'sync' )`.
-              return parseLocalFunctionDeclaration(begin);
+
+              // Although it looks like there are no type variables here, they
+              // may get injected from a comment.
+              Token formals = parseTypeVariablesOpt(afterId);
+
+              listener.beginLocalFunctionDeclaration(begin);
+              listener.handleModifiers(0);
+              if (voidToken != null) {
+                listener.handleVoidKeyword(voidToken);
+              } else {
+                commitType();
+              }
+              listener.beginFunctionName(token);
+              token = parseIdentifier(
+                  token, IdentifierContext.localFunctionDeclaration);
+              listener.endFunctionName(begin, token);
+              return parseLocalFunctionDeclarationFromFormals(formals);
             }
           } else if (identical(afterIdKind, LT_TOKEN)) {
             // We are looking at `type identifier '<'`.
-            Token afterTypeVariables = closeBraceTokenFor(afterId)?.next;
-            if (afterTypeVariables != null &&
-                optional("(", afterTypeVariables)) {
-              if (looksLikeFunctionBody(
-                  closeBraceTokenFor(afterTypeVariables).next)) {
+            Token formals = closeBraceTokenFor(afterId)?.next;
+            if (formals != null && optional("(", formals)) {
+              if (looksLikeFunctionBody(closeBraceTokenFor(formals).next)) {
                 // We are looking at "type identifier '<' ... '>' '(' ... ')'"
                 // followed by '{', '=>', 'async', or 'sync'.
-                return parseLocalFunctionDeclaration(begin);
+                parseTypeVariablesOpt(afterId);
+                listener.beginLocalFunctionDeclaration(begin);
+                listener.handleModifiers(0);
+                if (voidToken != null) {
+                  listener.handleVoidKeyword(voidToken);
+                } else {
+                  commitType();
+                }
+                listener.beginFunctionName(token);
+                token = parseIdentifier(
+                    token, IdentifierContext.localFunctionDeclaration);
+                listener.endFunctionName(begin, token);
+                return parseLocalFunctionDeclarationFromFormals(formals);
               }
             }
           }
           // Fall-through to expression statement.
         } else {
           token = begin;
           if (optional(':', token.next)) {
             return parseLabeledStatement(token);
           } else if (optional('(', token.next)) {
             if (looksLikeFunctionBody(closeBraceTokenFor(token.next).next)) {
-              return parseLocalFunctionDeclaration(token);
+              // We are looking at `identifier '(' ... ')'` followed by `'{'`,
+              // `'=>'`, `'async'`, or `'sync'`.
+
+              // Although it looks like there are no type variables here, they
+              // may get injected from a comment.
+              Token formals = parseTypeVariablesOpt(token.next);
+
+              listener.beginLocalFunctionDeclaration(token);
+              listener.handleModifiers(0);
+              listener.handleNoType(token);
+              listener.beginFunctionName(token);
+              token = parseIdentifier(
+                  token, IdentifierContext.localFunctionDeclaration);
+              listener.endFunctionName(begin, token);
+              return parseLocalFunctionDeclarationFromFormals(formals);
             }
           } else if (optional('<', token.next)) {
             Token afterTypeVariables = closeBraceTokenFor(token.next)?.next;
             if (afterTypeVariables != null &&
                 optional("(", afterTypeVariables)) {
               if (looksLikeFunctionBody(
                   closeBraceTokenFor(afterTypeVariables).next)) {
-                return parseLocalFunctionDeclaration(token);
+                // We are looking at `identifier '<' ... '>' '(' ... ')'`
+                // followed by `'{'`, `'=>'`, `'async'`, or `'sync'`.
+                parseTypeVariablesOpt(token.next);
+                listener.beginLocalFunctionDeclaration(token);
+                listener.handleModifiers(0);
+                listener.handleNoType(token);
+                listener.beginFunctionName(token);

[danrubel, 2017/07/21 17:11:20]

From this line down to the return statement looks the same as the code in the
above 3 change chunks. Can this code be moved into
parseLocalFunctionDeclarationFromFormals to reduce code duplication?

[ahe, 2017/08/07 11:45:27]

You inspired me to go a bit further, and I decided to move those changes to
their own CL (2999523002).

+                token = parseIdentifier(
+                    token, IdentifierContext.localFunctionDeclaration);
+                listener.endFunctionName(begin, token);
+                return parseLocalFunctionDeclarationFromFormals(
+                    afterTypeVariables);
               }
             }
             // Fall through to expression statement.
           }
         }
         return parseExpressionStatement(begin);
 
       case TypeContinuation.ExpressionStatementOrConstDeclaration:
         Token identifier;
         if (looksLikeType && token.isIdentifier) {
@@ skipping 1087 matching lines @@
     token = parseFormalParameters(token, MemberKind.Local);
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
     asyncState = savedAsyncModifier;
     listener.endFunctionExpression(beginToken, token);
     return isBlock ? token.next : token;
   }
 
-  Token parseLocalFunctionDeclaration(Token token) {
-    listener.beginLocalFunctionDeclaration(token);
-    Token beginToken = token;
-    token = parseModifiers(token, MemberKind.Local);
-    listener.beginFunctionName(token);
-    token = parseIdentifier(token, IdentifierContext.localFunctionDeclaration);
-    token = parseQualifiedRestOpt(
-        token, IdentifierContext.localFunctionDeclarationContinuation);
-    listener.endFunctionName(beginToken, token);
-    token = parseTypeVariablesOpt(token);
+  /// Parses the rest of a local function declaration starting from formal
+  /// parameters.
+  ///
+  /// Precondition: the parser has previously generated these events:
+  ///
+  /// - Type variables.
+  /// - beginLocalFunctionDeclaration.
+  /// - Modifiers.
+  /// - Return type.
+  /// - Function name.
+  Token parseLocalFunctionDeclarationFromFormals(Token token) {
     token = parseFormalParametersOpt(token, MemberKind.Local);
     token = parseInitializersOpt(token);
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, true);
     asyncState = savedAsyncModifier;
     token = token.next;
     listener.endLocalFunctionDeclaration(token);
     return token;
   }
@@ skipping 1645 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);