Fix type test for callable objects (issue 7338).

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/bigint_operations.h"
@@ skipping 2007 matching lines @@
 }
 
 
 void Class::set_allocation_stub(const Code& value) const {
   ASSERT(!value.IsNull());
   ASSERT(raw_ptr()->allocation_stub_ == Code::null());
   StorePointer(&raw_ptr()->allocation_stub_, value.raw());
 }
 
 
+bool Class::IsFunctionClass() const {
+  return raw() == Type::Handle(Type::Function()).type_class();
+}
+
+
 bool Class::IsListClass() const {
   return raw() == Isolate::Current()->object_store()->list_class();
 }
 
 
 bool Class::IsCanonicalSignatureClass() const {
   const Function& function = Function::Handle(signature_function());
   return (!function.IsNull() && (function.signature_class() == raw()));
 }
 
@@ skipping 53 matching lines @@
     }
     if (type_arguments.IsNull() ||
         type_arguments.IsRawInstantiatedRaw(len)) {
       return test_kind == kIsSubtypeOf;
     }
     return type_arguments.TypeTest(test_kind,
                                    other_type_arguments,
                                    len,
                                    malformed_error);
   }
-  // TODO(regis): Check if type S has a call() method of function type T.
-  // Check for two function types.
-  if (IsSignatureClass() && other.IsSignatureClass()) {
-    const Function& fun = Function::Handle(signature_function());
+  const bool other_is_function_class = other.IsFunctionClass();
+  if (other.IsSignatureClass() || other_is_function_class) {
     const Function& other_fun = Function::Handle(other.signature_function());
-    return fun.TypeTest(test_kind,
-                        type_arguments,
-                        other_fun,
-                        other_type_arguments,
-                        malformed_error);
+    if (IsSignatureClass()) {
+      if (other_is_function_class) {
+        return true;
+      }
+      // Check for two function types.
+      const Function& fun = Function::Handle(signature_function());
+      return fun.TypeTest(test_kind,
+                          type_arguments,
+                          other_fun,
+                          other_type_arguments,
+                          malformed_error);
+    }
+    // Check if type S has a call() method of function type T.
+    const String& function_name = String::Handle(Symbols::Call());
+    Function& function = Function::Handle(LookupDynamicFunction(function_name));
+    if (function.IsNull()) {
+      // Walk up the super_class chain.
+      Class& cls = Class::Handle(SuperClass());
+      while (!cls.IsNull() && function.IsNull()) {
+        function = cls.LookupDynamicFunction(function_name);
+        cls = cls.SuperClass();
+      }
+    }
+    if (!function.IsNull()) {
+      if (other_is_function_class ||
+          function.TypeTest(test_kind,
+                            type_arguments,
+                            other_fun,
+                            other_type_arguments,
+                            malformed_error)) {
+        return true;
+      }
+    }
   }
   // Check for 'direct super type' specified in the implements clause
   // and check for transitivity at the same time.
   Array& interfaces = Array::Handle(this->interfaces());
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
   AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     interface ^= interfaces.At(i);
     interface_class = interface.type_class();
@@ skipping 10176 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart