Add the ability to summarize inferred types based on function-typed parameters.

pkg/analyzer/lib/src/summary/summarize_elements.dart

 // Copyright (c) 2015, 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.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 668 matching lines @@
    *
    * [context] is the element within which the [EntityRef] will be
    * interpreted; this is used to serialize type parameters.
    */
   EntityRefBuilder serializeTypeRef(DartType type, Element context,
       {bool linked: false, int slot}) {
     EntityRefBuilder b = new EntityRefBuilder(slot: slot);
     if (type is TypeParameterType) {
       b.paramReference = findTypeParameterIndex(type, context);
     } else {
-      b.reference = serializeReferenceForType(type, linked);
+      if (type is FunctionType &&
+          type.element.enclosingElement is ParameterElement) {
+        // Code cannot refer to function types implicitly defined by parameters
+        // directly, so if we get here, we must be serializing a linked
+        // reference from type inference.
+        assert(linked);
+        ParameterElement parameterElement = type.element.enclosingElement;
+        while (true) {
+          Element parent = parameterElement.enclosingElement;
+          if (parent is ExecutableElement) {
+            Element grandParent = parent.enclosingElement;
+            b.implicitFunctionTypeIndices
+                .insert(0, parent.parameters.indexOf(parameterElement));
+            if (grandParent is ParameterElement) {
+              // Function-typed parameter inside a function-typed parameter.
+              parameterElement = grandParent;
+              continue;
+            } else {
+              // Function-typed parameter inside a top level function or method.
+              b.reference = _getElementReferenceId(parent, linked: linked);
+              break;
+            }
+          } else {
+            throw new StateError(
+                'Unexpected element enclosing parameter: ${parent.runtimeType}');
+          }
+        }
+      } else {
+        b.reference = serializeReferenceForType(type, linked);
+      }
       List<DartType> typeArguments = getTypeArguments(type);
       if (typeArguments != null) {
         // Trailing type arguments of type 'dynamic' should be omitted.
         int numArgsToSerialize = typeArguments.length;
         while (numArgsToSerialize > 0 &&
             typeArguments[numArgsToSerialize - 1].isDynamic) {
           --numArgsToSerialize;
         }
         if (numArgsToSerialize > 0) {
           List<EntityRefBuilder> serializedArguments = <EntityRefBuilder>[];
@@ skipping 94 matching lines @@
           .add(() => serializeTypeRef(type, context, linked: true, slot: slot));
     }
     return slot;
   }
 
   int _getElementReferenceId(Element element, {bool linked: false}) {
     return referenceMap.putIfAbsent(element, () {
       if (element is ConstructorElement && element.displayName.isEmpty) {
         return _getElementReferenceId(element.enclosingElement, linked: linked);
       }
-      if (element is MethodElement && !element.isStatic) {
-        throw new StateError('Only static methods can be serialized.');
-      }
-      if (element is PropertyAccessorElement) {
-        Element enclosing = element.enclosingElement;
-        if (!(enclosing is CompilationUnitElement || element.isStatic)) {
-          throw new StateError(
-              'Only top-level or static property accessors can be serialized.');
-        }
-      }
       LibraryElement dependentLibrary = element?.library;
       int unit;
       if (dependentLibrary == null) {
         assert(element == librarySerializer.typeProvider.dynamicType.element ||
             element == null);
         unit = 0;
         dependentLibrary = librarySerializer.libraryElement;
       } else {
         CompilationUnitElement unitElement =
             element.getAncestor((Element e) => e is CompilationUnitElement);
         unit = dependentLibrary.units.indexOf(unitElement);
         assert(unit != -1);
       }
       int numTypeParameters = 0;
       if (element is TypeParameterizedElement) {
         numTypeParameters = element.typeParameters.length;
       }
       LinkedReferenceBuilder linkedReference = new LinkedReferenceBuilder(
           dependency: librarySerializer.serializeDependency(dependentLibrary),
           kind: _getReferenceKind(element),
           unit: unit,
           numTypeParameters: numTypeParameters);
       String name = element == null ? 'void' : element.name;
       if (linked) {
         linkedReference.name = name;
+        Element enclosing = element?.enclosingElement;
+        if (enclosing is ClassElement) {
+          linkedReference.containingReference =
+              _getElementReferenceId(enclosing, linked: linked);
+        }
       } else {
         assert(unlinkedReferences.length == linkedReferences.length);
         int prefixReference = 0;
         Element enclosing = element?.enclosingElement;
         if (enclosing == null || enclosing is CompilationUnitElement) {
           // Figure out a prefix that may be used to refer to the given element.
           // TODO(paulberry): to avoid subtle relinking inconsistencies we
           // should use the actual prefix from the AST (a given type may be
           // reachable via multiple prefixes), but sadly, this information is
           // not recorded in the element model.
@@ skipping 268 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }