Make FunctionTypeMirror and ClosureMirror handle user-defined classes that implement the call opera…

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/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
@@ skipping 89 matching lines @@
 
 static RawInstance* CreateTypedefMirror(const Class& cls,
                                         const Instance& owner_mirror) {
   const Array& args = Array::Handle(Array::New(3));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, String::Handle(cls.UserVisibleName()));
   args.SetAt(2, owner_mirror);
   return CreateMirror(Symbols::_LocalTypedefMirrorImpl(), args);
 }
 
-
-static RawInstance* CreateFunctionTypeMirror(const Class& cls) {
-  const Array& args = Array::Handle(Array::New(1));
+static RawInstance* CreateFunctionTypeMirror(const Class& cls,
+                                             const Instance& owner_mirror) {
+  const Array& args = Array::Handle(Array::New(2));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
+  args.SetAt(1, owner_mirror);
   return CreateMirror(Symbols::_LocalFunctionTypeMirrorImpl(), args);
 }
 
+static RawInstance* CreateClosureTypeMirror(const Class& cls) {
+  const Array& args = Array::Handle(Array::New(1));
+  args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
+  return CreateMirror(Symbols::_LocalClosureTypeMirrorImpl(), args);
+}
 
+
 static RawInstance* CreateMethodMirror(const Function& func,
                                        const Instance& owner_mirror) {
   const Array& args = Array::Handle(Array::New(12));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
   args.SetAt(1, String::Handle(func.UserVisibleName()));
   args.SetAt(2, owner_mirror);
   args.SetAt(3, func.is_static() ? Bool::True() : Bool::False());
   args.SetAt(4, func.is_abstract() ? Bool::True() : Bool::False());
   args.SetAt(5, func.IsGetterFunction() ? Bool::True() : Bool::False());
   args.SetAt(6, func.IsSetterFunction() ? Bool::True() : Bool::False());
@@ skipping 18 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) {

[rmacnak, 2013/08/06 20:22:31]

Compare Instance::IsCallable().

+  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 Instance& owner_mirror) {
   if (cls.IsSignatureClass()) {
     if (cls.IsCanonicalSignatureClass()) {
       // We represent function types as canonical signature classes.
-      return CreateFunctionTypeMirror(cls);
+      return CreateClosureTypeMirror(cls);
     } else {
       // We represent typedefs as non-canonical signature classes.
       return CreateTypedefMirror(cls, owner_mirror);
     }
   }
 
+  const Function& call_function = Function::Handle(CallMethod(cls));
+  if (!call_function.IsNull()) {
+    // A user-defined class that implements the call operator.
+    return CreateFunctionTypeMirror(cls, owner_mirror);
+  }
+
   const Array& args = Array::Handle(Array::New(2));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, String::Handle(cls.UserVisibleName()));
   return CreateMirror(Symbols::_LocalClassMirrorImpl(), args);
 }
 
 
 static RawInstance* CreateLibraryMirror(const Library& lib) {
   const Array& args = Array::Handle(Array::New(3));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(lib)));
@@ skipping 137 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));
+  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));
   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));
   const AbstractType& return_type = AbstractType::Handle(func.result_type());
   return CreateTypeMirror(return_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
@@ skipping 368 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);

[rmacnak, 2013/08/06 20:22:31]

Use CallMethod() instead?

+  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 453 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());
 
   const AbstractType& type = AbstractType::Handle(field.type());
   return CreateTypeMirror(type);
 }
 
 }  // namespace dart