Implement type variables on local function declarations and expressions.

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 1119 matching lines @@
     }
 
     /// Returns true if [token] could be the start of a function body.
     bool looksLikeFunctionBody(Token token) {
       return optional('{', token) ||
           optional('=>', token) ||
           optional('async', token) ||
           optional('sync', token);
     }
 
+    /// Returns true if [token] could be the start of a function declaration
+    /// without a return type.
+    bool looksLikeFunctionDeclaration(Token token) {
+      if (!token.isIdentifier) {
+        return false;
+      }
+      token = token.next;
+      if (optional('<', token)) {
+        Token closeBrace = closeBraceTokenFor(token);
+        if (closeBrace == null) return false;
+        token = closeBrace.next;
+      }
+      if (optional('(', token)) {
+        return looksLikeFunctionBody(closeBraceTokenFor(token).next);
+      }
+      return false;
+    }
+
     FormalParameterKind parameterKind;
     switch (continuation) {
       case TypeContinuation.Required:
         return commitType();
 
       optional:
       case TypeContinuation.Optional:
         if (looksLikeType) {
           if (functionTypes > 0) {
             return commitType(); // Parse function type.
@@ skipping 46 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();
               }
-              return parseLocalFunctionDeclarationRest(begin, token, formals);
+              return parseNamedFunctionRest(begin, token, formals, false);
             }
           } 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();
                 }
-                return parseLocalFunctionDeclarationRest(begin, token, formals);
+                return parseNamedFunctionRest(begin, token, formals, false);
               }
             }
           }
           // 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);
-              return parseLocalFunctionDeclarationRest(begin, token, formals);
+              return parseNamedFunctionRest(begin, token, formals, false);
             }
           } 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);
-                return parseLocalFunctionDeclarationRest(
-                    begin, token, afterTypeVariables);
+                return parseNamedFunctionRest(
+                    begin, token, afterTypeVariables, false);
               }
             }
             // Fall through to expression statement.
           }
         }
         return parseExpressionStatement(begin);
 
       case TypeContinuation.ExpressionStatementOrConstDeclaration:
         Token identifier;
         if (looksLikeType && token.isIdentifier) {
           identifier = token;
         } else if (begin.next.isIdentifier) {
           identifier = begin.next;
         }
         if (identifier != null) {
           if (looksLikeVariableDeclarationEnd(identifier.next.kind)) {
             // We are looking at "const type identifier" followed by '=', ';',
             // or ','.
 
             // TODO(ahe): Generate type events and call
             // parseVariablesDeclarationRest instead.
             return parseVariablesDeclaration(begin);
           }
           // Fall-through to expression statement.
         }
 
         return parseExpressionStatement(begin);
 
       case TypeContinuation.SendOrFunctionLiteral:
-        if (looksLikeType &&
-            token.isIdentifier &&
-            isFunctionDeclaration(token.next)) {
-          return parseNamedFunctionExpression(begin);
-        } else if (isFunctionDeclaration(begin.next)) {
-          return parseNamedFunctionExpression(begin);
+        Token name;
+        bool hasReturnType;
+        if (looksLikeType && looksLikeFunctionDeclaration(token)) {
+          name = token;
+          hasReturnType = true;
+          // Fall-through to parseNamedFunctionRest below.
+        } else if (looksLikeFunctionDeclaration(begin)) {
+          name = begin;
+          hasReturnType = false;
+          // Fall-through to parseNamedFunctionRest below.
+        } else {
+          return parseSend(begin, continuationContext);
         }
-        return parseSend(begin, continuationContext);
+
+        Token formals = parseTypeVariablesOpt(name.next);
+        listener.beginNamedFunctionExpression(begin);
+        listener.handleModifiers(0);
+        if (hasReturnType) {
+          if (voidToken != null) {
+            listener.handleVoidKeyword(voidToken);
+          } else {
+            commitType();
+          }
+          reportRecoverableError(
+              begin, fasta.messageReturnTypeFunctionExpression);
+        } else {
+          listener.handleNoType(begin);
+        }
+
+        return parseNamedFunctionRest(begin, name, formals, true);
 
       case TypeContinuation.VariablesDeclarationOrExpression:
         if (looksLikeType &&
             token.isIdentifier &&
             isOneOf4(token.next, '=', ';', ',', 'in')) {
           // TODO(ahe): Generate type events and call
           // parseVariablesDeclarationNoSemicolonRest instead.
           return parseVariablesDeclarationNoSemicolon(begin);
         }
         return parseExpression(begin);
@@ skipping 1046 matching lines @@
 
   Token parseFunctionExpression(Token token) {
     Token beginToken = token;
     listener.beginFunctionExpression(token);
     token = parseFormalParameters(token, MemberKind.Local);
     token = parseAsyncOptBody(token, true, false);
     listener.endFunctionExpression(beginToken, token);
     return token;
   }
 
-  /// Parses the rest of a local function declaration starting from its [name]
+  /// Parses the rest of a named function declaration starting from its [name]
   /// but then skips any type parameters and continue parsing from [formals]
   /// (the formal parameters).
   ///
+  /// If [isFunctionExpression] is true, this method parses the rest of 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`.
+  ///
   /// Precondition: the parser has previously generated these events:
   ///
   /// - Type variables.
-  /// - beginLocalFunctionDeclaration.
+  /// - `beginLocalFunctionDeclaration` if [isFunctionExpression] is false,
+  ///   otherwise `beginNamedFunctionExpression`.
   /// - Modifiers.
   /// - Return type.
-  Token parseLocalFunctionDeclarationRest(
-      Token begin, Token name, Token formals) {
+  Token parseNamedFunctionRest(
+      Token begin, Token name, Token formals, bool isFunctionExpression) {
     Token token = name;
     listener.beginFunctionName(token);
     token = parseIdentifier(token, IdentifierContext.localFunctionDeclaration);
+    if (isFunctionExpression) {
+      reportRecoverableError(name, fasta.messageNamedFunctionExpression);
+    }
     listener.endFunctionName(begin, token);
     token = parseFormalParametersOpt(formals, MemberKind.Local);
     token = parseInitializersOpt(token);
-    token = parseAsyncOptBody(token, false, false);
-    listener.endLocalFunctionDeclaration(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);
+    token = parseAsyncOptBody(token, isFunctionExpression, false);
+    if (isFunctionExpression) {
+      listener.endNamedFunctionExpression(token);
+      return token;
+    } else {
+      listener.endLocalFunctionDeclaration(token);
+      return token.next;
     }
-    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.
+  /// (when [ofFunctionExpression] is true) and statement context. In statement
+  /// context (when [ofFunctionExpression] 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) {
+  Token parseAsyncOptBody(
+      Token token, bool ofFunctionExpression, bool allowAbstract) {
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
-    token = parseFunctionBody(token, isExpression, allowAbstract);
+    token = parseFunctionBody(token, ofFunctionExpression, allowAbstract);
     asyncState = savedAsyncModifier;
     return token;
   }
 
   Token parseConstructorReference(Token token) {
     Token start = token;
     listener.beginConstructorReference(start);
     token = parseIdentifier(token, IdentifierContext.constructorReference);
     token = parseQualifiedRestOpt(
         token, IdentifierContext.constructorReferenceContinuation);
@@ skipping 43 matching lines @@
         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.
+  /// (when [ofFunctionExpression] is true) and statement context. In statement
+  /// context (when [ofFunctionExpression] 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) {
+  Token parseFunctionBody(
+      Token token, bool ofFunctionExpression, 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);
-      if (!isExpression) {
+      if (!ofFunctionExpression) {
         expectSemicolon(token);
         listener.handleExpressionFunctionBody(begin, token);
       } else {
         listener.handleExpressionFunctionBody(begin, null);
       }
       return token;
     } else if (optional('=', token)) {
       Token begin = token;
       // Recover from a bad factory method.
       reportRecoverableError(token, fasta.messageExpectedBody);
       token = parseExpression(token.next);
-      if (!isExpression) {
+      if (!ofFunctionExpression) {
         expectSemicolon(token);
         listener.handleExpressionFunctionBody(begin, token);
       } else {
         listener.handleExpressionFunctionBody(begin, null);
       }
       return token;
     }
     Token begin = token;
     int statementCount = 0;
     if (!optional('{', token)) {
       token = reportUnrecoverableErrorWithToken(
               token, fasta.templateExpectedFunctionBody)
           .next;
       listener.handleInvalidFunctionBody(token);
       return token;
     }
 
     listener.beginBlockFunctionBody(begin);
     token = token.next;
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
     }
     listener.endBlockFunctionBody(statementCount, begin, token);
     expect('}', token);
-    return isExpression ? token.next : token;
+    return ofFunctionExpression ? 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 473 matching lines @@
         return parseLiteralNull(token);
       } else if (identical(value, "this")) {
         return parseThisExpression(token, context);
       } else if (identical(value, "super")) {
         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 parseNamedFunctionExpression(token);
+        return parseSendOrFunctionLiteral(token, context);
       } else if (!inPlainSync &&
           (identical(value, "yield") || identical(value, "async"))) {
         return expressionExpected(token);
       } else if (identical(value, "assert")) {
         return parseAssert(token, Assert.Expression);
       } else if (token.isIdentifier) {
         return parseSendOrFunctionLiteral(token, context);
       } else {
         return expressionExpected(token);
       }
@@ skipping 197 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)) {
-      Token closeBrace = closeBraceTokenFor(token);
-      if (closeBrace == null) return false;
-      token = closeBrace.next;
-    }
-    if (optional('(', token)) {
-      String afterParens = closeBraceTokenFor(token).next.stringValue;
-      if (identical(afterParens, '{') ||
-          identical(afterParens, '=>') ||
-          identical(afterParens, 'async') ||
-          identical(afterParens, 'sync')) {
-        return true;
-      }
-    }
-    return false;
-  }
-
   Token parseRequiredArguments(Token token) {
     if (optional('(', token)) {
       token = parseArguments(token);
     } else {
       listener.handleNoArguments(token);
       token = reportUnexpectedToken(token).next;
     }
     return token;
   }
 
@@ skipping 769 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);