A type should be a subtype of Function if its class declares a call function,

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 3672 matching lines @@
       return type_arguments.TypeTest(test_kind,
                                      other_type_arguments,
                                      from_index,
                                      num_type_params,
                                      bound_error,
                                      bound_trail,
                                      space);
     }
     if (other.IsFunctionClass()) {
       // Check if type S has a call() method.
-      Function& function =
-          Function::Handle(zone, thsi.LookupDynamicFunction(Symbols::Call()));
+      Function& function = Function::Handle(zone,
+          thsi.LookupDynamicFunctionAllowAbstract(Symbols::Call()));
       if (function.IsNull()) {
         // Walk up the super_class chain.
         Class& cls = Class::Handle(zone, thsi.SuperClass());
         while (!cls.IsNull() && function.IsNull()) {
-          function = cls.LookupDynamicFunction(Symbols::Call());
+          function = cls.LookupDynamicFunctionAllowAbstract(Symbols::Call());
           cls = cls.SuperClass();
         }
       }
       if (!function.IsNull()) {
         return true;
       }
     }
     // Check for 'direct super type' specified in the implements clause
     // and check for transitivity at the same time.
     Array& interfaces = Array::Handle(zone, thsi.interfaces());
@@ skipping 102 matching lines @@
 bool Class::IsPrivate() const {
   return Library::IsPrivate(String::Handle(Name()));
 }
 
 
 RawFunction* Class::LookupDynamicFunction(const String& name) const {
   return LookupFunction(name, kInstance);
 }
 
 
+RawFunction* Class::LookupDynamicFunctionAllowAbstract(
+    const String& name) const {
+  return LookupFunction(name, kInstanceAllowAbstract);
+}
+
+
 RawFunction* Class::LookupDynamicFunctionAllowPrivate(
     const String& name) const {
   return LookupFunctionAllowPrivate(name, kInstance);
 }
 
 
 RawFunction* Class::LookupStaticFunction(const String& name) const {
   return LookupFunction(name, kStatic);
 }
 
@@ skipping 52 matching lines @@
   for (intptr_t i = 0, j = prefix_length; i < accessor_name_len; i++, j++) {
     if (name.CharAt(j) != accessor_name.CharAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawFunction* Class::CheckFunctionType(const Function& func, MemberKind kind) {
-  if (kind == kInstance) {
-    if (func.IsDynamicFunction()) {
+  if ((kind == kInstance) || (kind == kInstanceAllowAbstract)) {
+    if (func.IsDynamicFunction(kind == kInstanceAllowAbstract)) {
       return func.raw();
     }
   } else if (kind == kStatic) {
     if (func.IsStaticFunction()) {
       return func.raw();
     }
   } else if (kind == kConstructor) {
     if (func.IsGenerativeConstructor()) {
       ASSERT(!func.is_static());
       return func.raw();
@@ skipping 10376 matching lines @@
       instantiated_other = TypeRef::Cast(instantiated_other).type();
     }
     if (instantiated_other.IsDynamicType()) {
       return true;
     }
   }
   other_type_arguments = instantiated_other.arguments();
   const bool other_is_dart_function = instantiated_other.IsDartFunctionType();
   if (other_is_dart_function || instantiated_other.IsFunctionType()) {
     // Check if this instance understands a call() method of a compatible type.
-    Function& call =
-        Function::Handle(zone, cls.LookupDynamicFunction(Symbols::Call()));
+    Function& call = Function::Handle(zone,
+        cls.LookupDynamicFunctionAllowAbstract(Symbols::Call()));
     if (call.IsNull()) {
       // Walk up the super_class chain.
       Class& super_cls = Class::Handle(zone, cls.SuperClass());
       while (!super_cls.IsNull() && call.IsNull()) {
-        call = super_cls.LookupDynamicFunction(Symbols::Call());
+        call = super_cls.LookupDynamicFunctionAllowAbstract(Symbols::Call());
         super_cls = super_cls.SuperClass();
       }
     }
     if (!call.IsNull()) {
       if (other_is_dart_function) {
         return true;
       }
       const Function& other_signature = Function::Handle(
           zone, FunctionType::Cast(instantiated_other).signature());
       if (call.IsSubtypeOf(type_arguments,
@@ skipping 740 matching lines @@
       const Function& fun =
           Function::Handle(zone, FunctionType::Cast(*this).signature());
       return fun.TypeTest(test_kind,
                           TypeArguments::Handle(zone, arguments()),
                           other_fun,
                           TypeArguments::Handle(zone, other.arguments()),
                           bound_error,
                           space);
     }
     // Check if type S has a call() method of function type T.
-    Function& function =
-        Function::Handle(zone, type_cls.LookupDynamicFunction(Symbols::Call()));
+    Function& function = Function::Handle(zone,
+        type_cls.LookupDynamicFunctionAllowAbstract(Symbols::Call()));
     if (function.IsNull()) {
       // Walk up the super_class chain.
       Class& cls = Class::Handle(zone, type_cls.SuperClass());
       while (!cls.IsNull() && function.IsNull()) {
-        function = cls.LookupDynamicFunction(Symbols::Call());
+        function = cls.LookupDynamicFunctionAllowAbstract(Symbols::Call());
         cls = cls.SuperClass();
       }
     }
     if (!function.IsNull()) {
       if (other_is_dart_function_type ||
           function.TypeTest(test_kind,
                             TypeArguments::Handle(zone, arguments()),
                             Function::Handle(
                                 zone, FunctionType::Cast(other).signature()),
                             TypeArguments::Handle(zone, other.arguments()),
@@ skipping 6410 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart