Improve parsing of function expressions.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, 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.body_builder;
 
 import '../fasta_codes.dart' show Message;
 
 import '../fasta_codes.dart' as fasta;
 
@@ skipping 2419 matching lines @@
   }
 
   void exitFunction() {
     debugEvent("exitFunction");
     functionNestingLevel--;
     inCatchBlock = pop();
     switchScope = pop();
   }
 
   @override
-  void beginFunction(Token token) {
-    debugEvent("beginFunction");
+  void beginFunctionDeclaration(Token token) {
+    debugEvent("beginNamedFunctionExpression");
     enterFunction();
   }
 
   @override
-  void beginUnnamedFunction(Token token) {
-    debugEvent("beginUnnamedFunction");
+  void beginNamedFunctionExpression(Token token) {
+    debugEvent("beginNamedFunctionExpression");
     enterFunction();
   }
 
   @override
-  void endFunction(Token getOrSet, Token endToken) {
-    debugEvent("Function");
+  void beginFunctionExpression(Token token) {
+    debugEvent("beginFunctionExpression");
+    enterFunction();
+  }
+
+  @override
+  void endNamedFunctionExpression(Token endToken) {
+    debugEvent("NamedFunctionExpression");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     if (functionNestingLevel != 0) {
       exitLocalScope();
     }
     FormalParameters formals = pop();
     List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
-    push(formals.addToFunction(new FunctionNode(body,
-        typeParameters: typeParameters, asyncMarker: asyncModifier)
-      ..fileOffset = formals.charOffset
-      ..fileEndOffset = endToken.charOffset));
+
+    exitLocalScope();
+    KernelFunctionDeclaration declaration = pop();
+    VariableDeclaration variable = declaration.variable;
+    var returnType = pop();
+    returnType ??= const DynamicType();
+    pop(); // Modifiers.
+    exitFunction();
+
+    variable.initializer = new KernelFunctionExpression(formals.addToFunction(
+        new FunctionNode(body,
+            typeParameters: typeParameters, asyncMarker: asyncModifier)
+          ..fileOffset = formals.charOffset
+          ..fileEndOffset = endToken.charOffset))
+      ..parent = variable
+      ..fileOffset = formals.charOffset;
+    push(new Let(variable, new VariableGet(variable)));
   }
 
   @override
-  void endFunctionDeclaration(Token token) {
+  void endFunctionDeclaration(Token endToken) {
     debugEvent("FunctionDeclaration");
-    FunctionNode function = pop();
+    Statement body = popStatement();
+    AsyncMarker asyncModifier = pop();
+    if (functionNestingLevel != 0) {
+      exitLocalScope();
+    }
+    FormalParameters formals = pop();
+    List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
+    FunctionNode function = formals.addToFunction(new FunctionNode(body,
+        typeParameters: typeParameters, asyncMarker: asyncModifier)
+      ..fileOffset = formals.charOffset
+      ..fileEndOffset = endToken.charOffset);
     exitLocalScope();
     var declaration = pop();
     var returnType = pop();
     var hasImplicitReturnType = returnType == null;
     returnType ??= const DynamicType();
     pop(); // Modifiers.
     exitFunction();
     if (declaration is FunctionDeclaration) {
       KernelFunctionDeclaration.setHasImplicitReturnType(
           declaration, hasImplicitReturnType);
       function.returnType = returnType;
       declaration.variable.type = function.functionType;
       declaration.function = function;
       function.parent = declaration;
     } else {
       // If [declaration] isn't a [FunctionDeclaration], it must be because
       // there was a compile-time error.
 
       // TODO(paulberry): ensure that when integrating with analyzer, type
       // inference is still performed for the dropped declaration.
       assert(library.hasCompileTimeErrors);
     }
     push(declaration);
   }
 
   @override
-  void endUnnamedFunction(Token beginToken, Token token) {
-    debugEvent("UnnamedFunction");
+  void endFunctionExpression(Token beginToken, Token token) {
+    debugEvent("FunctionExpression");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     exitLocalScope();
     FormalParameters formals = pop();
     exitFunction();
     List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier)
       ..fileOffset = beginToken.charOffset
       ..fileEndOffset = token.charOffset);
@@ skipping 1286 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return deprecated_internalProblem("Unknown async modifier: $asyncToken");
   }
 }