Improve parsing of function 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 FastaCode, FastaMessage;
 
 import '../fasta_codes.dart' as fasta;
 
@@ skipping 1371 matching lines @@
           }
           // Fall-through to expression statement.
         }
 
         return parseExpressionStatement(begin);
 
       case TypeContinuation.SendOrFunctionLiteral:
         if (looksLikeType &&
             token.isIdentifier &&
             isFunctionDeclaration(token.next)) {
-          return parseFunctionExpression(begin);
+          return parseNamedFunctionExpression(begin);
         } else if (isFunctionDeclaration(begin.next)) {
-          return parseFunctionExpression(begin);
+          return parseNamedFunctionExpression(begin);
         }
         return parseSend(begin, continuationContext);
 
       case TypeContinuation.VariablesDeclarationOrExpression:
         if (looksLikeType &&
             token.isIdentifier &&
             isOneOf4(token.next, '=', ';', ',', 'in')) {
           // TODO(ahe): Generate type events and call
           // parseVariablesDeclarationNoSemicolonRest instead.
           return parseVariablesDeclarationNoSemicolon(begin);
@@ skipping 1034 matching lines @@
     if (isUserDefinableOperator(token.next.stringValue)) {
       Token operator = token;
       token = token.next;
       listener.handleOperatorName(operator, token);
       return token.next;
     } else {
       return parseIdentifier(token, IdentifierContext.operatorName);
     }
   }
 
-  Token parseFunction(Token token) {
+  Token parseFunctionExpression(Token token) {
     Token beginToken = token;
-    listener.beginFunction(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;
+    listener.endFunctionExpression(beginToken, token);
+    return isBlock ? token.next : token;
+  }
+
+  Token parseFunctionDeclaration(Token token) {
+    listener.beginFunctionDeclaration(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);
     token = parseFormalParametersOpt(token, MemberKind.Local);
     token = parseInitializersOpt(token);
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, true);
     asyncState = savedAsyncModifier;
-    listener.endFunction(null, token);
-    return token.next;
-  }
-
-  Token parseUnnamedFunction(Token token) {
-    Token beginToken = token;
-    listener.beginUnnamedFunction(token);
-    token = parseFormalParameters(token, MemberKind.Local);
-    AsyncModifier savedAsyncModifier = asyncState;
-    token = parseAsyncModifier(token);
-    bool isBlock = optional('{', token);
-    token = parseFunctionBody(token, true, false);
-    asyncState = savedAsyncModifier;
-    listener.endUnnamedFunction(beginToken, token);
-    return isBlock ? token.next : token;
-  }
-
-  Token parseFunctionDeclaration(Token token) {
-    listener.beginFunctionDeclaration(token);
-    token = parseFunction(token);
+    token = token.next;
     listener.endFunctionDeclaration(token);
     return token;
   }
 
-  Token parseFunctionExpression(Token token) {
+  /// 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.beginFunction(token);
+    listener.beginNamedFunctionExpression(token);
     listener.handleModifiers(0);
     token = parseType(token, TypeContinuation.Optional);
+    if (token != beginToken) {
+      reportRecoverableErrorCode(token, fasta.codeReturnTypeFunctionExpression);
+    }
     listener.beginFunctionName(token);
+    Token nameToken = token;
     token = parseIdentifier(token, IdentifierContext.functionExpressionName);
+    reportRecoverableErrorCode(nameToken, fasta.codeNamedFunctionExpression);
     listener.endFunctionName(beginToken, token);
     token = parseTypeVariablesOpt(token);
     token = parseFormalParameters(token, MemberKind.Local);
     listener.handleNoInitializers();
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
     asyncState = savedAsyncModifier;
-    listener.endFunction(null, token);
+    listener.endNamedFunctionExpression(token);
     return isBlock ? token.next : token;
   }
 
   Token parseConstructorReference(Token token) {
     Token start = token;
     listener.beginConstructorReference(start);
     token = parseIdentifier(token, IdentifierContext.constructorReference);
     token = parseQualifiedRestOpt(
         token, IdentifierContext.constructorReferenceContinuation);
     token = parseTypeArgumentsOpt(token);
@@ skipping 590 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 parseFunctionExpression(token);
+        return parseNamedFunctionExpression(token);
       } 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 24 matching lines @@
     BeginToken beginGroup = token;
     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);
+      return parseFunctionExpression(token);
     } else {
       bool old = mayParseFunctionExpressions;
       mayParseFunctionExpressions = true;
       token = parseParenthesizedExpression(token);
       mayParseFunctionExpressions = old;
       return token;
     }
   }
 
   Token parseParenthesizedExpression(Token token) {
@@ skipping 99 matching lines @@
   Token parseLiteralFunctionSuffix(Token token) {
     assert(optional('(', 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);
+        return parseFunctionExpression(token);
       }
       // Fall through.
     }
     return reportUnexpectedToken(token).next;
   }
 
   /// genericListLiteral | genericMapLiteral | genericFunctionLiteral.
   ///
   /// Where
   ///   genericListLiteral ::= typeArguments '[' (expressionList ','?)? ']'
@@ skipping 857 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);