Adding proper handling for MethodMirror.owner

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 "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 #include "include/dart_mirrors_api.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"  // TODO(11742): Remove with CreateMirrorRef.
 #include "vm/bootstrap_natives.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/message.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
+static RawInstance* CreateClassMirror(const Class& cls);
+static RawInstance* CreateLibraryMirror(const Library& lib);
+static RawInstance* CreateMethodMirror(const Function& func,
+                                       const Instance& owner_mirror);
+
 inline Dart_Handle NewString(const char* str) {
   return Dart_NewStringFromCString(str);
 }
 
 
 DEFINE_NATIVE_ENTRY(Mirrors_isLocalPort, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, port, arguments->NativeArgAt(0));
 
   // Get the port id from the SendPort instance.
   const Object& id_obj = Object::Handle(DartLibraryCalls::PortGetId(port));
@@ skipping 981 matching lines @@
     Dart_Handle args[] = {
       CreateVMReference(instance),
       CreateLazyMirror(instance_cls),
       instance,
     };
     return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   }
 }
 
 
+// TODO(11742): At some point the function taking native parameters will replace
+// the version that uses API handles.
+static RawInstance* CreateClassMirror(const Class& cls) {

[siva, 2013/07/18 20:32:34]

Change the signature of the method to the final form that we want for this
function.

[Michael Lippautz (Google), 2013/07/18 22:01:23]

Done.

+  Dart_EnterScope();
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);

[siva, 2013/07/18 20:32:34]

As discussed it is not necessary to have this DARTSCOPE check here.

[Michael Lippautz (Google), 2013/07/18 22:01:23]

Done.

+  Dart_Handle cls_handle = Api::NewHandle(isolate, cls.raw());
+  if (Dart_IsError(cls_handle)) {
+    Dart_PropagateError(cls_handle);
+  }
+  Dart_Handle name_handle = Api::NewHandle(isolate, cls.Name());
+  if (Dart_IsError(name_handle)) {
+    Dart_PropagateError(name_handle);
+  }
+  Dart_Handle lib_handle = Api::NewHandle(isolate, cls.library());
+  if (Dart_IsError(lib_handle)) {
+    Dart_PropagateError(lib_handle);
+  }
+  Dart_Handle lib_mirror = CreateLibraryMirror(lib_handle);
+  if (Dart_IsError(lib_mirror)) {
+    Dart_PropagateError(lib_mirror);
+  }

[siva, 2013/07/18 20:32:34]

I think the TODO comment above should end up here stating that this call will go
away and be replaced by inlined functionality.

[Michael Lippautz (Google), 2013/07/18 22:01:23]

Done.

+  Dart_Handle result =  CreateClassMirror(cls_handle,
+                                          name_handle,
+                                          lib_handle,
+                                          lib_mirror);

[siva, 2013/07/18 20:32:34]

As discussed offline we should probably call this version of
CreateClassMirror, CreateClassMirrorUsingAPI or something like that so that it
is explicit that this method is going away.

[Michael Lippautz (Google), 2013/07/18 22:01:23]

Done.

+  if (Dart_IsError(result)) {
+    Dart_PropagateError(result);
+  }
+  const Instance& retvalue = Api::UnwrapInstanceHandle(isolate, result);
+  Dart_ExitScope();
+  return retvalue.raw();
+}
+
+
+// TODO(11742): At some point the function taking native parameters will replace
+// the version that uses API handles.
+static RawInstance* CreateLibraryMirror(const Library& lib) {

[siva, 2013/07/18 20:32:34]

Ditto comment about the signature here, you want it to be in the final form.

[Michael Lippautz (Google), 2013/07/18 22:01:23]

Done.

+  Dart_EnterScope();
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Dart_Handle lib_handle = Api::NewHandle(isolate, lib.raw());
+  Dart_Handle result = CreateLibraryMirror(lib_handle);
+  if (Dart_IsError(result)) {
+    Dart_PropagateError(result);
+  }
+  const Instance& retvalue = Api::UnwrapInstanceHandle(isolate, result);
+  Dart_ExitScope();
+  return retvalue.raw();
+}
+
+
+// TODO(11742): At some point the function taking native parameters will replace
+// the version that uses API handles.
+static RawInstance* CreateMethodMirror(const Function& func,
+                                       const Instance& owner_mirror) {
+  Dart_EnterScope();
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Dart_Handle func_handle = Api::NewHandle(isolate, func.raw());
+  Dart_Handle owner_handle = Api::NewHandle(isolate, owner_mirror.raw());
+  Dart_Handle result = CreateMethodMirror(func_handle, owner_handle);
+  if (Dart_IsError(result)) {
+    Dart_PropagateError(result);
+  }
+  const Instance& retvalue = Api::UnwrapInstanceHandle(isolate, result);
+  Dart_ExitScope();
+  return retvalue.raw();
+}
+
+
 void NATIVE_ENTRY_FUNCTION(Mirrors_makeLocalMirrorSystem)(
     Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_Handle mirrors = CreateMirrorSystem();
   if (Dart_IsError(mirrors)) {
     Dart_PropagateError(mirrors);
   }
   Dart_SetReturnValue(args, mirrors);
   Dart_ExitScope();
 }
@@ skipping 753 matching lines @@
 
 
 DEFINE_NATIVE_ENTRY(MethodMirror_name, 1) {
   const MirrorReference& func_ref =
       MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
   Function& func = Function::Handle();
   func ^= func_ref.referent();
   return func.UserVisibleName();
 }
 
+
+DEFINE_NATIVE_ENTRY(MethodMirror_owner, 1) {
+  const MirrorReference& func_ref =
+      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
+  Function& func = Function::Handle();
+  func ^= func_ref.referent();

[siva, 2013/07/18 20:32:34]

I see this pattern a lot I am wondering if it makes sense to
have some helper functions

e.g:

const Function func =
Function::Handle(MirrorReference::GetFunctionReferent(arguments->NativeArgAt(0)));

And GetFunctionReferent could be something like:
GetFunctionReferent(RawObject* raw_ptr) {
  const MirrorReference& ref = MirrorReference::CheckedHandle(raw_ptr);
  ASSERT(Object::Handle(ref.referent().IsFunction());
  return ref.referent();

}

maybe do this in a different CL.

[Michael Lippautz (Google), 2013/07/18 22:01:23]

Will try to incorporate in another CL.

+  if (func.IsNonImplicitClosureFunction()) {
+    return CreateMethodMirror(Function::Handle(
+        func.parent_function()), Instance::Handle(Instance::null()));
+  }
+  const Class& owner = Class::Handle(func.Owner());
+  if (owner.IsTopLevel()) {
+    return CreateLibraryMirror(Library::Handle(owner.library()));
+  }
+  return CreateClassMirror(owner);
+}
+
 }  // namespace dart