Make ClosureMirror handle instances of user-defined classes that implement call.

runtime/lib/mirrors.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 "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
@@ skipping 138 matching lines @@
   args.SetAt(0, field_ref);
   args.SetAt(1, name);
   args.SetAt(2, owner_mirror);
   args.SetAt(3, Instance::Handle());  // Null for type.
   args.SetAt(4, field.is_static() ? Bool::True() : Bool::False());
   args.SetAt(5, field.is_final()  ? Bool::True() : Bool::False());
 
   return CreateMirror(Symbols::_LocalVariableMirrorImpl(), args);
 }
 
+static RawFunction* CallMethod(const Class& cls) {
+  if (cls.IsSignatureClass()) {
+    return cls.signature_function();
+  }
+
+  Class& lookup_cls = Class::Handle(cls.raw());
+  Function& call_function = Function::Handle();
+  do {
+    call_function = lookup_cls.LookupDynamicFunction(Symbols::Call());
+    if (!call_function.IsNull()) {
+      return call_function.raw();
+    }
+    lookup_cls = lookup_cls.SuperClass();
+  } while (!lookup_cls.IsNull());
+  return Function::null();
+}
 
 static RawInstance* CreateClassMirror(const Class& cls,
                                       const AbstractType& type,
                                       const Instance& owner_mirror) {
   if (cls.IsSignatureClass()) {
     if (cls.IsCanonicalSignatureClass()) {
       // We represent function types as canonical signature classes.
       return CreateFunctionTypeMirror(cls, type);
     } else {
       // We represent typedefs as non-canonical signature classes.
@@ skipping 174 matching lines @@
   }
 
   const Object& metadata = Object::Handle(library.GetMetadata(decl));
   if (metadata.IsError()) {
     ThrowInvokeError(Error::Cast(metadata));
   }
   return metadata.raw();
 }
 
 
+DEFINE_NATIVE_ENTRY(FunctionTypeMirror_call_method, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Instance,
+                               owner_mirror,
+                               arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
+  const Class& cls = Class::Handle(ref.GetClassReferent());
+  const Function& func = Function::Handle(CallMethod(cls));
+  ASSERT(!func.IsNull());
+  return CreateMethodMirror(func, owner_mirror);
+}
+
+
 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_parameters, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& cls = Class::Handle(ref.GetClassReferent());
-  const Function& func = Function::Handle(cls.signature_function());
+  const Function& func = Function::Handle(CallMethod(cls));
+  ASSERT(!func.IsNull());
   return CreateParameterMirrorList(func);
 }
 
 
 DEFINE_NATIVE_ENTRY(FunctionTypeMirror_return_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& cls = Class::Handle(ref.GetClassReferent());
-  const Function& func = Function::Handle(cls.signature_function());
+  const Function& func = Function::Handle(CallMethod(cls));
+  ASSERT(!func.IsNull());
   return func.result_type();
 }
 
 
 static bool FieldIsUninitialized(const Field& field) {
   ASSERT(!field.IsNull());
 
   // Return getter method for uninitialized fields, rather than the
   // field object, since the value in the field object will not be
   // initialized until the first time the getter is invoked.
@@ skipping 395 matching lines @@
   if (obj.IsError()) {
     ThrowInvokeError(Error::Cast(obj));
     UNREACHABLE();
   }
   return obj.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClosureMirror_function, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(0));
-  ASSERT(closure.IsClosure());
+  ASSERT(!closure.IsNull());
 
-  const Function& func = Function::Handle(Closure::function(closure));
-  return CreateMethodMirror(func, Instance::null_instance());
+  Function& function = Function::Handle();
+  bool callable = closure.IsCallable(&function, NULL);
+  ASSERT(callable);
+
+  return CreateMethodMirror(function, Instance::null_instance());
 }
 
 
 static void ThrowNoSuchMethod(const Instance& receiver,
                               const String& function_name,
                               const Function& function,
                               const InvocationMirror::Call call,
                               const InvocationMirror::Type type) {
   const Smi& invocation_type = Smi::Handle(Smi::New(
       InvocationMirror::EncodeType(call, type)));
@@ skipping 446 matching lines @@
 }
 
 
 DEFINE_NATIVE_ENTRY(VariableMirror_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
   return field.type();
 }
 
 }  // namespace dart