Share code for parsing local functions.

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 1185 matching lines @@
               // 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);
+              return parseLocalFunctionDeclarationRest(begin, token, formals);
             }
           } else if (identical(afterIdKind, LT_TOKEN)) {
             // We are looking at `type identifier '<'`.
             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'.
                 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);
+                return parseLocalFunctionDeclarationRest(begin, token, 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)) {
               // 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);
+              return parseLocalFunctionDeclarationRest(begin, token, formals);
             }
           } else if (optional('<', token.next)) {
             Token afterTypeVariables = closeBraceTokenFor(token.next)?.next;
             if (afterTypeVariables != null &&
                 optional("(", afterTypeVariables)) {
               if (looksLikeFunctionBody(
                   closeBraceTokenFor(afterTypeVariables).next)) {
                 // 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);
-                token = parseIdentifier(
-                    token, IdentifierContext.localFunctionDeclaration);
-                listener.endFunctionName(begin, token);
-                return parseLocalFunctionDeclarationFromFormals(
-                    afterTypeVariables);
+                return parseLocalFunctionDeclarationRest(
+                    begin, token, afterTypeVariables);
               }
             }
             // Fall through to expression statement.
           }
         }
         return parseExpressionStatement(begin);
 
       case TypeContinuation.ExpressionStatementOrConstDeclaration:
         Token identifier;
         if (looksLikeType && token.isIdentifier) {
@@ skipping 1078 matching lines @@
       return token.next;
     } else {
       return parseIdentifier(token, IdentifierContext.operatorName);
     }
   }
 
   Token parseFunctionExpression(Token token) {
     Token beginToken = token;
     listener.beginFunctionExpression(token);
     token = parseFormalParameters(token, MemberKind.Local);
-    AsyncModifier savedAsyncModifier = asyncState;
-    token = parseAsyncModifier(token);
-    bool isBlock = optional('{', token);
-    token = parseFunctionBody(token, true, false);
-    asyncState = savedAsyncModifier;
+    token = parseAsyncOptBody(token, true, false);
     listener.endFunctionExpression(beginToken, token);
-    return isBlock ? token.next : token;
+    return token;
   }
 
-  /// Parses the rest of a local function declaration starting from formal
-  /// parameters.
+  /// Parses the rest of a local function declaration starting from its [name]
+  /// but then skips any type parameters and continue parsing from [formals]
+  /// (the 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 parseLocalFunctionDeclarationRest(
+      Token begin, Token name, Token formals) {
+    Token token = name;
+    listener.beginFunctionName(token);
+    token = parseIdentifier(token, IdentifierContext.localFunctionDeclaration);
+    listener.endFunctionName(begin, token);
+    token = parseFormalParametersOpt(formals, MemberKind.Local);
     token = parseInitializersOpt(token);
-    AsyncModifier savedAsyncModifier = asyncState;
-    token = parseAsyncModifier(token);
-    token = parseFunctionBody(token, false, true);
-    asyncState = savedAsyncModifier;
-    token = token.next;
+    token = parseAsyncOptBody(token, false, false);
     listener.endLocalFunctionDeclaration(token);
-    return token;
+    return token.next;
   }
 
   /// Parses a named function expression which isn't legal syntax in Dart.
   /// Useful for recovering from Javascript code being pasted into a Dart
   /// proram, as it will interpret `function foo() {}` as a named function
   /// expression with return type `function` and name `foo`.
   Token parseNamedFunctionExpression(Token token) {
     Token beginToken = token;
     listener.beginNamedFunctionExpression(token);
     listener.handleModifiers(0);
     token = parseType(token, TypeContinuation.Optional);
     if (token != beginToken) {
       reportRecoverableError(token, fasta.messageReturnTypeFunctionExpression);
     }
     listener.beginFunctionName(token);
     Token nameToken = token;
     token = parseIdentifier(token, IdentifierContext.functionExpressionName);
     reportRecoverableError(nameToken, fasta.messageNamedFunctionExpression);
     listener.endFunctionName(beginToken, token);
     token = parseTypeVariablesOpt(token);
     token = parseFormalParameters(token, MemberKind.Local);
     listener.handleNoInitializers();
+    token = parseAsyncOptBody(token, true, false);
+    listener.endNamedFunctionExpression(token);
+    return token;
+  }
+
+  /// Parses a function body optionally preceded by an async modifier (see
+  /// [parseAsyncModifier]).  This method is used in both expression context
+  /// (when [isExpression] is true) and statement context. In statement context
+  /// (when [isExpression] is false), and if the function body is on the form
+  /// `=> expression`, a trailing semicolon is required.
+  ///
+  /// It's an error if there's no function body unless [allowAbstract] is true.
+  Token parseAsyncOptBody(Token token, bool isExpression, bool allowAbstract) {
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
-    bool isBlock = optional('{', token);
-    token = parseFunctionBody(token, true, false);
+    token = parseFunctionBody(token, isExpression, allowAbstract);
     asyncState = savedAsyncModifier;
-    listener.endNamedFunctionExpression(token);
-    return isBlock ? token.next : token;
+    return token;
   }
 
   Token parseConstructorReference(Token token) {
     Token start = token;
     listener.beginConstructorReference(start);
     token = parseIdentifier(token, IdentifierContext.constructorReference);
     token = parseQualifiedRestOpt(
         token, IdentifierContext.constructorReferenceContinuation);
     token = parseTypeArgumentsOpt(token);
     Token period = null;
@@ skipping 40 matching lines @@
         expectSemicolon(token);
         listener.handleFunctionBodySkipped(token, true);
       } else {
         token = skipBlock(token);
         listener.handleFunctionBodySkipped(token, false);
       }
     }
     return token;
   }
 
+  /// Parses a function body.  This method is used in both expression context
+  /// (when [isExpression] is true) and statement context. In statement context
+  /// (when [isExpression] is false), and if the function body is on the form
+  /// `=> expression`, a trailing semicolon is required.
+  ///
+  /// It's an error if there's no function body unless [allowAbstract] is true.
   Token parseFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     if (optional(';', token)) {
       if (!allowAbstract) {
         reportRecoverableError(token, fasta.messageExpectedBody);
       }
       listener.handleEmptyFunctionBody(token);
       return token;
     } else if (optional('=>', token)) {
       Token begin = token;
       token = parseExpression(token.next);
@@ skipping 28 matching lines @@
     }
 
     listener.beginBlockFunctionBody(begin);
     token = token.next;
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
     }
     listener.endBlockFunctionBody(statementCount, begin, token);
     expect('}', token);
-    return token;
+    return isExpression ? token.next : token;
   }
 
   Token skipAsyncModifier(Token token) {
     String value = token.stringValue;
     if (identical(value, 'async')) {
       token = token.next;
       value = token.stringValue;
 
       if (identical(value, '*')) {
         token = token.next;
@@ skipping 1498 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);