Don't serialize elements of top-level function/constructor/method bodies.

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 606 matching lines @@
       bool isSetter,
       TypeName returnType,
       FormalParameterList formalParameters,
       FunctionBody body,
       bool isTopLevel,
       bool isDeclaredStatic,
       Comment documentationComment,
       NodeList<Annotation> annotations,
       TypeParameterList typeParameters,
       bool isExternal,
-      bool serializeBodyExpr) {
+      bool serializeBodyExpr,
+      bool serializeBody) {
     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 37 matching lines @@
     }
     b.visibleOffset = enclosingBlock?.offset;
     b.visibleLength = enclosingBlock?.length;
     Set<String> oldParameterNames = _parameterNames;
     if (formalParameters != null && formalParameters.parameters.isNotEmpty) {
       _parameterNames =
           _parameterNames == null ? new Set<String>() : _parameterNames.toSet();
       _parameterNames.addAll(formalParameters.parameters
           .map((FormalParameter p) => p.identifier.name));
     }
-    serializeFunctionBody(b, null, body, serializeBodyExpr);
+    serializeFunctionBody(b, null, body, serializeBodyExpr, serializeBody);
     _parameterNames = oldParameterNames;
     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], 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) {
+      bool serializeBodyExpr,
+      bool serializeBody) {
     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 (serializeBody) {
+      body.accept(this);
+    }
     if (serializeBodyExpr) {
       if (body is Expression) {
         b.bodyExpr =
             serializeConstExpr(_localClosureIndexMap, body, _parameterNames);
       } else if (body is ExpressionFunctionBody) {
         b.bodyExpr = serializeConstExpr(
             _localClosureIndexMap, body.expression, _parameterNames);
       } else {
         // TODO(paulberry): serialize other types of function bodies.
       }
@@ skipping 35 matching lines @@
    * If [serializeBodyExpr] is `true`, then the initializer expression is stored
    * in [UnlinkedExecutableBuilder.bodyExpr].
    */
   UnlinkedExecutableBuilder serializeInitializerFunction(
       Expression expression, bool serializeBodyExpr) {
     if (expression == null) {
       return null;
     }
     UnlinkedExecutableBuilder initializer =
         new UnlinkedExecutableBuilder(nameOffset: expression.offset);
-    serializeFunctionBody(initializer, null, expression, serializeBodyExpr);
+    serializeFunctionBody(
+        initializer, null, expression, serializeBodyExpr, true);
     initializer.inferredReturnTypeSlot = assignSlot();
     return initializer;
   }
 
   /**
    * Serialize a [FieldFormalParameter], [FunctionTypedFormalParameter], or
    * [SimpleFormalParameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParameter(NormalFormalParameter node) {
     UnlinkedParamBuilder b = new UnlinkedParamBuilder();
@@ skipping 288 matching lines @@
     }
     if (node.constKeyword != null) {
       b.isConst = true;
       b.constCycleSlot = assignSlot();
     }
     b.isExternal = node.externalKeyword != null;
     b.documentationComment = serializeDocumentation(node.documentationComment);
     b.annotations = serializeAnnotations(node.metadata);
     b.codeRange = serializeCodeRange(node);
     Map<int, int> localClosureIndexMap = serializeFunctionBody(
-        b, node.initializers, node.body, node.constKeyword != null);
+        b, node.initializers, node.body, node.constKeyword != null, false);
     if (node.constKeyword != null) {
       Set<String> constructorParameterNames =
           node.parameters.parameters.map((p) => p.identifier.name).toSet();
       b.constantInitializers = node.initializers
           .map((ConstructorInitializer initializer) =>
               serializeConstructorInitializer(initializer, (Expression expr) {
                 return serializeConstExpr(
                     localClosureIndexMap, expr, constructorParameterNames);
               }))
           .toList();
@@ skipping 97 matching lines @@
         node.isSetter,
         node.returnType,
         node.functionExpression.parameters,
         node.functionExpression.body,
         true,
         false,
         node.documentationComment,
         node.metadata,
         node.functionExpression.typeParameters,
         node.externalKeyword != null,
-        false));
+        false,
+        node.parent is FunctionDeclarationStatement));
   }
 
   @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,
-          _serializeClosureBodyExprs));
+          _serializeClosureBodyExprs,
+          true));
     }
   }
 
   @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 80 matching lines @@
         node.isSetter,
         node.returnType,
         node.parameters,
         node.body,
         false,
         node.isStatic,
         node.documentationComment,
         node.metadata,
         node.typeParameters,
         node.externalKeyword != null,
+        false,
         false));
   }
 
   @override
   void visitPartDirective(PartDirective node) {
     parts.add(new UnlinkedPartBuilder(
         uriOffset: node.uri.offset,
         uriEnd: node.uri.end,
         annotations: serializeAnnotations(node.metadata)));
   }
@@ skipping 57 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;
 }