Store expression function closures summaries when needed for type inference.

pkg/analyzer/lib/src/summary/summarize_ast.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 serialization.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/type.dart' show DartType;
@@ skipping 328 matching lines @@
 
   /**
    * If an expression is being serialized which can contain closures, map whose
    * keys are the offsets of local function nodes representing those closures,
    * and whose values are indices of those local functions relative to their
    * siblings.
    */
   Map<int, int> _localClosureIndexMap;
 
   /**
+   * Indicates whether closure function bodies should be serialized.  This flag
+   * is set while visiting the bodies of initializer expressions that will be
+   * needed by type inference.
+   */
+  bool _serializeClosureBodyExprs = false;
+
+  /**
    * Create a slot id for storing a propagated or inferred type or const cycle
    * info.
    */
   int assignSlot() => ++numSlots;
 
   /**
    * Build a [_Scope] object containing the names defined within the body of a
    * class declaration.
    */
   _Scope buildClassMemberScope(
@@ skipping 214 matching lines @@
         .replaceAll('\r\n', '\n');
     return new UnlinkedDocumentationCommentBuilder(
         text: text,
         offset: documentationComment.offset,
         length: documentationComment.length);
   }
 
   /**
    * Serialize a [FunctionDeclaration] or [MethodDeclaration] into an
    * [UnlinkedExecutable].
+   *
+   * If [serializeBodyExpr] is `true`, then the function definition is stored
+   * in [UnlinkedExecutableBuilder.bodyExpr].
    */
   UnlinkedExecutableBuilder serializeExecutable(
       AstNode node,
       String name,
       int nameOffset,
       bool isGetter,
       bool isSetter,
       TypeName returnType,
       FormalParameterList formalParameters,
       FunctionBody body,
       bool isTopLevel,
       bool isDeclaredStatic,
       Comment documentationComment,
       NodeList<Annotation> annotations,
       TypeParameterList typeParameters,
-      bool isExternal) {
+      bool isExternal,
+      bool serializeBodyExpr) {
     int oldScopesLength = scopes.length;
     _TypeParameterScope typeParameterScope = new _TypeParameterScope();
     scopes.add(typeParameterScope);
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder();
     String nameString = name;
     if (isGetter) {
       b.kind = UnlinkedExecutableKind.getter;
     } else if (isSetter) {
       b.kind = UnlinkedExecutableKind.setter;
       nameString = '$nameString=';
@@ skipping 27 matching lines @@
       }
     }
     b.documentationComment = serializeDocumentation(documentationComment);
     b.annotations = serializeAnnotations(annotations);
     b.codeRange = serializeCodeRange(node);
     if (returnType == null && !isSemanticallyStatic) {
       b.inferredReturnTypeSlot = assignSlot();
     }
     b.visibleOffset = enclosingBlock?.offset;
     b.visibleLength = enclosingBlock?.length;
-    serializeFunctionBody(b, null, body, false);
+    serializeFunctionBody(b, null, body, serializeBodyExpr);
     scopes.removeLast();
     assert(scopes.length == oldScopesLength);
     return b;
   }
 
   /**
    * Record local functions and variables into the given executable. The given
    * [body] is usually an actual [FunctionBody], but may be an [Expression]
    * when we process a synthetic variable initializer function.
    *
    * If [initializers] is non-`null`, closures occurring inside the initializers
    * are serialized first.
    *
    * If [serializeBodyExpr] is `true`, then the function definition is stored
-   * in [UnlinkedExecutableBuilder.bodyExpr].
+   * in [UnlinkedExecutableBuilder.bodyExpr], and closures occurring inside
+   * [initializers] and [body] have their function bodies serialized as well.
    *
    * The return value is a map whose keys are the offsets of local function
    * nodes representing closures inside [initializers] and [body], and whose
    * values are the indices of those local functions relative to their siblings.
    */
   Map<int, int> serializeFunctionBody(
       UnlinkedExecutableBuilder b,
       List<ConstructorInitializer> initializers,
       AstNode body,
       bool serializeBodyExpr) {
     if (body is BlockFunctionBody || body is ExpressionFunctionBody) {
       for (UnlinkedParamBuilder parameter in b.parameters) {
         parameter.visibleOffset = body.offset;
         parameter.visibleLength = body.length;
       }
     }
     List<UnlinkedExecutableBuilder> oldExecutables = executables;
     List<UnlinkedLabelBuilder> oldLabels = labels;
     List<UnlinkedVariableBuilder> oldVariables = variables;
     Map<int, int> oldLocalClosureIndexMap = _localClosureIndexMap;
+    bool oldSerializeClosureBodyExprs = _serializeClosureBodyExprs;
     executables = <UnlinkedExecutableBuilder>[];
     labels = <UnlinkedLabelBuilder>[];
     variables = <UnlinkedVariableBuilder>[];
     _localClosureIndexMap = <int, int>{};
+    _serializeClosureBodyExprs = serializeBodyExpr;
     if (initializers != null) {
       for (ConstructorInitializer initializer in initializers) {
         initializer.accept(this);
       }
     }
     body.accept(this);
     if (serializeBodyExpr) {
       if (body is Expression) {
         b.bodyExpr = serializeConstExpr(_localClosureIndexMap, body);
+      } else if (body is ExpressionFunctionBody) {
+        b.bodyExpr = serializeConstExpr(_localClosureIndexMap, body.expression);
       } else {
         // TODO(paulberry): serialize other types of function bodies.
       }
     }
     b.localFunctions = executables;
     b.localLabels = labels;
     b.localVariables = variables;
     Map<int, int> localClosureIndexMap = _localClosureIndexMap;
     executables = oldExecutables;
     labels = oldLabels;
     variables = oldVariables;
     _localClosureIndexMap = oldLocalClosureIndexMap;
+    _serializeClosureBodyExprs = oldSerializeClosureBodyExprs;
     return localClosureIndexMap;
   }
 
   /**
    * Serialize the return type and parameters of a function-typed formal
    * parameter and store them in [b].
    */
   void serializeFunctionTypedParameterDetails(UnlinkedParamBuilder b,
       TypeName returnType, FormalParameterList parameters) {
     EntityRefBuilder serializedReturnType = serializeTypeName(returnType);
@@ skipping 434 matching lines @@
         node.isGetter,
         node.isSetter,
         node.returnType,
         node.functionExpression.parameters,
         node.functionExpression.body,
         true,
         false,
         node.documentationComment,
         node.metadata,
         node.functionExpression.typeParameters,
-        node.externalKeyword != null));
+        node.externalKeyword != null,
+        false));
   }
 
   @override
   void visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       if (_localClosureIndexMap != null) {
         _localClosureIndexMap[node.offset] = executables.length;
       }
       executables.add(serializeExecutable(
           node,
           null,
           node.offset,
           false,
           false,
           null,
           node.parameters,
           node.body,
           false,
           false,
           null,
           null,
           node.typeParameters,
-          false));
+          false,
+          _serializeClosureBodyExprs));
     }
   }
 
   @override
   void visitFunctionTypeAlias(FunctionTypeAlias node) {
     int oldScopesLength = scopes.length;
     _TypeParameterScope typeParameterScope = new _TypeParameterScope();
     scopes.add(typeParameterScope);
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
     b.name = node.name.name;
@@ skipping 78 matching lines @@
         node.isGetter,
         node.isSetter,
         node.returnType,
         node.parameters,
         node.body,
         false,
         node.isStatic,
         node.documentationComment,
         node.metadata,
         node.typeParameters,
-        node.externalKeyword != null));
+        node.externalKeyword != null,
+        false));
   }
 
   @override
   void visitPartDirective(PartDirective node) {
     parts.add(new UnlinkedPartBuilder(
         uriOffset: node.uri.offset,
         uriEnd: node.uri.end,
         annotations: serializeAnnotations(node.metadata)));
   }
 
@@ skipping 46 matching lines @@
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }