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

pkg/analyzer/lib/src/summary/resynthesize.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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 400 matching lines @@
         case UnlinkedConstOperation.pushReference:
         case UnlinkedConstOperation.invokeConstructor:
         case UnlinkedConstOperation.length:
           return AstFactory.nullLiteral();
 //          throw new StateError('Unsupported constant operation $operation');
       }
     }
     return stack.single;
   }
 
-  void _pushMap(TypeArgumentList typeArguments) {
-    int count = uc.ints[intPtr++];
-    List<MapLiteralEntry> entries = <MapLiteralEntry>[];
-    for (int i = 0; i < count; i++) {
-      Expression value = _pop();
-      Expression key = _pop();
-      entries.insert(0, AstFactory.mapLiteralEntry2(key, value));
-    }
-    _push(AstFactory.mapLiteral(Keyword.CONST, typeArguments, entries));
-  }
-
   TypeName _buildTypeAst(DartType type) {
     if (type is DynamicTypeImpl) {
       return AstFactory.typeName4('dynamic')..type = type;
     } else if (type is InterfaceType) {
       List<TypeName> argumentNodes =
           type.typeArguments.map(_buildTypeAst).toList();
       TypeName node = AstFactory.typeName4(type.name, argumentNodes);
       node.type = type;
       return node;
     }
@@ skipping 35 matching lines @@
 
   void _pushList(TypeArgumentList typeArguments) {
     int count = uc.ints[intPtr++];
     List<Expression> elements = <Expression>[];
     for (int i = 0; i < count; i++) {
       elements.insert(0, _pop());
     }
     _push(AstFactory.listLiteral2(Keyword.CONST, typeArguments, elements));
   }
 
+  void _pushMap(TypeArgumentList typeArguments) {
+    int count = uc.ints[intPtr++];
+    List<MapLiteralEntry> entries = <MapLiteralEntry>[];
+    for (int i = 0; i < count; i++) {
+      Expression value = _pop();
+      Expression key = _pop();
+      entries.insert(0, AstFactory.mapLiteralEntry2(key, value));
+    }
+    _push(AstFactory.mapLiteral(Keyword.CONST, typeArguments, entries));
+  }
+
   void _pushPrefix(TokenType operator) {
     Expression operand = _pop();
     _push(AstFactory.prefixExpression(operator, operand));
   }
 }
 
 /**
  * A single constant variable for which the constant value should be computed.
  *
  * TODO(scheglov) we will probably need to add dependency list
@@ skipping 795 matching lines @@
           .type;
     } else {
       DartType getTypeParameter(int i) {
         if (i < type.typeArguments.length) {
           return buildType(type.typeArguments[i]);
         } else {
           return summaryResynthesizer.typeProvider.dynamicType;
         }
       }
       _ReferenceInfo referenceInfo = referenceInfos[type.reference];
-      return referenceInfo.buildType(getTypeParameter);
+      return referenceInfo.buildType(
+          getTypeParameter, type.implicitFunctionTypeIndices);
     }
   }
 
   /**
    * Resynthesize a [FunctionTypeAliasElement] and place it in the
    * [unitHolder].
    */
   void buildTypedef(UnlinkedTypedef serializedTypedef) {
     try {
       currentTypeParameters =
@@ skipping 143 matching lines @@
    * Populate [referenceInfos] with the correct information for the current
    * compilation unit.
    */
   void populateReferenceInfos() {
     int numLinkedReferences = linkedUnit.references.length;
     int numUnlinkedReferences = unlinkedUnit.references.length;
     referenceInfos = new List<_ReferenceInfo>(numLinkedReferences);
     for (int i = 0; i < numLinkedReferences; i++) {
       LinkedReference linkedReference = linkedUnit.references[i];
       String name;
+      int containingReference;
       if (i < numUnlinkedReferences) {
         name = unlinkedUnit.references[i].name;
+        containingReference = unlinkedUnit.references[i].prefixReference;
       } else {
         name = linkedUnit.references[i].name;
+        containingReference = linkedUnit.references[i].containingReference;
       }
       ElementHandle element;
       DartType type;
       if (linkedReference.kind == ReferenceKind.unresolved) {
         type = summaryResynthesizer.typeProvider.undefinedType;
       } else if (name == 'dynamic') {
         type = summaryResynthesizer.typeProvider.dynamicType;
       } else if (name == 'void') {
         type = VoidTypeImpl.instance;
       } else {
-        ElementLocation location = new ElementLocationImpl.con3(
-            getReferencedLocationComponents(
-                linkedReference.dependency, linkedReference.unit, name));
+        List<String> locationComponents;
+        if (containingReference != 0 &&
+            referenceInfos[containingReference].element is ClassElement) {
+          locationComponents = referenceInfos[containingReference]
+              .element
+              .location
+              .components
+              .toList();
+          locationComponents.add(name);
+        } else {
+          locationComponents = getReferencedLocationComponents(
+              linkedReference.dependency, linkedReference.unit, name);
+        }
+        ElementLocation location =
+            new ElementLocationImpl.con3(locationComponents);
         switch (linkedReference.kind) {
           case ReferenceKind.classOrEnum:
             element = new ClassElementHandle(summaryResynthesizer, location);
             break;
           case ReferenceKind.typedef:
             element = new FunctionTypeAliasElementHandle(
                 summaryResynthesizer, location);
             break;
+          case ReferenceKind.propertyAccessor:
+            assert(location.components.length == 4);
+            element = new PropertyAccessorElementHandle(
+                summaryResynthesizer, location);
+            break;
+          case ReferenceKind.method:
+            assert(location.components.length == 4);
+            element = new MethodElementHandle(summaryResynthesizer, location);
+            break;
           default:
             // This is an element that doesn't (yet) need to be referred to
             // directly, so don't bother populating an element for it.
             // TODO(paulberry): add support for more kinds, as needed.
             break;
         }
       }
       referenceInfos[i] = new _ReferenceInfo(
           name, element, type, linkedReference.numTypeParameters);
     }
@@ skipping 64 matching lines @@
   /**
    * The name of the entity referred to by this reference.
    */
   final String name;
 
   /**
    * The element referred to by this reference, or `null` if there is no
    * associated element (e.g. because it is a reference to an undefined
    * entity).
    */
-  final ElementHandle element;
+  final Element element;
 
   /**
    * If this reference refers to a non-generic type, the type it refers to.
    * Otherwise `null`.
    */
   DartType type;
 
   /**
    * The number of type parameters accepted by the entity referred to by this
    * reference, or zero if it doesn't accept any type parameters.
    */
   final int numTypeParameters;
 
   /**
    * Create a new [_ReferenceInfo] object referring to an element called [name]
    * via the element handle [elementHandle], and having [numTypeParameters]
    * type parameters.
    *
    * For the special types `dynamic` and `void`, [specialType] should point to
    * the type itself.  Otherwise, pass `null` and the type will be computed
    * when appropriate.
    */
   _ReferenceInfo(
       this.name, this.element, DartType specialType, this.numTypeParameters) {
     if (specialType != null) {
       type = specialType;
     } else if (numTypeParameters == 0) {
       // We can precompute the type because it doesn't depend on type
       // parameters.
-      type = _buildType(null);
+      type = _buildType(null, null);
     }
   }
 
   /**
    * Build a [DartType] corresponding to the result of applying some type
    * arguments to the entity referred to by this [_ReferenceInfo].  The type
    * arguments are retrieved by calling [getTypeArgument].
    *
+   * If [implicitFunctionTypeIndices] is not empty, a [DartType] should be
+   * created which refers to a function type implicitly defined by one of the
+   * element's parameters.  [implicitFunctionTypeIndices] is interpreted as in
+   * [EntityRef.implicitFunctionTypeIndices].
+   *
    * If the entity referred to by this [_ReferenceInfo] is not a type, `null`
    * is returned.
    */
-  DartType buildType(DartType getTypeArgument(int i)) {
+  DartType buildType(
+      DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     DartType result =
-        numTypeParameters == 0 ? type : _buildType(getTypeArgument);
+        (numTypeParameters == 0 && implicitFunctionTypeIndices.isEmpty)
+            ? type
+            : _buildType(getTypeArgument, implicitFunctionTypeIndices);
     if (result == null) {
       // TODO(paulberry): figure out how to handle this case (which should
       // only occur in the event of erroneous code).
       throw new UnimplementedError();
     }
     return result;
   }
 
   /**
    * If this reference refers to a type, build a [DartType] which instantiates
    * it with type arguments returned by [getTypeArgument].  Otherwise return
    * `null`.
+   *
+   * If [implicitFunctionTypeIndices] is not null, a [DartType] should be
+   * created which refers to a function type implicitly defined by one of the
+   * element's parameters.  [implicitFunctionTypeIndices] is interpreted as in
+   * [EntityRef.implicitFunctionTypeIndices].
    */
-  DartType _buildType(DartType getTypeArgument(int i)) {
+  DartType _buildType(
+      DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     List<DartType> typeArguments = const <DartType>[];
     if (numTypeParameters != 0) {
       typeArguments = <DartType>[];
       for (int i = 0; i < numTypeParameters; i++) {
         typeArguments.add(getTypeArgument(i));
       }
     }
     ElementHandle element = this.element; // To allow type promotion
     if (element is ClassElementHandle) {
       return new InterfaceTypeImpl.elementWithNameAndArgs(
           element, name, typeArguments);
     } else if (element is FunctionTypeAliasElementHandle) {
       return new FunctionTypeImpl.elementWithNameAndArgs(
           element, name, typeArguments, typeArguments.isNotEmpty);
+    } else if (element is FunctionTypedElement &&
+        implicitFunctionTypeIndices != null) {
+      FunctionTypedElementComputer computer = () {
+        FunctionTypedElement element = this.element;
+        for (int index in implicitFunctionTypeIndices) {
+          element = element.parameters[index].type.element;
+        }
+        return element;
+      };
+      return new DeferredFunctionTypeImpl(
+          computer, null, typeArguments, typeArguments.isNotEmpty);
     } else {
       return null;
     }
   }
 }