Handle more corner cases of closures while doing ast-based summaries.

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 370 matching lines @@
   /**
    * Serialize the given list of [annotations].  If there are no annotations,
    * the empty list is returned.
    */
   List<UnlinkedConstBuilder> serializeAnnotations(
       NodeList<Annotation> annotations) {
     if (annotations == null || annotations.isEmpty) {
       return const <UnlinkedConstBuilder>[];
     }
     return annotations.map((Annotation a) {
-      Map<int, int> localClosureIndexMap = null; // TODO(paulberry): fix.
+      // Closures can't appear inside annotations, so we don't need a
+      // localClosureIndexMap.
+      Map<int, int> localClosureIndexMap = null;
       _ConstExprSerializer serializer =
           new _ConstExprSerializer(this, localClosureIndexMap, null);
       serializer.serializeAnnotation(a);
       return serializer.toBuilder();
     }).toList();
   }
 
   /**
    * Serialize a [ClassDeclaration] or [ClassTypeAlias] into an [UnlinkedClass]
    * and store the result in [classes].
@@ skipping 232 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, body);
+    serializeFunctionBody(b, null, body);
     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.
    */
-  void serializeFunctionBody(UnlinkedExecutableBuilder b, AstNode body) {
+  void serializeFunctionBody(UnlinkedExecutableBuilder b,
+      List<ConstructorInitializer> initializers, 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<UnlinkedLabelBuilder> oldLabels = labels;
     List<UnlinkedVariableBuilder> oldVariables = variables;
     executables = <UnlinkedExecutableBuilder>[];
     labels = <UnlinkedLabelBuilder>[];
     variables = <UnlinkedVariableBuilder>[];
+    if (initializers != null) {
+      for (ConstructorInitializer initializer in initializers) {
+        initializer.accept(this);
+      }
+    }
     body.accept(this);
     b.localFunctions = executables;
     b.localLabels = labels;
     b.localVariables = variables;
     executables = oldExecutables;
     labels = oldLabels;
     variables = oldVariables;
   }
 
   /**
@@ skipping 15 matching lines @@
    * 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);
+    serializeFunctionBody(initializer, null, expression);
     initializer.inferredReturnTypeSlot = assignSlot();
     return initializer;
   }
 
   /**
    * Serialize a [FieldFormalParameter], [FunctionTypedFormalParameter], or
    * [SimpleFormalParameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParameter(NormalFormalParameter node) {
     UnlinkedParamBuilder b = new UnlinkedParamBuilder();
@@ skipping 266 matching lines @@
     }
     b.parameters = node.parameters.parameters
         .map((FormalParameter p) => p.accept(this))
         .toList();
     b.kind = UnlinkedExecutableKind.constructor;
     if (node.factoryKeyword != null) {
       b.isFactory = true;
       if (node.redirectedConstructor != null) {
         b.isRedirectedConstructor = true;
         TypeName typeName = node.redirectedConstructor.type;
-        Map<int, int> localClosureIndexMap = null; // TODO(paulberry): fix.
+        // Closures can't appear inside factory constructor redirections, so we
+        // don't need a localClosureIndexMap.
+        Map<int, int> localClosureIndexMap = null;
         b.redirectedConstructor =
             new _ConstExprSerializer(this, localClosureIndexMap, null)
                 .serializeConstructorRef(null, typeName.name,
                     typeName.typeArguments, node.redirectedConstructor.name);
       }
     } else {
       for (ConstructorInitializer initializer in node.initializers) {
         if (initializer is RedirectingConstructorInvocation) {
           b.isRedirectedConstructor = true;
           b.redirectedConstructorName = initializer.constructorName?.name;
         }
       }
     }
     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 = _withLocalClosureIndexMap(() {
+      serializeFunctionBody(b, node.initializers, node.body);
+    });
     if (node.constKeyword != null) {
       Set<String> constructorParameterNames =
           node.parameters.parameters.map((p) => p.identifier.name).toSet();
-      Map<int, int> localClosureIndexMap = null; // TODO(paulberry): fix.
       b.constantInitializers = node.initializers
           .map((ConstructorInitializer initializer) =>
               serializeConstructorInitializer(initializer, (Expression expr) {
                 return serializeConstExpr(
                     localClosureIndexMap, expr, constructorParameterNames);
               }))
           .toList();
     }
-    serializeFunctionBody(b, node.body);
     executables.add(b);
   }
 
   @override
   UnlinkedParamBuilder visitDefaultFormalParameter(
       DefaultFormalParameter node) {
     UnlinkedParamBuilder b = node.parameter.accept(this);
     if (node.defaultValue != null) {
-      Map<int, int> localClosureIndexMap = null; // TODO(paulberry): fix.
+      // Closures can't appear inside default values, so we don't need a
+      // localClosureIndexMap.
+      Map<int, int> localClosureIndexMap = null;
       b.defaultValue =
           serializeConstExpr(localClosureIndexMap, node.defaultValue);
       b.defaultValueCode = node.defaultValue.toSource();
     }
     b.initializer = serializeInitializerFunction(node.defaultValue);
     b.codeRange = serializeCodeRange(node);
     return b;
   }
 
   @override
@@ skipping 282 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;
 }