improve static type analysis for `await for`

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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 engine.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/scanner.dart';
 
@@ skipping 5834 matching lines @@
    */
   ExecutableElement lookupMember(ClassElement classElt, String memberName) {
     ExecutableElement element = _lookupMemberInClass(classElt, memberName);
     if (element != null) {
       return element;
     }
     return lookupInheritance(classElt, memberName);
   }
 
   /**
-   * Given some [InterfaceType] and some member name, this returns the
-   * [FunctionType] of the [ExecutableElement] that the
-   * class either declares itself, or inherits, that has the member name, if no member is inherited
-   * `null` is returned. The returned [FunctionType] has all type
-   * parameters substituted with corresponding type arguments from the given [InterfaceType].
-   *
-   * @param interfaceType the interface type to query
-   * @param memberName the name of the executable element to find and return
-   * @return the member's function type, or `null` if no such member exists
-   */
-  FunctionType lookupMemberType(
-      InterfaceType interfaceType, String memberName) {
-    ExecutableElement iteratorMember =
-        lookupMember(interfaceType.element, memberName);
-    if (iteratorMember == null) {
-      return null;
-    }
-    return substituteTypeArgumentsInMemberFromInheritance(
-        iteratorMember.type, memberName, interfaceType);
-  }
-
-  /**
    * Determine the set of methods which is overridden by the given class member. If no member is
    * inherited, an empty list is returned. If one of the inherited members is a
    * [MultiplyInheritedExecutableElement], then it is expanded into its constituent inherited
    * elements.
    *
    * @param classElt the class to query
    * @param memberName the name of the class member to query
    * @return a list of overridden methods
    */
   List<ExecutableElement> lookupOverrides(
@@ skipping 27 matching lines @@
   /**
    * This method takes some inherited [FunctionType], and resolves all the parameterized types
    * in the function type, dependent on the class in which it is being overridden.
    *
    * @param baseFunctionType the function type that is being overridden
    * @param memberName the name of the member, this is used to lookup the inheritance path of the
    *          override
    * @param definingType the type that is overriding the member
    * @return the passed function type with any parameterized types substituted
    */
+  // TODO(jmesserly): investigate why this is needed in ErrorVerifier's override
+  // checking. There seems to be some rare cases where we get partially
+  // substituted type arguments, and the function types don't compare equally.
   FunctionType substituteTypeArgumentsInMemberFromInheritance(
       FunctionType baseFunctionType,
       String memberName,
       InterfaceType definingType) {
     // if the baseFunctionType is null, or does not have any parameters,
     // return it.
     if (baseFunctionType == null ||
         baseFunctionType.typeArguments.length == 0) {
       return baseFunctionType;
     }
@@ skipping 5651 matching lines @@
    * The given expression is the expression used to compute the iterator for a
    * for-each statement. Attempt to compute the type of objects that will be
    * assigned to the loop variable and return that type. Return `null` if the
    * type could not be determined. The [iteratorExpression] is the expression
    * that will return the Iterable being iterated over.
    */
   DartType _getIteratorElementType(Expression iteratorExpression) {
     DartType expressionType = iteratorExpression.bestType;
     if (expressionType is InterfaceType) {
       InterfaceType interfaceType = expressionType;
-      FunctionType iteratorFunction =
-          _inheritanceManager.lookupMemberType(interfaceType, "iterator");
+      PropertyAccessorElement iteratorFunction =
+          interfaceType.lookUpInheritedGetter("iterator");
       if (iteratorFunction == null) {
         // TODO(brianwilkerson) Should we report this error?
         return null;
       }
       DartType iteratorType = iteratorFunction.returnType;
       if (iteratorType is InterfaceType) {
         InterfaceType iteratorInterfaceType = iteratorType;
-        FunctionType currentFunction = _inheritanceManager.lookupMemberType(
-            iteratorInterfaceType, "current");
+        PropertyAccessorElement currentFunction =
+            iteratorInterfaceType.lookUpInheritedGetter("current");
         if (currentFunction == null) {
           // TODO(brianwilkerson) Should we report this error?
           return null;
         }
         return currentFunction.returnType;
       }
     }
     return null;
   }
 
   /**
    * The given expression is the expression used to compute the stream for an
-   * asyncronous for-each statement. Attempt to compute the type of objects that
-   * will be assigned to the loop variable and return that type. Return `null`
-   * if the type could not be determined. The [streamExpression] is the
-   * expression that will return the stream being iterated over.
+   * asynchronous for-each statement. Attempt to compute the type of objects
+   * that will be assigned to the loop variable and return that type.
+   * Return `null` if the type could not be determined. The [streamExpression]
+   * is the expression that will return the stream being iterated over.
    */
   DartType _getStreamElementType(Expression streamExpression) {
     DartType streamType = streamExpression.bestType;
     if (streamType is InterfaceType) {
-      FunctionType listenFunction =
-          _inheritanceManager.lookupMemberType(streamType, "listen");
+      MethodElement listenFunction = streamType.lookUpInheritedMethod("listen");
       if (listenFunction == null) {
         return null;
       }
       List<ParameterElement> listenParameters = listenFunction.parameters;
       if (listenParameters == null || listenParameters.length < 1) {
         return null;
       }
       DartType onDataType = listenParameters[0].type;
       if (onDataType is FunctionType) {
         List<ParameterElement> onDataParameters = onDataType.parameters;
-        if (onDataParameters == null || onDataParameters.length < 1) {
+        if (onDataParameters == null || onDataParameters.isEmpty) {
           return null;
         }
-        DartType eventType = onDataParameters[0].type;
-        // TODO(paulberry): checking that typeParameters.isNotEmpty is a
-        // band-aid fix for dartbug.com/24191.  Figure out what the correct
-        // logic should be.
-        if (streamType.typeParameters.isNotEmpty &&
-            eventType.element == streamType.typeParameters[0]) {
-          return streamType.typeArguments[0];
-        }
+        return onDataParameters[0].type;
       }
     }
     return null;
   }
 
   /**
    * If given "mayBeClosure" is [FunctionExpression] without explicit parameters types and its
    * required type is [FunctionType], then infer parameters types from [FunctionType].
    */
   void _inferFunctionExpressionParametersTypes(
@@ skipping 1215 matching lines @@
     return false;
   }
 
   @override
   bool isSubtypeOf(DartType leftType, DartType rightType) {
     return _isSubtypeOf(leftType, rightType, null);
   }
 
   FunctionType _getCallMethodType(DartType t) {
     if (t is InterfaceType) {
-      ClassElement element = t.element;
-      InheritanceManager manager = new InheritanceManager(element.library);
-      FunctionType callType = manager.lookupMemberType(t, "call");
-      return callType;
+      return t.lookUpInheritedMethod("call")?.type;
     }
     return null;
   }
 
   // Given a type t, if t is an interface type with a call method
   // defined, return the function type for the call method, otherwise
   // return null.
   _GuardedSubtypeChecker<DartType> _guard(
       _GuardedSubtypeChecker<DartType> check) {
     return (DartType t1, DartType t2, Set<Element> visited) {
@@ skipping 3166 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }