Support for extract property for methods.

pkg/analyzer/lib/src/summary/link.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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 3133 matching lines @@
 
   @override
   ConstructorElementForLink get asConstructor => null;
 
   @override
   ConstVariableNode get asConstVariable => _constNode;
 
   @override
   DartType get asStaticType {
     Element element = this.element;
-    if (element is PropertyAccessorElement && element.isGetter) {
-      return element.returnType;
+    if (element is PropertyAccessorElement) {
+      if (element.isGetter) {
+        return element.returnType;
+      }
+      return DynamicTypeImpl.instance;
     }
-    // TODO(paulberry): implement.
+    if (element is MethodElement) {
+      return element.type;
+    }
     return DynamicTypeImpl.instance;
   }
 
   @override
   TypeInferenceNode get asTypeInferenceNode {
     // TODO(paulberry): implement.
     return null;
   }
 
   @override
   DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
     if (element != null) {
       DartType type = asStaticType;
       if (type is InterfaceType) {
         Element nameElement = type.lookUpGetter(name, element.library);
+        nameElement ??= type.lookUpMethod(name, element.library);
         return new NonstaticMemberElementForLink(nameElement, _constNode);
       }
     }
     return this;
   }
 }
 
 /**
  * Element representing a function or method parameter resynthesized
  * from a summary during linking.
@@ skipping 974 matching lines @@
   /**
    * Return the contained element with the given [name], or `null` if the lookup
    * fails.  Currently only static types are supported in the linker, so lookup
    * is performed only in the strong mode.
    */
   Element _getContainedElement(String name) {
     Linker linker = compilationUnit.library._linker;
     if (linker.strongMode) {
       DartType type = asStaticType;
       if (type is InterfaceType) {
-        return type.lookUpGetter(name, compilationUnit.library);
+        Element result = type.lookUpGetter(name, compilationUnit.library);
+        result ??= type.lookUpMethod(name, compilationUnit.library);
+        return result;
       }
     }
     // TODO(scheglov): implement for propagated types
     return null;
   }
 }