improve static type analysis for `await for`

pkg/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 1294 matching lines @@
       List<ParameterElement> parameters,
       List<AstNode> parameterLocations,
       SimpleIdentifier errorNameTarget) {
     bool isGetter = false;
     bool isSetter = false;
     if (executableElement is PropertyAccessorElement) {
       PropertyAccessorElement accessorElement = executableElement;
       isGetter = accessorElement.isGetter;
       isSetter = accessorElement.isSetter;
     }
-    String executableElementName = executableElement.name;
     FunctionType overridingFT = executableElement.type;
     FunctionType overriddenFT = overriddenExecutable.type;
-    InterfaceType enclosingType = _enclosingClass.type;
-    overriddenFT = _inheritanceManager
-        .substituteTypeArgumentsInMemberFromInheritance(
-            overriddenFT, executableElementName, enclosingType);
     if (overridingFT == null || overriddenFT == null) {
       return false;
     }
     DartType overridingFTReturnType = overridingFT.returnType;
     DartType overriddenFTReturnType = overriddenFT.returnType;
     List<DartType> overridingNormalPT = overridingFT.normalParameterTypes;
     List<DartType> overriddenNormalPT = overriddenFT.normalParameterTypes;
     List<DartType> overridingPositionalPT = overridingFT.optionalParameterTypes;
     List<DartType> overriddenPositionalPT = overriddenFT.optionalParameterTypes;
     Map<String, DartType> overridingNamedPT = overridingFT.namedParameterTypes;
@@ skipping 3144 matching lines @@
           continue;
         }
         // Some element was found in the superclass chain that matches the name
         // of the required member.
         // If it is not abstract and it is the correct one (types match- the
         // version of this method that we have has the correct number of
         // parameters, etc), then this class has a valid implementation of this
         // method, so skip it.
         if ((elt is MethodElement && !elt.isAbstract) ||
             (elt is PropertyAccessorElement && !elt.isAbstract)) {
-          // Since we are comparing two function types, we need to do the
-          // appropriate type substitutions first ().
-          FunctionType foundConcreteFT = _inheritanceManager
-              .substituteTypeArgumentsInMemberFromInheritance(
-                  concreteType, memberName, enclosingType);
-          FunctionType requiredMemberFT = _inheritanceManager
-              .substituteTypeArgumentsInMemberFromInheritance(
-                  requiredMemberType, memberName, enclosingType);
-          if (_typeSystem.isSubtypeOf(foundConcreteFT, requiredMemberFT)) {
+          if (_typeSystem.isSubtypeOf(concreteType, requiredMemberType)) {
             continue;
           }
         }
       }
       // The not qualifying concrete executable element was found, add it to the
       // list.
       missingOverrides.add(executableElt);
     }
     // Now that we have the set of missing overrides, generate a warning on this
     // class.
@@ skipping 1566 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }