Fix AST-based type inference via interfaces.

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 2164 matching lines @@
 
   void _computeBinaryExpressionType(TokenType operator) {
     DartType right = stack.removeLast();
     DartType left = stack.removeLast();
     _pushBinaryOperatorType(left, operator, right);
   }
 
   void _computePrefixExpressionType(String operatorName) {
     DartType operand = stack.removeLast();
     if (operand is InterfaceType) {
-      MethodElement method = operand.lookUpMethod(operatorName, library);
+      MethodElement method = operand.lookUpInheritedMethod(operatorName,
+          library: library, thisType: true);

[scheglov, 2016/05/25 20:21:21]

"thisType" is already true by default.

[Paul Berry, 2016/05/25 20:28:12]

Thanks.  Fixed.

       if (method != null) {
         DartType type = method.returnType;
         stack.add(type);
         return;
       }
     }
     stack.add(DynamicTypeImpl.instance);
   }
 
   void _doAssignToIndex() {
@@ skipping 65 matching lines @@
     DartType type = _leastUpperBound(thenType, elseType);
     type = _dynamicIfNull(type);
     stack.add(type);
   }
 
   void _doExtractIndex() {
     stack.removeLast(); // index
     DartType target = stack.removeLast();
     stack.add(() {
       if (target is InterfaceType) {
-        MethodElement method = target.lookUpMethod('[]', library);
+        MethodElement method = target.lookUpInheritedMethod('[]',
+            library: library, thisType: true);
         if (method != null) {
           return method.returnType;
         }
       }
       return DynamicTypeImpl.instance;
     }());
   }
 
   void _doExtractProperty() {
     DartType target = stack.removeLast();
     String propertyName = _getNextString();
     stack.add(() {
       if (target is InterfaceType) {
-        PropertyAccessorElement getter =
-            target.lookUpGetter(propertyName, library);
-        if (getter != null) {
-          return getter.returnType;
-        }
-        MethodElement method = target.lookUpMethod(propertyName, library);
-        if (method != null) {
-          return method.type;
+        ExecutableElement element = target
+            .lookUpInheritedGetterOrMethod(propertyName, library: library);
+        if (element != null) {
+          if (element is PropertyAccessorElement) {
+            return element.returnType;
+          } else {
+            // Method tear-off
+            return element.type;
+          }
         }
       }
       return DynamicTypeImpl.instance;
     }());
   }
 
   void _doInvokeConstructor() {
     int numNamed = _getNextInt();
     int numPositional = _getNextInt();
     // TODO(paulberry): don't just pop the args; use their types
@@ skipping 24 matching lines @@
     int numPositional = unlinkedConst.ints[intPtr++];
     List<String> namedArgNames = _getNextStrings(numNamed);
     List<DartType> namedArgTypeList = _popList(numNamed);
     List<DartType> positionalArgTypes = _popList(numPositional);
     // TODO(scheglov) if we pushed target and method name first, we might be
     // able to move work with arguments in _inferExecutableType()
     String methodName = _getNextString();
     DartType target = stack.removeLast();
     stack.add(() {
       if (target is InterfaceType) {
-        MethodElement method = target.lookUpMethod(methodName, library);
+        MethodElement method = target.lookUpInheritedMethod(methodName,
+            library: library, thisType: true);
         FunctionType rawType = method?.type;
         FunctionType inferredType = _inferExecutableType(rawType, numNamed,
             numPositional, namedArgNames, namedArgTypeList, positionalArgTypes);
         if (inferredType != null) {
           return inferredType.returnType;
         }
       }
       return DynamicTypeImpl.instance;
     }());
   }
@@ skipping 99 matching lines @@
     return unit.resolveTypeRef(ref, variable._typeParameterContext);
   }
 
   /**
    * Return the type of the property with the given [propertyName] in the
    * given [targetType]. May return `dynamic` if the property cannot be
    * resolved.
    */
   DartType _getPropertyType(DartType targetType, String propertyName) {
     return targetType is InterfaceType
-        ? targetType.lookUpGetter(propertyName, library)?.returnType
+        ? targetType
+            .lookUpInheritedGetter(propertyName,
+                library: library, thisType: true)
+            ?.returnType
         : DynamicTypeImpl.instance;
   }
 
   FunctionType _inferExecutableType(
       FunctionType rawMethodType,
       int numNamed,
       int numPositional,
       List<String> namedArgNames,
       List<DartType> namedArgTypeList,
       List<DartType> positionalArgTypes) {
@@ skipping 43 matching lines @@
 
   List<DartType> _popList(int n) {
     List<DartType> result = stack.sublist(stack.length - n, stack.length);
     stack.length -= n;
     return result;
   }
 
   void _pushBinaryOperatorType(
       DartType left, TokenType operator, DartType right) {
     if (left is InterfaceType) {
-      MethodElement method = left.lookUpMethod(operator.lexeme, library);
+      MethodElement method = left.lookUpInheritedMethod(operator.lexeme,
+          library: library, thisType: true);
       if (method != null) {
         DartType type = method.returnType;
         type = linker.typeSystem.refineBinaryExpressionType(
             typeProvider, left, operator, right, type);
         stack.add(type);
         return;
       }
     }
     stack.add(DynamicTypeImpl.instance);
   }
@@ skipping 1069 matching lines @@
   NonstaticMemberElementForLink(this._library, this._target, this._name);
 
   @override
   ConstVariableNode get asConstVariable => _target.asConstVariable;
 
   @override
   DartType get asStaticType {
     if (_library._linker.strongMode) {
       DartType targetType = _target.asStaticType;
       if (targetType is InterfaceType) {
-        PropertyAccessorElement getter =
-            targetType.lookUpGetter(_name, _library);
-        if (getter != null) {
-          return getter.returnType;
-        }
-        MethodElement method = targetType.lookUpMethod(_name, _library);
-        if (method != null) {
-          return method.type;
+        ExecutableElement element =
+            targetType.lookUpInheritedGetterOrMethod(_name, library: _library);
+        if (element != null) {
+          if (element is PropertyAccessorElement) {
+            return element.returnType;
+          } else {
+            // Method tear-off
+            return element.type;
+          }
         }
       }
       // TODO(paulberry): handle .call on function types and .toString or
       // .hashCode on all types.
     }
     // TODO(paulberry, scheglov): implement for propagated types
     return DynamicTypeImpl.instance;
   }
 
   @override
@@ skipping 1074 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }