Serialize and resynthesize variable initializers.

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/src/generated/utilities_dart.dart';
@@ skipping 457 matching lines @@
         text: text,
         offset: documentationComment.offset,
         length: documentationComment.length);
   }
 
   /**
    * Serialize a [FunctionDeclaration] or [MethodDeclaration] into an
    * [UnlinkedExecutable].
    */
   UnlinkedExecutableBuilder serializeExecutable(
-      SimpleIdentifier name,
+      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) {
     int oldScopesLength = scopes.length;
     _TypeParameterScope typeParameterScope = new _TypeParameterScope();
     scopes.add(typeParameterScope);
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder();
-    String nameString = name.name;
+    String nameString = name;
     if (isGetter) {
       b.kind = UnlinkedExecutableKind.getter;
     } else if (isSetter) {
       b.kind = UnlinkedExecutableKind.setter;
       nameString = '$nameString=';
     } else {
       b.kind = UnlinkedExecutableKind.functionOrMethod;
     }
     b.isAbstract = body is EmptyFunctionBody;
     b.name = nameString;
-    b.nameOffset = name.offset;
+    b.nameOffset = nameOffset;
     b.typeParameters =
         serializeTypeParameters(typeParameters, typeParameterScope);
     if (!isTopLevel) {
       b.isStatic = isDeclaredStatic;
     }
     b.returnType = serializeTypeName(returnType);
     b.isExternal = isExternal;
     bool isSemanticallyStatic = isTopLevel || isDeclaredStatic;
     if (formalParameters != null) {
       b.parameters = formalParameters.parameters
@@ skipping 14 matching lines @@
       b.inferredReturnTypeSlot = assignTypeSlot();
     }
     b.visibleOffset = enclosingBlock?.offset;
     b.visibleLength = enclosingBlock?.length;
     serializeFunctionBody(b, body);
     scopes.removeLast();
     assert(scopes.length == oldScopesLength);
     return b;
   }
 
-  void serializeFunctionBody(UnlinkedExecutableBuilder b, FunctionBody body) {
+  /**
+   * 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.
+   */
+  void serializeFunctionBody(UnlinkedExecutableBuilder b, AstNode body) {
     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<UnlinkedVariableBuilder> oldVariables = variables;
     executables = <UnlinkedExecutableBuilder>[];
     variables = <UnlinkedVariableBuilder>[];
@@ skipping 13 matching lines @@
     EntityRefBuilder serializedReturnType = serializeTypeName(returnType);
     if (serializedReturnType != null) {
       b.type = serializedReturnType;
     }
     b.parameters = parameters.parameters
         .map((FormalParameter p) => p.accept(this))
         .toList();
   }
 
   /**
+   * If the given [expression] is not `null`, serialize it as an
+   * [UnlinkedExecutableBuilder], otherwise return `null`.
+   */
+  UnlinkedExecutableBuilder serializeInitializerFunction(
+      Expression expression) {
+    if (expression == null) {
+      return null;
+    }
+    UnlinkedExecutableBuilder initializer =
+        new UnlinkedExecutableBuilder(nameOffset: expression.offset);
+    serializeFunctionBody(initializer, expression);
+    return initializer;
+  }
+
+  /**
    * Serialize a [FieldFormalParameter], [FunctionTypedFormalParameter], or
    * [SimpleFormalParameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParameter(NormalFormalParameter node) {
     UnlinkedParamBuilder b = new UnlinkedParamBuilder();
     b.name = node.identifier.name;
     b.nameOffset = node.identifier.offset;
     b.annotations = serializeAnnotations(node.metadata);
     switch (node.kind) {
       case ParameterKind.REQUIRED:
@@ skipping 163 matching lines @@
           (variables.isFinal || variables.isConst)) {
         b.propagatedTypeSlot = assignTypeSlot();
       }
       bool isSemanticallyStatic = !isField || isDeclaredStatic;
       if (variables.type == null &&
           (variable.initializer != null || !isSemanticallyStatic)) {
         b.inferredTypeSlot = assignTypeSlot();
       }
       b.visibleOffset = enclosingBlock?.offset;
       b.visibleLength = enclosingBlock?.length;
+      b.initializer = serializeInitializerFunction(variable.initializer);
       this.variables.add(b);
     }
   }
 
   @override
   void visitBlock(Block node) {
     Block oldBlock = enclosingBlock;
     enclosingBlock = node;
     super.visitBlock(node);
     enclosingBlock = oldBlock;
@@ skipping 80 matching lines @@
     executables.add(b);
   }
 
   @override
   UnlinkedParamBuilder visitDefaultFormalParameter(
       DefaultFormalParameter node) {
     UnlinkedParamBuilder b = node.parameter.accept(this);
     if (node.defaultValue != null) {
       b.defaultValue = serializeConstExpr(node.defaultValue);
     }
+    b.initializer = serializeInitializerFunction(node.defaultValue);
     return b;
   }
 
   @override
   void visitEnumDeclaration(EnumDeclaration node) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder();
     b.name = node.name.name;
     b.nameOffset = node.name.offset;
     b.values = node.constants
         .map((EnumConstantDeclaration value) => new UnlinkedEnumValueBuilder(
@@ skipping 32 matching lines @@
       } else {
         b.type = serializeTypeName(node.type);
       }
     }
     return b;
   }
 
   @override
   void visitFunctionDeclaration(FunctionDeclaration node) {
     executables.add(serializeExecutable(
-        node.name,
+        node.name.name,
+        node.name.offset,
         node.isGetter,
         node.isSetter,
         node.returnType,
         node.functionExpression.parameters,
         node.functionExpression.body,
         true,
         false,
         node.documentationComment,
         node.metadata,
         node.functionExpression.typeParameters,
         node.externalKeyword != null));
   }
 
   @override
+  void visitFunctionExpression(FunctionExpression node) {
+    if (node.parent is! FunctionDeclaration) {
+      executables.add(serializeExecutable(
+          null,
+          node.offset,
+          false,
+          false,
+          null,
+          node.parameters,
+          node.body,
+          false,
+          false,
+          null,
+          null,
+          node.typeParameters,
+          false));
+    }
+  }
+
+  @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;
     b.nameOffset = node.name.offset;
     b.typeParameters =
         serializeTypeParameters(node.typeParameters, typeParameterScope);
     EntityRefBuilder serializedReturnType = serializeTypeName(node.returnType);
@@ skipping 46 matching lines @@
     libraryNameOffset = node.name.offset;
     libraryNameLength = node.name.length;
     libraryDocumentationComment =
         serializeDocumentation(node.documentationComment);
     libraryAnnotations = serializeAnnotations(node.metadata);
   }
 
   @override
   void visitMethodDeclaration(MethodDeclaration node) {
     executables.add(serializeExecutable(
-        node.name,
+        node.name.name,
+        node.name.offset,
         node.isGetter,
         node.isSetter,
         node.returnType,
         node.parameters,
         node.body,
         false,
         node.isStatic,
         node.documentationComment,
         node.metadata,
         node.typeParameters,
@@ skipping 53 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;
 }