Fix more-specific for interface types with call functions.

pkg/compiler/lib/src/dart_types.dart

 // Copyright (c) 2012, 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 dart_types;
 
 import 'dart:math' show min;
 
 import 'common/resolution.dart' show Resolution;
 import 'common.dart';
@@ skipping 1009 matching lines @@
   }
 
   bool invalidTypeArguments(DartType t, DartType s);
 
   bool invalidFunctionReturnTypes(DartType t, DartType s);
 
   bool invalidFunctionParameterTypes(DartType t, DartType s);
 
   bool invalidTypeVariableBounds(DartType bound, DartType s);
 
+  bool invalidCallableType(DartType callType, DartType s);
+
   /// Handle as dynamic for both subtype and more specific relation to avoid
   /// spurious errors from malformed types.
   bool visitMalformedType(MalformedType t, DartType s) => true;
 
   bool visitInterfaceType(InterfaceType t, DartType s) {
     // TODO(johnniwinther): Currently needed since literal types like int,
     // double, bool etc. might not have been resolved yet.
     t.element.ensureResolved(resolution);
 
     bool checkTypeArguments(InterfaceType instance, InterfaceType other) {
       List<DartType> tTypeArgs = instance.typeArguments;
       List<DartType> sTypeArgs = other.typeArguments;
       assert(tTypeArgs.length == sTypeArgs.length);
       for (int i = 0; i < tTypeArgs.length; i++) {
         if (invalidTypeArguments(tTypeArgs[i], sTypeArgs[i])) {
           return false;
         }
       }
       return true;
     }
 
     if (s is InterfaceType) {
       InterfaceType instance = t.asInstanceOf(s.element);
-      return instance != null && checkTypeArguments(instance, s);
-    } else {
-      return false;
+      if (instance != null && checkTypeArguments(instance, s)) {
+        return true;
+      }
     }
+
+    if (s == coreTypes.functionType && t.element.callType != null) {
+      return true;
+    } else if (s is FunctionType) {
+      FunctionType callType = t.callType;
+      return callType != null && !invalidCallableType(callType, s);
+    }
+
+    return false;
   }
 
   bool visitFunctionType(FunctionType t, DartType s) {
     if (s == coreTypes.functionType) {
       return true;
     }
     if (s is! FunctionType) return false;
     FunctionType tf = t;
     FunctionType sf = s;
     if (invalidFunctionReturnTypes(tf.returnType, sf.returnType)) {
@@ skipping 149 matching lines @@
     return !s.isVoid && !isMoreSpecific(t, s);
   }
 
   bool invalidFunctionParameterTypes(DartType t, DartType s) {
     return !isMoreSpecific(t, s);
   }
 
   bool invalidTypeVariableBounds(DartType bound, DartType s) {
     return !isMoreSpecific(bound, s);
   }
+
+  bool invalidCallableType(DartType callType, DartType s) {
+    return !isMoreSpecific(callType, s);
+  }
 }
 
 /**
  * Type visitor that determines the subtype relation two types.
  */
 class SubtypeVisitor extends MoreSpecificVisitor {
   SubtypeVisitor(Resolution resolution) : super(resolution);
 
   bool isSubtype(DartType t, DartType s) {
     return t.treatAsDynamic || isMoreSpecific(t, s);
@@ skipping 12 matching lines @@
   }
 
   bool invalidFunctionParameterTypes(DartType t, DartType s) {
     return !isAssignable(t, s);
   }
 
   bool invalidTypeVariableBounds(DartType bound, DartType s) {
     return !isSubtype(bound, s);
   }
 
-  bool visitInterfaceType(InterfaceType t, DartType s) {
-    if (super.visitInterfaceType(t, s)) return true;
-
-    if (s == coreTypes.functionType && t.element.callType != null) {
-      return true;
-    } else if (s is FunctionType) {
-      FunctionType callType = t.callType;
-      return callType != null && isSubtype(callType, s);
-    }
-    return false;
+  bool invalidCallableType(DartType callType, DartType s) {
+    return !isSubtype(callType, s);
   }
 }
 
 /**
  * Callback used to check whether the [typeArgument] of [type] is a valid
  * substitute for the bound of [typeVariable]. [bound] holds the bound against
  * which [typeArgument] should be checked.
  */
 typedef void CheckTypeVariableBound(GenericType type, DartType typeArgument,
     TypeVariableType typeVariable, DartType bound);
@@ skipping 734 matching lines @@
           sb.write(', ');
         }
         namedParameterTypes[index].accept(this, namedParameters[index]);
         needsComma = true;
       }
       sb.write('}');
     }
     sb.write(')');
   }
 }